Roblox Physics

roblox-physics

Official sources (always check these for the latest):

• https://create.roblox.com/docs/physics
• https://create.roblox.com/docs/physics/assemblies
• https://create.roblox.com/docs/physics/mechanical-constraints
• https://create.roblox.com/docs/physics/mover-constraints
• https://create.roblox.com/docs/physics/network-ownership
• https://create.roblox.com/docs/physics/sleep-system
• https://create.roblox.com/docs/physics/adaptive-timestepping
• https://create.roblox.com/docs/physics/units
• https://create.roblox.com/docs/workspace/collisions

This skill covers the modern constraint-based physics system, not deprecated BodyMover objects. It focuses on building correct, stable, multiplayer-safe mechanisms.

When to use this skill

Activate when:

• Building vehicles, doors, elevators, cranes, swings, suspension, or platforms.
• Moving objects with forces instead of setting CFrame every frame.
• Tuning stability for complex mechanisms or multiplayer physics.
• Choosing between mechanical and mover constraints.
• Debugging why assemblies sleep, jitter, or behave unexpectedly.

Cross-reference:

• roblox-networking/SKILL.md for network ownership security and server-authoritative validation.
• roblox-core/SKILL.md for services and script locations.
• roblox-testing/SKILL.md for profiling physics with MicroProfiler.

Core concepts

Assemblies

An assembly is one or more parts connected by rigid welds or movable joints, simulated as a single rigid body.

Key BasePart properties (same for any part in the assembly):

• AssemblyLinearVelocity / AssemblyAngularVelocity — prefer constraints or ApplyImpulse over direct assignment for realistic motion.
• AssemblyCenterOfMass — force here produces pure linear acceleration.
• AssemblyMass — sum of all part masses; infinite if any part is anchored.
• AssemblyRootPart — automatically chosen root for replication and network ownership.

Root-part priority: anchored > non-massless > higher RootPriority > size/name heuristics.

Anchoring

• Anchoring one part in an assembly makes it the root; the rest are implicitly anchored.
• Anchoring multiple parts in the same assembly splits it.
• To anchor an entire assembly, only anchor the root part.

Collision filtering

Use collision groups (PhysicsService:RegisterCollisionGroup, BasePart.CollisionGroup) or NoCollisionConstraint for part-to-part filtering. CanCollide, CanTouch, and CanQuery control different behaviors; see references/collisions-and-filtering.md.

Mechanical constraints

All mechanical constraints connect one or two Attachments (or Bones), except WeldConstraint and NoCollisionConstraint which use Part0/Part1.

See references/mechanical-constraints.md for creation, orientation, motor/servo tuning, and limits.

Mover constraints

Modern replacements for deprecated BodyMovers:

See references/mover-constraints.md for force modes (Magnitude vs PerAxis), relativity frames, rigidity, and reaction forces.

Network ownership

• The server owns anchored parts.
• Unanchored parts near a player character are automatically owned by that client.
• Set ownership explicitly with BasePart:SetNetworkOwner(player) (server only). Reset with SetNetworkOwnershipAuto().
• Assign vehicle/driver ownership carefully: the first seated player may own the whole assembly otherwise.

Security: clients can exploit owned parts (teleport, fake collisions). Validate gameplay-critical events server-side. See references/network-ownership.md.

Sleep system

Assemblies stop simulating when still to save performance. They wake on collisions, property changes, impulses, or gravity/wind changes.

• If a slow mechanism falls asleep, increase motion or use actuated joints (motor/servo constraints) which get stricter sleep thresholds.
• Visualize sleep states with Awake parts in Studio's Visualization Options.

Physics stepping method

Workspace.PhysicsSteppingMethod:

• Fixed (default, 240 Hz) — best general choice; use for racing, destruction, tanks, or when most parts already solve at 240 Hz.
• Adaptive — assigns assemblies to 60/120/240 Hz islands for up to ~2.5× performance in suitable experiences.

Use the MicroProfiler to check island distribution.

Units quick reference

See references/units-and-physical-properties.md.

Common mistakes this skill prevents

