Roblox Collision Summaries API: Detailed Physics Data From the Engine

Roblox’s BasePart:BindToCollisionSummaries() API gives creators access to detailed contact information produced by the physics engine. Instead of learning only that two parts touched, a script can inspect the contact point, surface normal, relative velocity, contact area, and simulation time. That makes the API useful for impact effects, responsive audio, vehicle physics, breakable objects, and more precise combat interactions.

What is the Roblox Collision Summaries API?

Announced by Roblox on October 6, 2026, BasePart:BindToCollisionSummaries(callback) subscribes a part to detailed collision summaries. After the physics simulation step, Roblox invokes the callback with an array of summaries for the contacts involving that subscribed part. The method returns an RBXScriptConnection, which you can disconnect when you no longer need collision data.

This is a separate mechanism from Touched. The traditional event tells a script that contact occurred, while collision summaries expose information about where the contact happened and how the parts were moving relative to each other.

What information does each collision summary contain?

How to use BindToCollisionSummaries in Roblox Studio

Place a Script or LocalScript in an appropriate location and subscribe a part that is in Workspace. The following example checks the incoming speed along the contact normal and prints the location of a strong impact.

local part = workspace:WaitForChild("ImpactPart")

local function onCollision(summaries)
    for _, summary in summaries do
        local impactSpeed = summary.RelativeVelocity:Dot(summary.Normal)

        if impactSpeed > 10 then
            print("Strong impact at", summary.Point)
            print("Impact speed:", impactSpeed)
            print("Other part:", summary.Part1:GetFullName())
        end
    end
end

local connection = part:BindToCollisionSummaries(onCollision)

-- Disconnect when this part no longer needs collision monitoring:
-- connection:Disconnect()

The threshold in this example is only a starting point. Test different values against your game’s scale, object mass, and expected movement speeds. The API reports relative velocity; it does not directly return a damage value or a physical force.

How to calculate impact strength and detect sliding

For a head-on impact measurement, take the dot product of RelativeVelocity and Normal. The projection represents the relative speed along the contact normal. The component tangent to the normal can help distinguish a glancing collision or sliding contact from a direct hit.

local relativeVelocity = summary.RelativeVelocity
local normal = summary.Normal

local normalSpeed = relativeVelocity:Dot(normal)
local tangentVelocity =
    relativeVelocity - normal * normalSpeed

local slidingSpeed = tangentVelocity.Magnitude

print("Normal speed:", normalSpeed)
print("Sliding speed:", slidingSpeed)

Use the sign and magnitude deliberately: the direction of the normal and the relative-velocity convention matter when deciding whether parts are approaching or separating. For gameplay logic, validate the result with controlled test collisions instead of assuming every large magnitude represents damage.

Practical uses for game developers

• Impact particles: Spawn sparks, dust, debris, or impact flashes at the reported contact point and orient them using the normal.
• Dynamic sound: Choose impact sounds or volume based on relative impact speed and the materials involved.
• Breakable props: Decide whether an object should crack or break based on a tuned impact threshold and the part’s mass.
• Vehicle handling: Detect wheel, chassis, or body contacts and build more responsive collision feedback.
• Combat hit feedback: Use the contact location and direction to create more convincing hit reactions when the relevant part is simulated by that client or server.
• Sliding and friction effects: Use the tangential velocity component to trigger tire marks, scraping sounds, or surface effects.

Important limitations and performance notes

• It is not a replacement event for every Touched use case. Collision summaries provide physics contact details, but their reporting rules differ from touch events.
• Network ownership matters. Summaries are generated where the physics simulation runs, such as the owning client or the server. They are not automatically replicated to other clients. If another machine needs the result, send only the necessary data through your own RemoteEvent or other networking design.
• CanCollide must allow physical contact. Parts with CanCollide = false do not produce collision summaries.
• Sleeping contacts are omitted. Contacts between two sleeping parts are not recorded.
• Complex geometry can create multiple records. Non-convex collision geometry may produce multiple summaries for a pair of parts, and Terrain contacts can be split by contact normal.
• One callback can contain multiple substeps. Physics may run multiple substeps per rendered frame. Use the Time field to order summaries when needed.
• Keep subscriptions focused. Roblox says contact-recording overhead scales with the number of subscribed parts rather than the total number of collisions in the scene. Subscribe only to parts that need the data, and disconnect unused connections.
• The callback data is read-only. Summary objects are frozen; treat them as immutable records.

Collision Summaries API vs. Touched

Use Touched when its event semantics are what your experience needs. Choose collision summaries when your system needs contact geometry or relative motion data. Do not call BindToCollisionSummaries() from inside a Touched handler; Roblox documents it as a separate subscription API.

Frequently asked questions

Does BindToCollisionSummaries run every frame?

The callback is invoked at most once per frame after the physics step when the subscribed part has collision summaries to report. Its array can include multiple contacts and multiple physics substeps.

Does the API replicate collision data to every player?

No. The summaries are generated on the network owner running the physics simulation and are not automatically replicated. Send selected information yourself if another client or the server needs it.

Can I use it on a part with CanCollide set to false?

No collision summaries are produced for parts whose CanCollide property is false. This API is for physical contacts, not a general-purpose overlap query.

How do I stop receiving collision summaries?

Keep the RBXScriptConnection returned by the method and call Disconnect() when monitoring is no longer required. Destroying the subscribed part also disconnects its subscriptions.

Is collision area always greater than zero?

No. The estimated area can be zero for a contact patch with fewer than three points, such as an edge or corner contact.

Official Roblox references

• Roblox announcement: Collision Summaries API – Detailed Collision Data From The Engine
• Roblox Creator Hub: BasePart API reference
• Roblox Creator Hub: Collisions documentation
• Roblox Creator Hub: Creator Updates

Author: Shivam Das