Set Up Session Replay for Unreal Engine

Learn how to capture gameplay video of the moments leading up to a crash with Sentry's Unreal Engine SDK.

Session Replay records what was happening on screen in the moments leading up to a crash, giving you a visual reproduction to pair with the captured event.

Unlike the web and mobile Session Replay experiences, which reconstruct the UI from the view hierarchy and aggressively mask text and images by default, the Unreal Engine SDK captures the rendered output of your game directly. When a crash occurs, the recording is sent to Sentry as a session replay that's linked to the crash event and viewable on the Replays page. Capture and delivery differ per platform — see Platform Notes for the details.

PlatformWhat gets capturedRequirements
WindowsA rolling video clip of the game's backbuffer.Engine codec plugins matching the GPU vendor (NVIDIA or AMD) and a plugin rebuild.*
LinuxA rolling video clip of the game's backbuffer.Engine codec plugins, an NVIDIA GPU, and a plugin rebuild.*
macOSA rolling video clip of the game's backbuffer.Engine codec plugins and a plugin rebuild.*
iOSA rolling video clip of the game's backbuffer.Unreal Engine 5.8 or newer, engine codec plugins, and a plugin rebuild.*
AndroidA sequence of periodic screenshots stitched into a video.None beyond the standard Android setup.
XboxA rolling video clip of the game's backbuffer.A plugin extension built with the software encoder.*

* See the Platform Notes below for the exact engine version, plugin, GPU, and driver requirements.

PlayStation and Nintendo Switch are not currently supported. On those platforms the setting is a no-op.

To enable Session Replay, navigate to Project Settings > Plugins > Sentry and expand the Session Replay section, then toggle Enable session replay (experimental).

Alternatively, add the following to your project's configuration .ini file:

Copied
[/Script/Sentry.SentrySettings]
AttachSessionReplay=True

The following settings are available under the Session Replay section in the plugin settings:

  • Enable session replay (experimental) (AttachSessionReplay, default False) — Master toggle for the feature.
  • Replay duration (ms) (SessionReplayDurationMs, default 5000, range 1000–20000) — The requested length of the retroactive replay window. On Windows, Linux, macOS, iOS, and Xbox this is the rolling clip length kept on disk for the crash replay. This value is ignored on Android, where the underlying SDK determines the duration.

The Advanced recording options group (SessionReplayOptions) provides low-level encoder and muxer tuning for the desktop, iOS, and Xbox recorders. The defaults are sensible for most projects.

  • Fragment duration (seconds) (FragmentSeconds, default 0.5, range 0.1–2.0) — Length of each video fragment. Shorter values reduce the worst-case amount of footage lost at crash time, but increase keyframe frequency and lower compression efficiency. Ignored on Xbox, where every frame is a keyframe and each fragment holds a single frame.
  • Rotation interval (seconds) (RotationIntervalSeconds, default 1.0, range 0.25–5.0) — How often the on-disk replay clip is refreshed.
  • Target framerate (Framerate, default 30, range 1–60) — Capture framerate. The game can render faster; frames are sampled down to this rate.
  • Target bitrate (kbps) (BitrateKbps, default 2000, range 200–20000) — Encoder target bitrate.
Copied
[/Script/Sentry.SentrySettings]
AttachSessionReplay=True
SessionReplayDurationMs=5000
SessionReplayOptions=(FragmentSeconds=0.500000,RotationIntervalSeconds=1.000000,Framerate=30,BitrateKbps=2000)

On desktop platforms, Session Replay continuously encodes the game's backbuffer into a rolling video clip that's delivered to Sentry when a crash occurs. Encoding is hardware-accelerated; the SDK automatically picks an encoder at runtime from the codec plugins enabled in your project:

PlatformEncoderEngine pluginsGPU and driver requirements
WindowsNVIDIA NVENCAVCodecsCore, NVCodecsNVIDIA GPU with driver 531.61 or newer.
WindowsAMD AMFAVCodecsCore, AMFCodecsAMD GPU with a recent Adrenalin driver. D3D11/D3D12 RHI only — not available when running with -vulkan.
LinuxNVIDIA NVENCAVCodecsCore, NVCodecsNVIDIA GPU with proprietary driver 530.41 or newer — NVENC isn't available with the open-source Nouveau driver.
macOSApple VideoToolboxAVCodecsCore, VTCodecsNone — uses the dedicated hardware media engine on Apple Silicon and a software fallback on Intel Macs.
  • Enable the codec plugins for every GPU vendor you want to cover. The Sentry plugin only compiles the recorder when AVCodecsCore is present. On Windows, NVCodecs and AMFCodecs can be enabled side by side — the encoder matching the player's GPU is selected at runtime.
  • A plugin rebuild is required after toggling the setting. Whether Session Replay is compiled in is decided at build time from AttachSessionReplay, so after enabling or disabling it, delete your project's Binaries and Intermediate directories and rebuild.
  • Machines without a compatible encoder fall back to no recording. The feature self-disables for the session and logs a warning; crash reporting itself is unaffected.
  • The replay may arrive after the next app launch. With the default backends (Crashpad on Windows and Linux, sentry-cocoa on macOS), the replay is uploaded on the next application launch after the crash. With the opt-in native backend, it's uploaded during the crashed session.

On iOS, Session Replay uses the same recording pipeline as desktop, encoding the game's backbuffer with Apple VideoToolbox via the AVCodecsCore and VTCodecs engine plugins. Encoding is hardware-accelerated on all devices, and the desktop notes above (plugin rebuild, encoder fallback) apply equally.

iOS requires Unreal Engine 5.8 or newer — earlier engine versions don't ship the AVCodecs plugins for iOS, and the setting is a no-op there.

The replay is uploaded on the next app launch, together with the crash report.

Session Replay assumes your game runs in a fixed screen orientation (typical for games). The recording orientation is determined once when the SDK initializes; if your game supports both portrait and landscape and the device is rotated mid-session, the recording stays locked to the initial orientation and subsequent footage may appear squeezed or stretched. Crash reporting itself is unaffected.

On Android, enabling the setting turns on the Android SDK's Session Replay, which records the full session rather than a short pre-crash clip. It works differently from the desktop and iOS recorders: instead of encoding the game's rendered frames, it periodically captures screenshots of the game surface and stitches them into a video. See the Android Session Replay docs for details on sampling and configuration.

Xbox exposes no video encoder, so the plugin extension bundles a software H.264 encoder (openh264) and encodes on the CPU. The encoder is off by default and is built into the extension by setting SENTRY_BUILD_OPENH264=ON; without it, Session Replay is compiled out.

Frames are scaled to 720p before encoding. We recommend lowering Framerate from its default of 30 to 10, which the software encoder can sustain.

On Android, the SDK's default text and image masking applies to the native Android view hierarchy, not to the game's rendering surface, which is captured directly. Review the Android Session Replay privacy documentation for details on masking any native UI your game overlays.

If you run into issues or have feedback about Session Replay on Unreal Engine, please open a GitHub issue.

Previous
App Hangs and ANRs
Next
Set Up Logs
Was this helpful?
Help improve this content
Our documentation is open source and available on GitHub. Your contributions are welcome, whether fixing a typo (drat!) or suggesting an update ("yeah, this would be better").