Inspect Performance Hotspots as 3D Heatmaps in Your Game Editor

A build comparison tells you how much a performance metric changed. To investigate it, you also need to know where that change was observed.

Framedash has long shown that where on the dashboard: aggregated cells painted over a map image and filterable by build and platform. SDK updates for Unity, Unreal Engine 5, and Godot (C#) on 2026-07-24 brought the same cells into the editor. With the level still open, you can overlay its performance data as translucent 3D voxels on the level layout.

Overlay aggregated performance data on the level in 3D

Each voxel is one server-aggregated cell, drawn at the world coordinates your telemetry recorded. The editor asks the API for XYZ aggregation, so a cell that carries a measured z renders as a translucent box centered on that height instead of a flat patch on the ground.

That difference is the point of the release. A flat grid collapses a multi-level space: measurements from a balcony and the atrium below can land in the same square meter and average into an unremarkable color. Preserving height lets you distinguish which level produced the higher values. Older API responses that carry no z stay visible as flat cells at the map floor, so a project mid-migration doesn’t lose its view.

All three editors share one five-stop blue-to-red palette. It is normalized against the highest cell in the response, so red means the worst cell in what you just fetched rather than a fixed threshold. Both the Unity overlay controls and the Godot dock print the cell count and the maximum weight next to the legend, which is how you tell a genuine hotspot from a quiet map where the peak is unremarkable. A fetch returns at most the API’s limit of 10,000 aggregated cells.

Opening it in each engine

Every editor reads its data with a Read API Key carrying the analytics:read scope, plus the Project ID. This is separate from the game’s write-only ingest key. The editor only needs permission to read aggregates, and a separate least-privileged key prevents accidental writes from contaminating comparison data. If you would rather not type a key into a project, set FRAMEDASH_ANALYTICS_API_KEY before launching the editor. All three SDKs read it as a fallback, use it only for that editor process, and never persist it; an explicitly configured key still wins.

Unity: a SceneView overlay

Open Window > Framedash Heatmap, set the Read API Key and Project ID, refresh the map list, pick a map, and click Fetch. No Play mode needed.

The SceneView then carries a Framedash Heatmap overlay with three actions: Show, Frame, and Controls. Frame snaps the SceneView to the loaded data’s bounds, which saves a lot of hunting on a large level. Closing the controls window does not destroy the overlay. The selected map and the overlay preference persist per project, and an open controls window restores its map list and refetches enabled data after a script reload, so a recompile doesn’t cost you the view. The overlay is suppressed while the editor is in Play mode and comes back afterward if the toggle is still on.

Framedash uses the recorded Unity Vector3 components directly — telemetry X/Y/Z maps to SceneView X/Y/Z with no ground-plane axis remap. Use Z Offset only when you want a deliberate display translation; it does not rewrite the cloud coordinates.

The first version of this overlay shipped in Unity SDK 0.1.4 on 2026-07-17 as flat quads. Version 0.1.7 on 2026-07-24 turned it into voxels.

Unreal Engine 5: a per-viewport show flag

In UE5 SDK 0.1.13, fetching and displaying are separate on purpose. Window > Framedash > Framedash Heatmap opens the data panel where you fetch, outside PIE. Display is a per-level-viewport Show > Framedash Heatmap flag that starts disabled and stays independent across viewport layouts, so you can keep one viewport clean for authoring and one heat-mapped for reference. Closing the data panel no longer removes an active heatmap.

Because the editor module draws through the editor scene’s main render pass, standard F9 and high-resolution viewport screenshots include the heatmap. Press F9 once to capture an image for a ticket. Play In Editor suspends the visualization and restores your prior viewport choices when play ends.

Cloud voxels are batched by color and drawn cool-to-hot, so high-load cells stay visually prominent, and none of it runs per-cell collision traces. The API URL, project ID, read key, opacity, alignment, and Z offset live under Project Settings > Plugins > Framedash Heatmap.

Godot (C#): an editor dock

Enabling the plugin adds a Framedash Heatmap dock to the Godot editor, shipped in Godot SDK 0.1.8. Enter the read key, project ID, and API base URL, choose a time range and cell size, then Refresh Maps. Pick a map, choose Fetch Heatmap, enable Show, and use Frame Heatmap to point the 3D editor camera at the data.

The dock renders up to 10,000 cells as a single cached translucent voxel mesh rather than a node or a physics trace per cell. Alongside Show and Frame you get opacity, Z offset, event/time/cell filters, a legend, the cell count, and the maximum weight. Settings live in Godot’s per-project editor metadata under .godot/editor/editor_layout.cfg, not project.godot, so keep .godot/ out of version control. The editor blocks redirects before forwarding the read key, hides the overlay while a game is running, and restores it after play stops. All heatmap code is guarded by TOOLS, which keeps it and the read key out of exported games.

It runs on the telemetry you already send

There is no second instrumentation pass for this. The cells come from position-qualified events: anything you track with a non-empty map_id, against a map already registered in the dashboard. The automatic perf_heartbeat carries an empty map_id and no position, so it never reaches the spatial grid on its own.

What you can put on the map is FPS, frame time, GPU time, and memory usage. Memory works per cell because the SDK attaches its memory-category metrics to position-qualified events as well as to the heartbeat — Unity 0.1.4 added mem.vram and mem.heap on 2026-07-17 for exactly that reason. Camera rotation capture is on by default, so every event also records yaw and pitch, and the cell-detail view can break a hotspot down by which way the player was looking.

So the loop is short. Instrument once, play or run your profiling scenarios, then open the level and look at where the color sits.

The two views answer different questions. Use the dashboard to compare builds and platforms, and the editor to place degraded areas in the context of the level layout. The voxels show where high values were observed, not what caused them. Treat them as a starting point for checking nearby rendering load, scripts, and assets. Before a release, you can inspect the heatmap for the areas a build changed without leaving the open level.

Getting started

If your game already sends Framedash telemetry with map IDs, you only need to update the SDK and create a read key. If it doesn’t, SDK integration takes about five minutes, and the Free plan is enough to see your first heatmap.

• The concept and the dashboard-side filters are covered in Performance Heatmaps.
• Per-engine setup lives in the Unity, Unreal, and Godot SDK guides.