• Using deprecated BodyMovers instead of modern constraints.
• Setting CFrame every frame instead of using forces/constraints.
• Anchoring every part in an assembly (splits it and hurts performance).
• Ignoring network ownership on vehicles and then wondering why input lags.
• Trusting Touched events from client-owned parts for damage/authority.
• Letting actuated joints fall asleep prematurely.

Scripts

• scripts/VehicleController.lua — chassis setup with HingeConstraint steering and motor drive, with client ownership and server validation.
• scripts/DoorHinge.lua — motorized/servo door with limits and state machine.
• scripts/PlatformMover.lua — AlignPosition + AlignOrientation platform with configurable waypoints.
• scripts/Suspension.lua — spring-damper suspension using SpringConstraint.

How to proceed

1. Decide if the object is a rigid mechanism (mechanical constraint) or force-driven (mover constraint). 2. Plan assemblies, root parts, and anchoring strategy. 3. Set network ownership for multiplayer responsiveness. 4. Tune forces/velocities using units and physical properties. 5. Profile with MicroProfiler and watch sleep/ownership visualizations.

Collisions and Filtering

Official guide: https://create.roblox.com/docs/workspace/collisions

Collision events

• BasePart.Touched — fires when another part touches.
• BasePart.TouchEnded — fires when contact ends.
• These fire regardless of CanCollide.

Collision filtering

Collision groups

local PhysicsService = game:GetService("PhysicsService")

PhysicsService:RegisterCollisionGroup("Players")
PhysicsService:RegisterCollisionGroup("Projectiles")

PhysicsService:CollisionGroupSetCollidable("Players", "Projectiles", false)

PhysicsService:SetPartCollisionGroup(part, "Projectiles")

Useful for team-specific collisions, projectile passthrough, etc.

NoCollisionConstraint

Disable collisions between two specific parts without managing groups:

local noCollide = Instance.new("NoCollisionConstraint")
noCollide.Part0 = partA
noCollide.Part1 = partB
noCollide.Parent = partA

CanCollide, CanTouch, CanQuery

Important: these are not confidentiality controls. They affect physics and queries, not replication or rendering.

Detecting collisions safely

For gameplay-critical collisions, prefer server-side checks or Shapecasts/Raycasts over Touched events, especially when the touching part is client-owned.

local function onTouched(otherPart)
    if otherPart:IsDescendantOf(someSafeModel) then
        return
    end
    -- validate distance, ownership, etc.
end

Mechanical Constraints

Official guide: https://create.roblox.com/docs/physics/mechanical-constraints

Creating constraints

Most mechanical constraints require two Attachment instances (or Bone instances). The constraint's behavior depends on attachment orientation:

• Axis (yellow arrow) defines primary rotation/translation axes.
• SecondaryAxis defines secondary orientation.

You can create constraints via: 1. Studio Constraint Picker in the Model tab. 2. Explorer → insert constraint → link Attachment0/Attachment1 (or Part0/Part1 for Weld/NoCollision).

Constraint reference

WeldConstraint

• Connects Part0 and Part1 rigidly.
• Maintains relative position and orientation.
• Deactivates if parts are anchored into different assemblies.
• No attachments needed.

RigidConstraint

• Attachment-based rigid connection.
• Supports Bones for skinned mesh applications.
• Same relative transform behavior as WeldConstraint.

HingeConstraint

• Rotates around one shared axis.
• Motor mode: target AngularVelocity with acceleration/torque limits.
• Servo mode: target TargetAngle with speed/torque limits.
• LimitsEnabled + LowerAngle/UpperAngle/Restitution for swing doors, levers, etc.

Tip: make sure both attachments' Axis properties point the same direction.

PrismaticConstraint

• Slides along one axis, no rotation.
• Motor/servo modes for elevators, pistons, drawers.
• Use LimitsEnabled to define slide range.

CylindricalConstraint

• Combines prismatic slide + hinge rotation.
• Separate linear and angular actuator controls.
• Useful for landing gear, hydraulic arms, screw mechanisms.

SpringConstraint

