Guide · Roblox Studio basics

How to fix lag in your Roblox game

Lag has three different causes: low frame rate on the player's device, a slow server, or too much memory. The fix depends on which one you have, so measure first. This guide lists the tools built into Roblox and the fixes Roblox recommends for each cause, from its documentation read on 16 November 2026.

Updated 16 November 20265 min readIntermediateRoblox StudioWritten by

In short

First find the cause. Press Shift + F5 in the Roblox client to see frame rate, and F9 for the Developer Console, which shows memory, script performance and server health. Then fix what the numbers point to. The fixes that help most maps: turn on instance streaming, reuse the same mesh instead of many unique ones, anchor parts that do not need physics, turn off shadows on small parts and extra lights, and use Box collision on small meshes.

  • Test in the Roblox client, not only Studio: Roblox says Studio skews performance numbers.
  • Test on a low-end device. A strong PC can hide a problem that phones show clearly.
  • A server runs at up to 60 steps a second. Lower means the server is the problem.
On this page
  1. 1. Measure
  2. Parts and meshes
  3. Physics
  4. Scripts
  5. NPCs
  6. Network
  7. RoCode
  8. Questions
  9. Sources

Step 1: Find out what is slow

Roblox performance tools (Roblox docs, read 16 November 2026)
ToolWhat it showsHow to open
Debug stats summaryFrame rate in the clientShift + F5
Developer ConsoleLogs, memory, script performance, server healthF9
MicroProfilerHow much time each task takes every frameCtrl + Alt + F6 (⌘ + ⌥ + F6 on Mac)
Performance StatsMemory, CPU, GPU, network and pingCtrl + Alt + F7 (⌘ + ⌥ + F7 on Mac)
Render StatsDraw callsShift + F2
Scene AnalysisWhich instances use the most resourcesIn Studio, while testing
Performance DashboardMemory, frame rate, server heartbeat and crash rates for live playersCreator Dashboard
  • Client frame rate. The default cap is 60 FPS. In the MicroProfiler, a frame that takes longer than 16.67 ms is below 60.
  • Server. In the Developer Console, open Server Jobs, expand Heartbeat and read Steps Per Sec. It is capped at 60. A slow server also shows up as high ping in the Server Stats tab.
  • Memory. Open the Memory tab of the Developer Console. Roblox suggests keeping server memory under 50%, and looking into crashes if your crash rate goes above 2 to 3%.

Too many parts, meshes or shadows

Drawing the scene is a large part of every frame on the player's device. If the frame rate drops when you look at one area of the map, that area is too dense. Roblox's fixes:

  • Reuse meshes. Identical meshes with the same textures are drawn together in one draw call. Upload each mesh once and duplicate it in Studio. Importing a whole map at once often gives every copy its own asset ID, which stops this.
  • Turn on instance streaming so players only load what is near them. Roblox calls it the highest impact way to cut client memory. With streaming on, set a model's LevelOfDetail to SLIM so far-away models use lightweight meshes.
  • Lower mesh detail. Set a MeshPart's RenderFidelity to Automatic or Performance instead of Precise.
  • Cut shadows. Turn off CastShadow on small parts and moving objects, turn off Shadows on lights that do not need them, use fewer lights and limit their range and angle.
  • Avoid stacked transparency. Half-transparent objects in front of each other make the engine draw the same pixels several times. Decals, textures and particles also batch poorly, so do not pile them up in one spot.

For thousands of trees or rocks, the first two points do most of the work: one tree mesh duplicated many times, with streaming on.

Too much physics

  • Anchor every part that does not need to move.
  • Keep adaptive physics stepping (the default). The fixed mode steps everything at 240 Hz and costs much more.
  • Use simpler collisions. A MeshPart's CollisionFidelity set to precise is the most expensive. Use Box for small or background objects and Box or Hull for medium ones. For big complex meshes, build collisions from invisible parts.
  • Turn collisions off where they are not needed: set CanCollide, CanTouch and CanQuery to false.
  • Simplify mechanisms. Use fewer constraints and joints, and stop ragdoll limbs colliding with each other.

Slow scripts and memory leaks

  • Do not run heavy code every frame. Keep work on RunService events such as Heartbeat and PreRender for things that truly need it, like the camera. Run the rest less often in a loop.
  • Split big jobs across frames with task.wait().
  • Disconnect events you no longer need, or destroy the instance they belong to. Connections that stay connected are never cleaned up, which leaks memory.
  • Clear tables when a player leaves. A table that gains an entry on every join and never loses one grows forever.
  • Clean up characters. Enable PlayerCharacterDestroyBehavior on Workspace so player objects and characters are destroyed after a player leaves.

In the Developer Console, a growing LuaHeap or InstanceCount points to a leak, and PlaceScriptMemory shows memory script by script.

Many NPCs

  • NPCs that never move do not need a Humanoid. Use an AnimationController to play their animations.
  • Turn off Humanoid states an NPC never uses with Humanoid:SetStateEnabled(), for example Climbing.
  • Play NPC animations on the client instead of the server.
  • Reuse NPCs from a pool instead of destroying and creating them, and only spawn NPCs near players.

More on moving NPCs in NPC pathfinding.

Network lag

  • Send less, less often. Fire a RemoteEvent when something changes, not every frame, and send only what changed. For a purchase, send the item bought, not the whole inventory.
  • Tween on the client. A tween run by the server sends the changing property to every player every frame, which looks jittery and floods the network.
  • Make effects on the client. For an explosion, the server only needs the position. Each client can build the visuals.
  • Load big maps in pieces instead of creating or destroying a huge model at once.

Ask RoCode to find and fix the heavy parts

RoCode (RoCode.app) is an AI agent for Roblox Studio. You describe a change in a web chat and a free plugin makes it in the place you have open. It can read your place, so you can ask it to apply fixes from this guide across the whole map. It gives 1 free credit a day with no card.

You type

Anchor every part in the map that never needs to move, and turn off CastShadow on parts smaller than 2 studs.

RoCode does
  • Reads the parts in your place and changes the matching ones
  • Edits your scripts in place, for example moving a tween from the server to the client
  • Lists what it changed, and you can undo the build

Measure before and after with the tools above. The prompt is an example written by us.

Questions

Why is my Roblox game so laggy?

Usually one of three things: the player's device cannot draw the scene fast enough, the server is overloaded, or memory is too high. Check frame rate with Shift + F5 and the Developer Console with F9 to see which.

How do I reduce lag from thousands of trees?

Use one tree mesh uploaded once and duplicated, so the engine draws the copies together, and turn on instance streaming so players only load nearby trees. Turning off CastShadow on small parts helps too.

How do I see FPS in Roblox?

Press Shift + F5 in the Roblox client. In Studio, use Window, then Performance, then Stats, but Roblox says client numbers are more accurate.

Do too many parts cause lag?

Many unique, dense objects cause more draw calls and lower the frame rate. Identical meshes that share the same asset are drawn together, so reuse helps more than the raw part count suggests.

Do scripts cause lag?

Yes, when heavy code runs every frame or memory leaks from events that are never disconnected. The MicroProfiler and the Developer Console's script and memory tabs show which script.

Sources and further reading

Try RoCode on your own place.

Free every day, no card required. Install the plugin, describe the feature, and review what lands in Studio.