Engine

Tag Table

The following is a list of tags given by MicroProfiler, separated by type. Understanding these tags will help in determining the cause and identifying potential solutions for unoptimized code.The tables contain tag label, descriptions and performance advice for improving performance and optimizing your experience.

AI/Navigation

LabelDescriptionPerformance Advice
rasterizeTileUpdates navigation tiles needed for a pathfinding request, usually followed by computePath which requires those tiles be up-to-date. Follows NavigationJob/preprocess on the main thread.Reduce the number of pathfinding tile invalidations, as this causes those paths to need recomputing. This is caused by non-navigable parts moving.
computePath

Calculates paths, typically after rasterizeTile.

Reduce the number and world extents of ComputePath calls. Try reusing paths for multiple agents if they are expected to start/end from approximately similar locations.
preprocess/getPrimitivesOverlappingCollects the world geometry for each pathfinding tile and schedules the rasterization tasks to be executed by the pathfinding thread.Reduce the part count.

Animation

LabelDescriptionPerformance Advice
Simulation/gameSteppedProcessing of game specific objects such as Humanoids, Animations and heartbeat callbacks
Simulation/gameStepped/StepLegacyHumanoid state changes and movement.Called stepHumanoid on server now (parallel version)Disable or reduce Humanoid states on NPCs, if you have them. Ladder state is most important to disable. Reduce callbacks to state changes such as Humanoid.Died or Humanoid.Running
Simulation/gameStepped/stepAnimationAnimators will step forward in currently playing animations.Reduce the amount of Animators or animated joints to lower the workload of this step. Reduce number of callbacks to animation events such as AnimationTrack.KeyframeReached or AnimationTrack.Ended
Simulation/gameStepped/RunService.SteppedRuns functions connected to the RunService.Stepped event.Reduce the amount or workload of functions connected to this event. Consider delaying or replacing expensive calculations. Consider spreading computation across multiple frames.

Audio

LabelDescriptionPerformance Advice
SoundProcessing audio: locations, effects, volumes, etc.
DeveloperTag_SoundsIn-Memory Sounds: generally short sounds that are small enough to go in memory. Usually brief one-shot fx, not long-form music. Use fewer short sounds
DeveloperTag_StreamingSoundsstream/StreamingSounds: these are larger sounds that get streamed from disk. Generally longer-form music files. Use fewer long sounds.

Networking

LabelDescriptionPerformance Advice
Net PacketReceiveReceives network packets. If many objects or events are being replicated, this step takes longer. Replicate fewer objects or events.
Replicator/ProcessPacketsProcesses contents of network packets, such as motion, event invocations and property changes. Reduce the number or size of objects being replicated, or do this in incremental steps. May increase if map size increases, as larger maps tend to have more overall activity.
Allocate Bandwidth and Run Senders/Dispatch Physics Senders and TouchSendersSends data about activity in the experience. Reduce the amount of moving objects and/or touches. See following sections.
Allocate Bandwidth and Run Senders/Dispatch StreamJobSends corresponding specific regions to specific clients in the "Streaming" feature.Reduce the minimum and target streaming radii.
Allocate Bandwidth and Run Senders/Dispatch Data SendersSends property changes, remote events, Humanoid state changes, animation start/stops. Reduce the number of replicated changes to the data model
Replicator SendClusterSends Terrain data to clients.Reduce the amount or size of Terrain changes.
ModelCompleteness Mega JobServer only: completeness is an internal concept. When models are completely sent, model completeness events are sent.Add or remove fewer instances.
DeserializePacketLow-level network packet processing. Prepares for Replicator ProcessPackets.Send fewer updates.

Rendering

LabelDescriptionPerformance Notes
PrepareInformation is gathered from the main thread and updates various data structures used for rendering. This blocks the simulation threads, so it should be as small as possible.See Prepare labels below.
Prepare/Pass3dAdornRendering various object adorns, such as text labels above objects. This step may include raycasting to determine if such objects are visible.Reduce the number of visible adorned objects, such as BillboardGuis, Humanoid name/health labels, etc.
Prepare/Pass2DReadies 2D UI rendering (both player and Roblox UI).Reduce the amount or complexity of UI elements.
Prepare/UpdateInvalidPartsUpdates parts that had some property changed or added.Reduce the amount of properties changes on the world. If a script updates a large set of object properties, break it down across frames.
Prepare/UpdateInvalidateFastClustersPrepares geometry, typically "FastClusters" used to render Humanoids. Sub-markers specify the number of parts, vertices, and size of vertices.Reduce the use of 'Humanoids' under objects that are not Humanoids. This should not be used to shorten draw calls as FastClusters consume much more memory.
Prepare/UpdateDynamicPartsUpdates positions for Humanoids, vehicles and other moving instances for rendering.Reduce the number or complexity of moving Humanoids or vehicles visible. Combining parts of the same material and color into a union or MeshPart can help with this.
Prepare/updateInstancedClustersPrepares static geometry that uses instanced rendering (parts and mesh parts). Labels "Clusters" and "Instances" indicate the number updated.Use less overall mesh and material variation. You can also create clusters by using objects that have similar appearances - size, color, material.
PerformWhen actual rendering commands are created and issued.See Perform labels below.
Perform/fillGuiVerticesUI rendering. Fills buffers with UI vertices for adorns. "Gui count" label indicates the amount of elements in the renderer list.If the cost is high, reduce the amount of UI being updated by disabling it when it is not used by ensuring it is hidden correctly.
Perform/Scene/queryFrustumOrderedApplies frustum culling so that objects not visible are not rendered.If there is a high cost that means there are a lot of elements. Perhaps use some larger meshes where a single mesh has more details as opposed to many small individual pieces.
Perform/Scene/ComputeLightingPerformComputation of lighting near the camera.Manipulate the number of light sources or move the camera less to reduce the time it takes to recalculate lighting.
Perform/ Scene/ ComputeLightingPerform/UpdateLightGridUpdates the voxel lighting. Lights are only rendered in Voxel Lighting mode, but occupancy and sky light are computed in all lighting modes.If updating chunk occupancy takes too long, consider using lower resolution geometry, or reducing the number of parts. If the other sub-markers take too long, consider reducing the number of lights. Consider using non-shadow casting geometry for objects that move and invalidate the occupancy.
Perform/Scene/Glow, ColorCorrection, MSAA, SSAO, and SSAOApplyPost-processing rendering.Reduce the number of post-processing effects, usually this is not significant.
Perform/Scene/UIUI rendering. In Id_Screen, there is a label with the number of batches, materials and triangles used.Reduce the number of visible UI elements. Using CanvasGroups may help at the expense of increased memory use.
Perform/PresentWaits for the GPU to finish rendering the previous frame; actually issues rendering commands to GPU; deals with low-level graphics resources.Reduce scene complexity in general. If this step is taking a long time, you may be limited by the GPU.
Perform/Present/waitUntilCompletedWaits for the GPU to finish rendering the previous frame.If this is generally happening a lot then the amount of things rendered is too high. FRM helps with balancing this, but if it remains high, try to use less detail.