• Applies force based on displacement and relative velocity.
• FreeLength is the rest length.
• Stiffness and Damping tune oscillation.
• Optional MinLength/MaxLength.
• Units: stiffness ≈ 0.0456 RMU/s² per N/m; damping ≈ 0.0456 RMU/s per N·s/m.

TorsionSpringConstraint

• Applies torque based on angular displacement and velocity.
• Useful for torsion bars, rotational return springs.

BallSocketConstraint

• Same position, free rotation on all axes.
• Optional cone/limit constraints.

UniversalConstraint

• Keeps two axes perpendicular.
• Common in drive shafts and robotics.

RopeConstraint

• Prevents attachments from separating beyond Length.
• WinchEnabled allows motorized length change.

RodConstraint

• Maintains fixed separation distance.
• Optional tilt limits.

PlaneConstraint

• Constrains motion to a plane defined by attachment orientation.

NoCollisionConstraint

• Disables collisions between Part0 and Part1.
• Both parts still collide with the rest of the world.

Actuator types

Most powered constraints support:

• None — passive constraint, no force applied.
• Motor — continuous motion toward a velocity.
• Servo — moves to and holds a target position/angle.

Tuning parameters:

• MaxForce / MaxTorque — caps applied force.
• MotorMaxAcceleration / MotorMaxForce — motor responsiveness.
• Responsiveness — servo stiffness.
• Restitution — bounciness at limits.

Constraint visualization

Enable in Studio:

• Show Welds (Alt+W / ⌥+W)
• Show Constraint Details (Alt+D / ⌥+D)
• Assemblies / Mechanisms in Visualization Options

Use these to debug orientation, root parts, and ownership.

Luau example: powered hinge door

local hinge = script.Parent:WaitForChild("HingeConstraint")

-- Open 90 degrees
hinge.ActuatorType = Enum.ActuatorType.Servo
hinge.ServoMaxTorque = 5000
hinge.AngularSpeed = 2
hinge.TargetAngle = 90

-- Close
hinge.TargetAngle = 0

Luau example: spring-damper suspension

local spring = script.Parent:WaitForChild("SpringConstraint")
spring.Stiffness = 5000
spring.Damping = 500
spring.FreeLength = 3

Mover Constraints

Official guide: https://create.roblox.com/docs/physics/mover-constraints

Mover constraints apply force, velocity, torque, or alignment to assemblies. They are the modern replacement for deprecated BodyMover objects.

Migration table

AlignPosition

Moves Attachment0 toward Attachment1 or a world Position.

Key properties:

• Mode — TwoAttachment or OneAttachment.
• RigidityEnabled — if true, solver does whatever it takes; if false, use MaxForce, MaxVelocity, Responsiveness.
• ForceLimitMode — Magnitude (scalar MaxForce) or PerAxis (vector MaxAxesForce).
• ApplyAtCenterOfMass — apply at CoM instead of attachment point.
• ReactionForceEnabled — apply equal/opposite force to Attachment1.

AlignOrientation

Aligns Attachment0 orientation with Attachment1 or a goal orientation.

Key properties:

• AlignType — PrimaryAxisParallel, PrimaryAxisPerpendicular, or AllAxes.
• RigidityEnabled, MaxTorque, MaxAngularVelocity, Responsiveness.
• LookAtPosition — separate Vector3 that points Attachment0's primary axis at a world position (use with OneAttachment mode and a target orientation).

LinearVelocity

Maintains constant linear velocity on an assembly.

• VelocityConstraintMode:
• Vector — 3D velocity vector.
• Line — velocity along attachment axis.
• Plane — velocity within a plane.
• RelativeTo — world, Attachment0, Attachment1.
• ForceLimitMode / MaxForce / MaxAxesForce.

Warning: this applies force to maintain velocity. For one-time velocity, use ApplyImpulse or set AssemblyLinearVelocity.

AngularVelocity

Maintains constant angular velocity.

• AngularVelocity vector in rad/s (relative to RelativeTo).
• MaxTorque.
• RelativeTo.

VectorForce

Applies constant force.

