FPS Drop Detection

Last updated on April 15, 2026

Overview

FPS Drop Detection automatically identifies, captures, and reports sustained frame rate drops during gameplay sessions. It extends the ADT Health pillar alongside crash reporting, giving developers visibility into non-fatal performance degradations that silently harm player experience but go unreported without dedicated tooling.

This feature is designed for game developers and QA engineers working with Development builds. It captures rich context for every confirmed FPS drop — including a 10-second video clip, thread profiling data, player location, and level name — and surfaces this data in the ADT Web dashboard and ADT Hub.

Why FPS Drop Detection Exists

Crashes are visible. They terminate the process, generate a stack trace, and show up in analytics. Frame rate drops are invisible. A player experiences a 2-second hitch in a busy marketplace zone, the session continues, and no one knows it happened.

Before FPS Drop Detection, developers relied on two approaches to find these problems:

• Manual profiling — a developer runs the game with a profiler attached, hoping to reproduce the exact conditions that cause the drop. This is time-consuming and depends on the developer experiencing the issue firsthand.
• User complaints — QA testers or playtest participants describe "the game felt laggy in the forest area." Without data, the team cannot reproduce, prioritize, or verify a fix.

FPS Drop Detection solves this by running continuous, low-overhead monitoring in every Development build session. When a sustained frame rate drop occurs, the system automatically captures the evidence and uploads it at session end. Developers get actionable data without changing their workflow.

How FPS Drop Detection Works

FPS Drop Detection operates through a four-stage pipeline: detect, capture, upload, and visualize.

1. Detect

The ADT SDK monitors frame time every frame during gameplay. When the frame rate falls below a configurable threshold (default: 30 FPS) and stays below it for longer than a configurable duration (default: 500ms), a FPS drop event is confirmed.

A single-frame spike does not trigger a detection. The system uses a debounce mechanism to ensure only sustained performance degradations are reported. After confirming a FPS drop, a 60-second cooldown prevents repeated events during prolonged low-performance periods.

2. Capture

On confirmation, the system captures a snapshot of the moment:

• Video clip — a 10-second recording from the ring buffer, showing exactly what was on screen before, during, and after the drop.
• Thread profiling — GameThread, RenderThread, and GPU millisecond timings, identifying which thread is the bottleneck.
• Player context — the current level/map name and the player's coordinates in the world.
• Hardware metadata — CPU model, GPU model, and RAM, enabling hardware-tier analysis.

The capture sequence is designed to be fast and non-intrusive. It does not contribute to further frame drops.

3. Upload

Captured FPS drop data is queued locally during the session. Uploads happen only after the session ends — never during active gameplay. This design ensures that the reporting system itself never causes network interference or frame drops.

If the upload fails, payloads are retained on disk and retried on the next session start. No data is discarded due to transient network issues.

4. Visualize

FPS drop data appears across several views in the ADT dashboard:

• Sessions List — each session shows a FPS drop count and a status indicator (Clean, Has FPS Drops, or Crashed), so developers can immediately spot problematic sessions.
• FPS Drops List — a filterable, sortable table of all individual FPS drop events across sessions, with columns for level, duration, minimum FPS, bottleneck type, and build version.
• FPS Drops Aggregated — FPS drops grouped by level/map, revealing which areas of the game have systemic performance problems across multiple users and sessions.
• Session Flight Recorder — a timeline view of a single session with FPS drop markers at their proportional timestamps. Clicking a marker opens the inspector with the video clip, stat breakdown, and player context.

Future: AI-Powered Diagnosis (Phase 2)

In a future phase, developers can opt in to full profiling, which captures a complete engine trace file for the session. An AI diagnosis engine analyzes the trace to identify the specific functions responsible for each FPS drop and resolves them to source file paths and line numbers. This turns a performance observation into an actionable code reference.

Key Benefits

• Automatic detection — FPS drops are captured without any manual triggering, annotation, or profiler setup. Every Development build session is monitored.
• Rich context per event — each FPS drop includes a video clip, thread profiling, player location, and hardware info. Developers can diagnose without reproducing.
• Zero gameplay impact — monitoring overhead is less than 0.1ms per frame. Uploads happen only after the session ends. The system never contributes to the problem it detects.
• Level-based aggregation — grouping FPS drops by map reveals systemic hotspots. Developers can prioritize optimization by area impact, not anecdotal reports.
• Unified health view — FPS drop data lives alongside crash data in the same dashboard, timeline, and session views. No context switching between tools.
• Persistent local queue — no data is lost due to network issues. Failed uploads are retried automatically on the next session.

Limitations and Considerations

• Development builds only — FPS Drop Detection is active only in Development builds. It is automatically stripped from Shipping builds. This feature is not intended for production monitoring.
• Unreal Engine 5.0+ only (Phase 1) — the initial release supports Unreal Engine. Unity and other engines are not supported.
• Windows only (Phase 1) — console platform support (PlayStation 5, Xbox, Nintendo Switch) is planned for a future phase but has no committed timeline.
• Session-end upload only — real-time upload during gameplay is not supported. Developers must wait for the session to end before data appears in the dashboard.
• Project-level thresholds only — FPS and duration thresholds are set at the project/game level. Per-build overrides are not supported.
• Beta Feature — FPS Drop Detection is gated behind a Beta Feature toggle in namespace settings. An admin must enable it before the feature becomes available.
• 30-day retention — FPS drop data follows the existing build retention policy. Data older than 30 days is automatically deleted.

Supported Platforms

Engine	Platform	Status
Unreal Engine 5.0+	Windows	Supported (Phase 1)
Unreal Engine 5.0+	PlayStation 5	Planned (future phase)
Unreal Engine 5.0+	Xbox (GDK)	Planned (future phase)
Unreal Engine 5.0+	Nintendo Switch	Planned (future phase)
Unity	All	Not supported