Frame Recording: The Comprehensive Guide for Emulators, Performance Profiling, and Game Capture
Introduction to Frame Recording
Frame recording is the process of capturing and storing each visual frame, user input, and relevant metadata from applications such as games or emulators. In 2025, frame recording has become an essential tool for developers, testers, and enthusiasts seeking to analyze performance, create replayable sessions, and produce high-quality game capture footage.
In gaming, frame recording enables precise benchmarking, allowing users to measure frame rates (FPS) and detect performance bottlenecks. In emulation, frame recording preserves gameplay sessions by storing exact sequences of inputs and states, which can be replayed, shared, or used for tool-assisted speedruns (TAS). For software engineers, frame recording underpins powerful profiling tools within browsers and applications for debugging and optimizing rendering pipelines.
The use cases for frame recording now range from game performance analysis and bug reporting to AI-driven gameplay analytics and automated regression testing. This guide explores the technical foundations, implementation details, and advanced applications of frame recording.
Understanding Frame Recording File Formats
FR, FBM, and FRS Formats Explained
Frame recording in emulators relies on specialized file formats, most notably FR, FBM, and FRS. These formats are engineered to efficiently capture and replay gameplay sessions, preserving not only video frames but also the exact sequence of user inputs and emulator states.
At their core, these formats contain the following components:
- File Header: Identifies the format version and metadata.
- Save State Chunk: Captures the emulator's state at the start of recording.
- Frame Data Chunk: Stores per-frame input, timing, and state changes.
- Metadata Chunk: Optional information such as rerecord counts, author, or recording settings.
Most emulator frame recordings assume a fixed frame rate, typically 60 frames per second (FPS), to ensure deterministic replay and accurate synchronization.

Key Data in Frame Recording Files
Several types of data are critical in frame recording file formats:
- Recorded Frames: Each input or rendered frame captured during the session.
- Rerecord Count: The number of times a recording has been edited or modified, useful for TAS and debugging.
- Frame Input Data: Raw input states for controllers/keyboards per frame.
- Compression: Some formats support compression to reduce file size.
Below is an example hex layout of a frame data chunk:
10000: 01 00 00 00 // Frame number (1)
20004: 80 00 // Input data (e.g., button state)
30006: 3C // Frame duration (60 FPS = 16.67ms/frame)
4
This layout is often repeated for each frame, allowing precise playback and analysis.
Frame Recording in Emulators
How Emulators Record and Play Back Frames
Emulators such as FBA, FBA-RR, and FBA shuffle implement frame recording by intercepting input states and saving emulator state at key points. The workflow typically involves:
- Creating a Save State: At the beginning of a recording, the emulator saves the entire game/emulator state.
- Recording Input per Frame: For each frame, the emulator logs user input (e.g., button presses) and any necessary state changes.
- Rerecording: Users can load earlier states, modify input, and save a new recording. Each modification increments the rerecord count.
- Playback: The emulator loads the initial save state and replays the exact sequence of recorded inputs, reconstructing the original session deterministically.
Example: Pseudocode for Reading a Frame Data Chunk
1def read_frame_data_chunk(file):
2 frame_number = int.from_bytes(file.read(4), 'little')
3 input_data = file.read(2)
4 frame_duration = int.from_bytes(file.read(1), 'little')
5 return {
6 "frame": frame_number,
7 "input": input_data,
8 "duration": frame_duration
9 }
10
Supported emulators include:
- FBA (Final Burn Alpha): Classic arcade emulator with frame recording support.
- FBA-RR (FBA rerecording): TAS-focused fork with enhanced input recording.
- FBA shuffle: Variant with advanced movie and input handling.
Common Issues and Troubleshooting
Frame recording is sensitive to emulator version mismatches and implementation bugs. One common issue is the metadata duplication bug found in some FBA shuffle (fbash) builds, where metadata chunks are appended multiple times, breaking compatibility.
Other pitfalls include changes in input mapping between versions, corrupted save states, or unsupported features in older or forked emulators. Always verify version compatibility and use authoritative external resources for troubleshooting.
Frame Recording for Game Benchmarking and Capture
Using Fraps and Similar Tools for Frame Recording
For native PC games, tools like Fraps capture rendered frames and audio directly from DirectX or OpenGL pipelines. Fraps records at user-specified frame rates (e.g., 30, 60, or even 120 FPS), creating high-quality AVI files suitable for benchmarking, performance analysis, or sharing.
Fraps also provides real-time benchmarking overlays, displaying live FPS counters and logging frame timings to disk. This is invaluable for performance profiling and detecting rendering stutters.
Unlike emulator movie files, Fraps captures the visual output, not input or save state data. This makes Fraps ideal for video capture but less suitable for deterministic playback or TAS work.
Best Practices for High-Quality Recording
To ensure optimal results when using Fraps or similar video capture tools:
- Set recording FPS to match your monitor's refresh rate (commonly 60 FPS) for smooth playback.
- Choose high-quality video codecs to minimize compression artifacts.
- Sync audio by enabling full input/output capture and verifying audio-video alignment in post-processing.
- Benchmark in controlled environments, closing background applications to avoid inconsistent frame times.
- Use lossless or high-bitrate settings for critical benchmarking or archival footage.
Performance Profiling with Frame Recording in Chrome
Introduction to Chrome’s Frame Viewer
Modern web browsers like Chrome offer built-in performance profiling tools that leverage frame recording to analyze rendering pipelines. The Frame Viewer (accessible via
about:tracing
or Chrome DevTools) records each paint, layout, and input event, enabling developers to diagnose jank, dropped frames, and rendering inefficiencies.Frame recording in Chrome is crucial for:
- Rendering performance analysis
- User experience optimization
- Performance bug reporting
How to Capture and Analyze Frame Data
Developers can capture frame data in Chrome using the built-in performance tools or via command line (especially in Chrome Canary and Android builds):
- Open Chrome and navigate to
chrome://tracing
or DevTools > Performance. - Start a recording session and reproduce the performance scenario.
- Save the trace file for analysis or sharing.
- Use the Frame Viewer to inspect frame timings, paint events, and input latency.
For command-line recording (e.g., in Chrome Canary):
1chrome.exe --enable-tracing --trace-startup --trace-startup-file=trace.json
2
This produces a JSON trace file containing detailed frame event data for later analysis.

Use cases include performance bug reporting (attaching trace files to bug trackers), regression analysis, and deep dives into rendering pipelines.
Future Trends and Advanced Uses of Frame Recording
Looking ahead to 2025 and beyond, frame recording is being transformed by automation, AI, and advanced analytics. Tool-assisted speedruns (TAS) rely on frame-perfect input replay and rerecording features, pushing emulator formats to evolve with better compression and metadata support.
AI-driven analysis can automatically detect anomalies, regressions, or gameplay events in frame data, streamlining both QA and player experience research. Integration with cloud-based profiling and continuous benchmarking tools is making frame recording a staple of software development and performance engineering workflows.
As file formats mature, expect enhanced interoperability between emulators, benchmarking tools, and analysis suites, further empowering developers and researchers.
Conclusion
Frame recording sits at the intersection of game capture, software profiling, and emulator development. By mastering file formats, tools, and best practices, developers can unlock powerful workflows for benchmarking, debugging, and content creation. As the ecosystem evolves in 2025, frame recording will remain a cornerstone of performance engineering and digital preservation.
Want to level-up your learning? Subscribe now
Subscribe to our newsletter for more tech based insights
FAQ