Roblox LinearVelocity: The Complete 2025 Guide (with Full Scripts)

Table of Contents

1. What is Roblox LinearVelocity (and why it replaced BodyMovers)?

2. LinearVelocity vs VectorForce vs AssemblyLinearVelocity: when to use each

3. Key properties you’ll actually use (without the fluff)

4. Required setup checklist (attachments, network ownership, parenting)

5. Full System #1 — Dash with LinearVelocity (client feel, server authority)

6. Full System #2 — Knockback on hit (anti-exploit, predictable physics)

7. Full System #3 — Server-spawned Projectiles that feel crisp

8. Full System #4 — Moving Platform driven by LinearVelocity

9. Common pitfalls & debugging (why it “doesn’t move”)

10. Performance tips (replication, mass, MaxForce, cooldowns)

11. Design patterns you can reuse across your entire game

12. FAQ for LinearVelocity in Roblox Studio

    
    

1) What is Roblox LinearVelocity (and why it replaced BodyMovers)?

LinearVelocity is a constraint-based actuator that pushes an assembly toward a target linear velocity. Unlike the old BodyVelocity (now deprecated), LinearVelocity integrates with the modern constraints system, plays nicer with network ownership, and gives you better control of acceleration via MaxForce. In short: it’s the right way to move unanchored physics objects and characters with physically believable motion.

Use LinearVelocity when you want:

• Predictable, directional movement (dashes, knockback, conveyors).

• Server-authored impulses that still feel smooth for players.

• Physics-driven projectiles that aren’t just CFrame teleports.

2) LinearVelocity vs VectorForce vs AssemblyLinearVelocity

Use this quick decision matrix:

• LinearVelocity → “I want this assembly to match a target velocity for a short window (dash/knockback/platform).”

• VectorForce → “I need a continuous force (thrust, hover, buoyancy, gravity compensation).”

• AssemblyLinearVelocity (property) → “I want an instant velocity change right now (tap to nudge), not sustained enforcement.” Great for micro impulses, but not for sustained movement you can tune.

Rule of thumb: For movement you want to regulate over time (with caps or cooldowns), prefer LinearVelocity. For constant push (like a rocket’s thrust), use VectorForce. For “one-off” impulses, set AssemblyLinearVelocity directly (server authoritative).

3) Key Properties You’ll Actually Use

• Attachment0 (Attachment) — The frame of reference. On characters, use HumanoidRootPart.RootAttachment.

• VectorVelocity (Vector3) — The desired world (or relative) linear velocity.

• RelativeTo (Enum.ActuatorRelativeTo) — Usually World. You can also set it relative to Attachment0 for local-space motion.

• MaxForce (number) — The max force the actuator can exert. Too low → sluggish. Too high → snappy/arcade. Scale with mass.

Tip: Scale MaxForce by assembly mass for consistent feel across objects:MaxForce = mass 2000 (dash), mass 8000 (lunge/knockback), etc. Tune to taste.

4) Required Setup Checklist

• ✅ The target Part/Model is Unanchored (anchored = no movement).

• ✅ The target Part has an Attachment (characters already have RootAttachment).

• ✅ You parent the LinearVelocity to the part (or an ancestor in the assembly).

• ✅ You set RelativeTo = World (unless you’re intentionally using local space).

• ✅ You tune MaxForce high enough to reach the desired speed quickly.

• ✅ For characters, be mindful of Network Ownership (players own their characters; server should still author the change and guard cooldowns).

5) Full System #1 — Dash with LinearVelocity

Goal: buttery-smooth dash that feels client-responsive but is server-safe.

Structure:

• ReplicatedStorage/Modules/PhysicsUtil (ModuleScript)

• ReplicatedStorage/Remotes/DashRequest (RemoteEvent)

• StarterPlayer/StarterPlayerScripts/DashClient (LocalScript)

• ServerScriptService/DashServer (Script)

5.1 PhysicsUtil (ModuleScript — full script)

Path: ReplicatedStorage/Modules/PhysicsUtil.lua

5.2 DashClient (LocalScript — full script)

Path: StarterPlayer/StarterPlayerScripts/DashClient

5.3 DashServer (Script — full script)

Path: ServerScriptService/DashServer

Why this works: The client handles input and cosmetic feel (FOV pop). The server clamps speed/duration and applies LinearVelocity. Result = responsive, secure, and consistent across all clients.

6) Full System #2 — Knockback on Hit (Server-Authoritative)

Structure:

• ReplicatedStorage/Remotes/RegisterHit (RemoteEvent)

• ServerScriptService/Combat/KnockbackServer (Script)

Client sends a candidate hit. The server verifies target and applies a short LinearVelocity burst.

This yields reliable, cheat-resistant knockback: short duration, server-owned, and tuned by mass.

7) Full System #3 — Server-Spawned Projectiles with LinearVelocity

Goal: Create crisp, network-consistent bullets/arrows/energy balls. The server spawns and simulates the projectile (so it’s trustworthy). We use LinearVelocity for the initial ballistic push.

Structure:

• ReplicatedStorage/Remotes/FireProjectile (RemoteEvent)