Scripts

LabelDescriptionPerformance Advice
Render/PreRender/fireBindToRenderSteppedCallbacksRunning functions bound to render step via RunService:BindToRenderStep().Ensure functions in scripts using RunService:BindToRenderStep() do as little work as possible.
Render/PreRender/RunService.RenderSteppedRuns functions connected to the RunService.RenderStepped event.Similar to BindToRenderStep, ensure functions using this event do as little work as possible.
WaitingHybridScriptJobResumes scripts waiting using wait. frames.This step has an execution time budget to run waiting scripts, so if you have too many waiting scripts or scripts with a long runtime before yielding, this step can take multiple
LuaGCLua garbage collection cycle. Label provides memory estimates on total allocation and how much was deallocated. Pool lua tables and other collectable objects or try to reduce creating temporary tables or strings
Heartbeat/RunService.HeartbeatRuns functions connected to the RunService.Heartbeat event.Talk to simulation and scripts contacts. Current description is generic enough to be not wrongReduce the amount or workload of functions connected to RunService.Heartbeat.

Simulation

LabelDescriptionPerformance Advice
Distributed Physics OwnershipDetermines whether the server or a client has authority over certain instances such as parts.Distributed Physics Ownership.
Simulation/assembleUpdates a tree of connected objects (assemblies) used by the physics engine.Reduce the amount of joints being created or destroyed.
Simulation/physicsSteppedRuns the physics simulation.Reduce the amount and complexity of physically simulated bodies.
physicsStepped/SpacialFilter/filterStepUpdates simulation islands, arranging parts according to network ownership, local simulation. Islands are non-interacting groups of parts which can be simulated independently.Avoid setting network ownership frequently. Keep groups of parts far enough away from each other so they can be simulated separately.
physicsStepped/worldStep/stepContactsUpdates contacts between objects.Reduce the amount of bodies colliding at once, or use simpler collision boxes. Cubes are better than complex meshes.
physicsStepped/worldStep/stepWorld OR stepWorldThrottledSolves physics equations relating to connectors, buoyancy and Humanoids. When the engine is overloaded and unable to simulate everything in real time, some steps may be throttled (stepWorldThrottled) and only "real time assemblies" such as Humanoids are simulated.Depends on where the time is going based on the following three phases: stepContacts: narrow phase collision detection geometry tests. Solver step: integrate time and resolve collisions and other constraints updateBroadphase: update positions of assemblies in collision detection system and find possibly colliding narrow phase pairs.
NotifyMovingAssembliesHelps track how long primitives have been sleeping.
Simulation/InterpolateNetworkedAssembliesInterpolates assemblies not controlled by this network peer.Set the network owner of parts to this peer to reduce this; although this will usually cause more physics work to be done elsewhere.
Simulation/handleFallenPartsRemoves parts that have fallen below Workspace/FallenPartsDestroyHeight.Lower the destroy height or reduce the amount of parts that fall to the destroy height.
Heartbeat/HeartbeatInternal/updateVisuallySleepingSecond part of NotifyMovingAssemblies.
Heartbeat/RunService.HeartbeatRuns functions connected to the RunService.Heartbeat event.Talk to simulation and scripts contacts. Current description is generic enough to be not wrongReduce the amount or workload of functions connected to RunService.Heartbeat.
worldStep/StepContactsHelps physics simulation step many contacts at once.Reduce the number of colliding objects.
SolveBatchHelps the physics simulation solve batches of objects' motion.
Mechanism InterpolationHelps with InterpolateNetworkAssemblies.

UI

LabelDescriptionPerformance Advice
Render/PreRender/UpdateInputUpdates and fires all user input related events if the user has performed input since the last frame.This is when events related to user input will fire. It is important to try and not do too much work directly as you get the input. Consider doing a minimal amount of processing for the input, and larger computations should be pushed off to another thread that happens later.
Render/PreRender/TweenServiceUpdates objects being tweened using TweenService and calls completion callbacks, such as those used provided to TweenSize or TweenPosition.Reduce the number of objects being tweened using TweenService and ensure callbacks do as little work as possible.
Render/PreRender/UpdateUILayoutsUpdates position and size of UI elements. Reduce the amount of UI elements being resized or repositioned dynamically, such as those managed by UILayout.
Heartbeat/TweenServiceOn server, updates objects tweened with TweenService. On the client, this is done in a PreRender step instead.Reduce the amount of objects tweened by TweenService.