• Force vector.
• RelativeTo — world or attachment frame.
• Apply at attachment point or CoM depending on setup.

Torque

Applies constant torque about the assembly's center of mass.

• Torque vector.
• RelativeTo.

LineForce

Applies force along the line connecting two attachments.

• InverseSquareLaw — falloff with distance (like gravity/magnetism).
• Magnitude.
• ApplyAtCenterOfMass.

AnimationConstraint

Drives attachments by a target CFrame offset. Useful for animation-driven physics.

• IsKinematic — kinematic or force-based.
• MaxForce / MaxTorque.

Choosing a mover

Luau example: hover platform

local alignPos = script.Parent:WaitForChild("AlignPosition")
local alignOrn = script.Parent:WaitForChild("AlignOrientation")

alignPos.RigidityEnabled = false
alignPos.MaxForce = 100000
alignPos.MaxVelocity = 50
alignPos.Responsiveness = 50
alignPos.Position = Vector3.new(0, 10, 0)

alignOrn.RigidityEnabled = false
alignOrn.MaxTorque = 100000
alignOrn.MaxAngularVelocity = 5
alignOrn.Responsiveness = 50

Network Ownership

Official guide: https://create.roblox.com/docs/physics/network-ownership

What ownership does

Roblox uses distributed physics. Each unanchored assembly is simulated by either the server or a client. The owner simulates locally and replicates state.

• Server-owned — authoritative, higher latency for clients.
• Client-owned — responsive for that player, but exploitable.
• Anchored parts are always server-owned.

Automatic ownership

By default, unanchored parts near a player's character are owned by that client. Ownership can transfer as characters move.

Manual ownership

Server-side only:

part:SetNetworkOwner(player)     -- assign to a player
part:SetNetworkOwnershipAuto()   -- revert to engine defaults
part:GetNetworkOwner()           -- get current owner

Rules:

• You can only set ownership on an unanchored assembly root.
• Anchoring resets ownership to server.
• Setting ownership on one assembly in a mechanism sets ownership for the whole mechanism.

Common vehicle pattern

When a player sits in a VehicleSeat, give them ownership so driving feels responsive:

local Players = game:GetService("Players")
local vehicleSeat = script.Parent

vehicleSeat:GetPropertyChangedSignal("Occupant"):Connect(function()
    local humanoid = vehicleSeat.Occupant
    if humanoid then
        local player = Players:GetPlayerFromCharacter(humanoid.Parent)
        if player then
            vehicleSeat:SetNetworkOwner(player)
        end
    else
        vehicleSeat:SetNetworkOwnershipAuto()
    end
end)

Also assign ownership of loose parts on the vehicle (e.g., cargo) to the same driver.

Security implications

• Clients can teleport or warp owned parts.
• Touched events fired by client-owned parts can be faked.
• Do not use client-owned physics for authoritative damage, scoring, or checkpoints.
• Validate important gameplay events on the server using position/distance/time checks.

Visualization

Enable Network owners in Visualization Options. Colors are shown per-assembly:

• Blue — the local player owns the assembly.
• Green — another client owns the assembly.
• Red — buffer zone, pending transfer.
• White/grey — server owns the assembly.
• Black — no owner (not simulated).

Debugging tips

• If a vehicle feels laggy for the driver, check that the driver owns it.
• If a mechanism jitters, ensure all connected assemblies share the same owner.
• If a part is black, it may be massless with no owner; anchor it or give it physical significance.

Units and Physical Properties

Official guide: https://create.roblox.com/docs/physics/units

Primary units

Derived units

Gravity presets

Physical property limits

Consistency

Use standard Roblox units throughout an experience. Custom interpretations (e.g., 1 stud = 1 foot) require recalibrating all physics constants and can break compatibility with default character controllers.

Custom physical properties

local props = PhysicalProperties.new(
    0.7,  -- density
    0.3,  -- friction
    0.5,  -- elasticity
    1.0,  -- frictionWeight
    1.0   -- elasticityWeight
)
part.CustomPhysicalProperties = props

Set CustomPhysicalProperties = nil to revert to material defaults.