• ServerScriptService/Projectiles/ProjectileServer (Script)

• StarterPack/Blaster (Tool)└ LocalScript (client fires event with mouse world position)

7.1 ProjectileServer (Script — full script)

Path: ServerScriptService/Projectiles/ProjectileServer

7.2 Blaster Tool (LocalScript — full script)

Path: StarterPack/Blaster/LocalScript

This gives you a clean, server-auth projectile that flies using LinearVelocity and reacts to Touched.

8) Full System #4 — Moving Platform with LinearVelocity (Waypoint Loop)

You can move unanchored platforms with physics for more dynamic worlds. Below, a server script drives a platform between waypoint parts.

Structure:

• Workspace/MovingPlatform (Model with PrimaryPart: a rectangular Part, Anchored = false)└ Attachment (inside PrimaryPart; name PlatformAttachment)

• Workspace/PlatformWaypoints (Folder) with Parts named WP1, WP2, WP3, …

• ServerScriptService/Platforms/PlatformMover (Script)

  
  

  

You now have a physics-driven platform that loops through waypoints. Players standing on it will ride naturally because it’s real physics (not teleported CFrames).

9) Common Pitfalls & Debugging

• “It doesn’t move.”

  • Is the part Anchored? (Must be false.)

  • Did you attach a valid Attachment? (Characters usually have RootAttachment.)

  • Is MaxForce too low? Scale with mass.

  • Is RelativeTo set as intended? Usually World.

• “It jitters or rubber-bands.”

  • Conflicts with other constraints or scripts setting velocity/CFrame.

  • Character movement controllers fighting you—apply dashes briefly (≤0.25s).

• “Client can cheat the dash speed.”

  • Server clamps speed/duration. Never trust client values directly.

• “Projectile feels inconsistent.”

  • Server should own network simulation: part:SetNetworkOwner(nil).

• “Platform drifts over time.”

  • Tighten arrival threshold, or snap position to exact waypoint on arrival (tiny CFrame correction) if you need perfect loops.

10) Performance Tips

• Short lifetimes for LinearVelocity bursts (dash/knockback ≤0.3s). Auto-destroy actuators.

• Reuse attachments when possible; don’t spam create/destroy every frame.

• Mass matters. Heavier assemblies need larger MaxForce to feel snappy.

• Server authority for anything that affects other players (knockback, projectiles).

• Cooldowns protect both gameplay and server performance.

11) Design Patterns You Can Reuse

• Burst Movement Pattern — Add LV → set velocity → delay → destroy. Use for lunges, slides, wall-pushes.

• Guided Motion Pattern — Recompute VectorVelocity toward a target each heartbeat (platforms, escorts, homing).

• Hybrid Control Pattern — VectorForce for constant lift/thrust + LinearVelocity to cap lateral speed.

• Mass-Scaled Tuning — Always define MaxForce = mass * constant. You’ll thank yourself later.

12) FAQ

Q: Should I use LinearVelocity for character movement instead of Humanoid:Move?A: No; keep normal locomotion with Humanoids. Use short LV bursts for abilities (dashes, knockbacks) that complement the built-in controller.

Q: Can I stack multiple LinearVelocity objects on the same part?A: You can, but results add up and may be chaotic. Prefer one LV at a time per assembly for clarity. In these scripts we clean up old instances.

Q: Why RelativeTo = World?A: It’s easiest to reason about and avoids weird local frame rotations. Switch to Attachment0 space only when you specifically want “move forward relative to current facing.”

Q: What about AngularVelocity?A: Use AngularVelocity alongside LinearVelocity for controlled spins/turns (vehicles, spinning traps). Same constraints family, similar rules.

Q: Are BodyMovers still okay?A: They’re deprecated. Migrate to constraints: LinearVelocity (→ BodyVelocity), VectorForce (→ BodyForce), AngularVelocity (→ BodyAngularVelocity), AlignPosition (→ BodyPosition), etc.

SEO Recap & On-Page Checklist

• Primary keyword: Roblox LinearVelocity

• Secondary keywords: Roblox physics, replace BodyVelocity, Roblox knockback script, Roblox dash script, Roblox projectile script, Roblox moving platform, Roblox constraints

• Meta description (≤160 chars):Master Roblox LinearVelocity with full scripts for dash, knockback, projectiles, and platforms. Modern physics, anti-exploit, and performance tips.

• Slug: roblox-linearvelocity-complete-guide

• H2/H3 include keywords (done throughout).

• Internal links (suggested): Link to your physics fundamentals, character controller tuning, and anti-exploit best practices posts.

• Code is complete (no snippets) and ready to paste.

Final Thoughts

With LinearVelocity in your toolkit, you’ve got a modern, scalable way to author snappy abilities and believable motion—without fighting legacy BodyMovers.

The four complete systems above (dash, knockback, projectile, moving platform) are plug-and-play patterns you can reuse across Ball Brawl, Break the Bank, and client projects. If you want, I can bundle these into a mini “Physics Starters” package next—clean folders, icons, and pre-wired remotes—so you can drop it into any new place and ship faster.