Some of the delay you feel in an emulated game is not your TV or controller. It is inside the game itself. Many classic titles were programmed to act on your input only two, three or more frames later, and an emulator faithfully reproduces that wait.
As an Amazon Associate, we earn from qualifying purchases.
Run-Ahead is RetroArch’s answer, and it is the one latency feature that attacks the problem at that level. This guide explains how it works, how to measure your game’s lag frames, what Second Instance does to the audio, and which cores can use it. RetroArch is free, open-source software; use it with games you dumped from your own cartridges and discs.
This article contains affiliate links; if you buy through them, the site may earn a commission at no extra cost to you.
Quick Answer
Turn on Run-Ahead in RetroArch’s Latency menu and set the frame count to your game’s own internal lag, often one to three frames on classic 2D titles, measured with the pause and frame-advance test. Enable Second Instance mode to protect the audio. Run-Ahead removes only lag inside the game; your display and controller still matter.
How Run-Ahead Actually Works
Per libretro’s documentation, every game has a built-in amount of lag: some react on the next displayed frame, others take two, three or more frames before a button press is rendered on screen. Run-Ahead calculates frames as fast as possible in the background so it can roll the action back to the moment you pressed the button, showing you the frame where your input has already taken effect.
The mechanism is save states. In the default single-instance mode, RetroArch mutes audio and video, runs one frame and saves state, runs any additional run-ahead frames the same way, then enables audio and video, runs the frame you will actually see, and loads the saved state back. All of this happens in RAM; the states never touch your disk.
The Two Settings That Matter
The first setting is the frame count. The next section covers choosing it, because guessing wrong is worse than leaving the feature off.
The second is Second Instance mode, and its trade-off is audio. In two-instance mode, the primary instance handles audio only and then saves state; a secondary instance loads that state, runs the frames ahead discarding audio and video, and produces the frame you see, resyncing only when your input changes. The reason is that many cores do not leave their audio emulation in a clean state after loading a save state, which produces buzzing in single-instance mode. Because the primary instance never loads states, the buzzing never starts. Libretro advises using Second Instance where possible; it also works around some cores’ save state limitations, at the cost of running a second copy of the core.
How Many Frames? Measure the Game, Not the Console
The correct frame count is a property of the individual game, not the system it ran on. Libretro’s documented test takes a minute: pause emulation, hold a direction or the jump button, then advance frame by frame until the character reacts. The lag frames equal the number of advances minus one, because at best an action is visible on the very next frame. Libretro’s own example is Super Mario World, which carries two frames of internal lag at all times, so two is its correct setting.
Use the shortest internal lag you can find in that game, because a game’s delay is not always constant. Set the count higher than the real lag and the documentation warns of stutter and rollback when pressing buttons, and possibly various weirdness; on games that respond instantly it also judders and skips animation frames. Most classic 2D games land between one and three frames, but the test makes the setting right.
Which Cores Support It, and Which Cannot Afford It
Run-Ahead relies on save states, so they need to be clean and fast; if a core does not support them, the feature cannot work at all. That is why it belongs to the 2D era. Libretro specifically patched cores including the Snes9x family, FCEUmm, Nestopia, QuickNES, Gambatte and Genesis Plus GX to perform well with it, and those are the cores where it shines.
The boundary cases are the 3D systems. Beetle PSX gained run-ahead support, but libretro directs users to the software renderer with it, noting the hardware OpenGL and Vulkan renderers misbehave under run-ahead, and combining a dynarec with run-ahead is very CPU intensive. Heavier cores for Nintendo 64, Dreamcast, PlayStation 2 and GameCube class systems generally lack the fast, clean serialization run-ahead needs.
Run-Ahead vs Frame Delay vs Hard GPU Sync
These three attack different links of the chain, which is why the documentation says you can still use the others on top. Run-Ahead removes the game’s internal frames. Frame Delay works at the end of the chain: it postpones creating the frame, including the moment input is polled, until the last viable instant before the display needs it, so your press is sampled later and shown sooner. Automatic Frame Delay, added in RetroArch 1.9.13, starts from half the frame period and scales itself down if it detects frame drops. Hard GPU Sync uses synchronization fences to stop frames piling up between CPU and GPU, at some performance cost on the OpenGL path.
The catch is that all three spend the same budget: CPU headroom inside a 60 fps frame. Stacked aggressively on a weak machine they cause the very stutter you were trying to escape. The sensible order is run-ahead set correctly first, automatic frame delay second, hard sync where your driver supports it; if drops appear, back the frame delay off before touching the run-ahead count.
The Hardware Cost
Your machine must run the core several times per displayed frame: libretro’s rule of thumb is that the system should run the core at at least twice its regular speed for run-ahead to stay playable, and demand climbs with the frame count. Second Instance mode runs two copies of the core on top of that. A core that only just holds full speed has nothing left to spend, which is why single-thread CPU performance decides how far you can push the feature.
What Run-Ahead Cannot Fix
Run-ahead deals with internal game logic lag, and only that. It cannot remove delay added by your display’s picture processing, which is why game mode still matters. It cannot remove delay added between your finger and the emulator, so a Bluetooth controller’s radio wait survives it untouched. It also does nothing for a game that already responds on the next frame.
Gear That Supports a Low-Lag Setup
MINISFORUM UM790 Pro Mini PC
Run-ahead is bought with CPU headroom: this mini PC’s Ryzen 9 gives 2D cores the multiple-times-full-speed margin the feature needs.
Specs:
- Processor: AMD Ryzen 9 7940HS, 8 cores and 16 threads, up to 5.2 GHz
- Graphics: AMD Radeon 780M integrated
- Memory and storage: 32GB DDR5, 1TB PCIe 4.0 SSD
- Ports: 2 USB4, 2 HDMI 2.1, 2.5G Ethernet, Bluetooth 5.3
ASUS TUF Gaming VG249Q1A Monitor
Run-ahead cleans up the game’s frames; the display still has to show them promptly, and a high-refresh panel shortens the wait between frames.
Specs:
- Panel: 23.8-inch IPS, 1920 x 1080
- Refresh rate: 165Hz overclocked, 144Hz native
- Response: 1ms MPRT with Extreme Low Motion Blur
- Sync and ports: FreeSync Premium, DisplayPort 1.2, 2 HDMI 1.4
- Published input lag figure: not stated
8BitDo Pro 2 Bluetooth Controller (Hall Effect)
The wired mode is the point: a USB-C cable removes the radio link from the chain entirely, and the SNES-style layout suits 2D libraries.
Specs:
- Sticks: Hall Effect joysticks
- Connectivity: Bluetooth 4.0 and wired USB-C
- Extras: 2 back paddle buttons, mode switch for Switch, Android, D-input and X-input
- Battery: 1000mAh rechargeable, up to 20 hours per maker
- Weight: 228 g
Xbox Wireless Controller (Carbon Black)
Microsoft’s pad is the easy wired option: a USB-C cable turns it into a direct input device RetroArch recognises instantly, with a hybrid D-pad that handles retro platformers well.
Specs:
- Model: QAT-00001, Carbon Black
- Connectivity: Bluetooth and wired USB-C
- Controls: hybrid D-pad, Share button, textured grip
- Power: 2 AA batteries, up to 40 hours per maker
Samsung T7 Portable SSD 1TB
Run-ahead’s states live in RAM, so storage is not part of the feature; a fast drive simply keeps a large self-dumped library portable.
Specs:
- Model: MU-PC1T0T/AM
- Capacity: 1TB
- Interface: USB 3.2 Gen 2 over USB-C
- Read speed: up to 1,050 MB/s per maker
How to Choose
Start with the measurement, not the menu. Run the frame-advance test on the games you actually play; if a game’s internal lag is zero, run-ahead has nothing to offer and your effort belongs on the display and controller links. If your favourite 2D games carry two or three frames, check the core: a patched, fast core on a CPU with at least double-speed headroom is what works. Enable Second Instance unless a game misbehaves, use automatic frame delay rather than a fixed value, and treat hard sync as the final layer. Hardware follows the same order: CPU headroom, display, then a controller you can plug in.
Who Should Skip
Skip run-ahead if your library is mostly 3D-era systems, where cores rarely support it well enough to matter. Skip it if your PC only just holds full speed in your cores, because it trades a lag problem for a stutter problem. Skip it for turn-based RPGs, strategy games and visual novels, where a frame or two changes nothing. And skip the measuring ritual if you play casually; a wired controller and game mode give you most of the improvement.
FAQ
Does run-ahead work with every RetroArch core?
No. It depends on the core supporting fast, clean save states, and it works best on 2D systems. Many 3D cores lack support or cannot afford the CPU cost. The related Preemptive Frames option in the same menu reaches a similar result more lightly, re-running frames when input changes.
How do I find the right frame count for a game?
Use libretro’s test: pause, hold a direction or the jump button, and advance one frame at a time until the character reacts. Advances minus one is the game’s internal lag, and that is your frame count.
Is Second Instance mode always better?
Usually, and libretro recommends it where possible: the primary instance never loads save states, which avoids the audio buzzing single-instance mode can produce on some cores. It costs more CPU, so treat it as the default, not a rule.
Can run-ahead make a game respond faster than the original console did?
For the game’s internal lag, yes. The original hardware had the same built-in frames, and run-ahead removes them, which is why libretro describes the result as lower latency than original hardware. Your display and controller delays still apply on top.
Final Verdict
Run-Ahead is the most surgical latency tool in emulation: it removes the frames of delay the game itself was programmed with. Set the count by measuring each game, leave Second Instance on, stack automatic frame delay above it, and accept its boundaries — 2D cores with headroom, not 3D cores on the edge. Classic games then respond the way you remember, or better.










