- Top Pick: Xbox Wireless Controller (Carbon Black)
- Runner-up: Lenovo Legion Go S (Z2 Go, 16GB, 512GB, Windows 11)
- Also consider: Lenovo Legion Go 2 (Ryzen Z2 Extreme, 32GB, 2TB)
Play a platformer on original hardware, then play your own dumped copy of the same game in an emulator, and the jump can feel a fraction late. Nothing is broken. Emulator input lag is rarely one big delay; it is a stack of small ones added at every stage between your finger and the screen, and each stage has its own fix and its own price.
As an Amazon Associate, we earn from qualifying purchases.
The good news is that most of the stack is adjustable, and the projects document their tools openly. This guide walks the stack in the order your input travels — controller, display, frame presentation, then the emulator’s own latency features — using the documented settings in RetroArch and Dolphin. Everything here applies to games you own and dumped yourself.
This article contains affiliate links, and we may earn a commission if you buy through them, at no extra cost to you.
Quick Answer
Work down the stack in order: plug the controller in or use its wired mode, run the display at its highest refresh rate with VRR on, then open the emulator’s latency settings. In RetroArch, frame delay (or automatic frame delay) trims presentation delay cheaply, while run-ahead removes a game’s own built-in lag frames, at a real CPU cost only lighter systems can afford.
The Lag Stack, in the Order Your Input Travels
Layer 1: The Controller Hop
The first delay is the trip from pad to PC. A wired connection makes that trip directly; Bluetooth adds a wireless hop with its own timing, which is why the same pad can feel tighter plugged in than paired. Switching the controller to its wired mode is the cheapest test there is.
One warning before you shop by numbers: controller makers rarely publish polling rates — the pads below list theirs as not stated. Judge a pad by its connection options, a real wired mode rather than a charge-only cable.
Layer 2: The Display’s Refresh Window
A finished frame can only appear when the display shows it, so the panel’s refresh cycle is the second layer. At a low refresh rate, a frame that just misses one window waits a long time for the next; at a high refresh rate the same miss costs far less, because windows arrive more often. Running a display at its highest refresh rate is a latency fix in itself.
Variable refresh rate matters for a subtler reason. Classic systems and arcade boards often ran at rates that are not neat divisors of 60 — some arcade boards ran near 54 Hz, per the Libretro documentation — and a fixed-refresh panel cannot pace those evenly. RetroArch’s Sync to Exact Content Framerate option exists for this: on a VRR panel the display follows the game’s own rate, and uneven panel rates only pace smoothly while VRR is active.
Layer 3: How the Emulator Presents the Frame
Between the emulated machine and the panel sits the frontend’s presentation path, and RetroArch’s documentation is blunt about its traps. Threaded Video is described as well known to interfere with smooth frame pacing and audio sync, worth its cost only on hardware otherwise too weak to hold full speed. Windowed modes can contribute to pacing problems through the desktop compositor, which is why the documentation recommends exclusive fullscreen. VSync swap interval settings decide how refresh windows map to game frames, and the video driver choice changes how a core and GPU pair behaves. Hard GPU Sync also lives here: the run-ahead documentation names it as a later-stage method that stacks with the earlier ones, keeping CPU and GPU in tighter step instead of letting work queue up.
Layer 4: Frame Delay, the Cheap Trim
RetroArch’s Frame Delay setting attacks a quiet inefficiency. Normally a frame is prepared — inputs polled, emulation run, image rendered — then sits finished until the frame period ends. Frame Delay postpones that preparation, input polling included, to the last moment that is realistically viable, so your input is sampled closer to the moment of display.
The cost is headroom. The work must still finish inside a shortened window, so a value set too aggressively on a core already working hard produces the opposite of the goal: missed deadlines, judder and dropped frames. That tuning burden is why RetroArch added Automatic Frame Delay to its Latency menu: it starts from your chosen strength and tunes it down automatically based on system performance.
Layer 5: Run-Ahead, Removing the Game’s Own Lag
The last layer is the one players least expect: the game itself. Libretro’s documentation points out that many games do not react on the very next frame — some take two, three or more frames before a press is rendered. Run-Ahead is RetroArch’s answer: it emulates frames ahead in the background using save states held in RAM, so when your input arrives, the frame shown already accounts for it.
It works in two documented modes. Single-Instance mode runs the extra frames on the same core, saving and loading state around them. Two-Instance mode — the Run-Ahead Use Second Instance option — runs a second copy of the core alongside the first, which the documentation notes works around some save-state limitations and avoids the audio problems rapid state loading in one instance can cause.
Run-Ahead also has a documented way to set it correctly: pause the game, hold a direction, then advance the emulation one frame at a time until the character moves. The advances minus one is that game’s internal lag — and that is the value to use. Set it higher and the documentation warns of stutter and rollback oddity; set it lower and some lag remains. Either way the bill is CPU: the extra frames must fit inside the same real-time budget.
The Dolphin Variation
Standalone emulators expose their own versions of these layers. In Dolphin, the documented presentation lever is Immediately Present XFB, under Graphics, then Hacks: it presents frame copies to the display sooner instead of holding them for the normal buffer path. Its documented caveat mirrors this guide’s theme — games that rely on the external frame buffer for rendering can show instability with it on, so it is a per-game judgement. Its V-Sync toggle plays the Layer 3 role.
Per-System Expectations
For the cartridge era and early disc systems — 8-bit, 16-bit and PlayStation-class games — the full toolkit applies at once: wired pad, VRR or high refresh, automatic frame delay, and one or two frames of run-ahead. Stacked together, these can match the responsiveness of original hardware — and run-ahead can go further, subtracting lag frames the console itself could not.
GameCube, Wii and PlayStation 2 sit in the middle. The presentation layers still pay — Dolphin’s XFB option, sensible vsync choices — but run-ahead is mostly off the table, because these cores already spend the CPU budget on holding full speed. Expect frame delay in modest values, if any.
PlayStation 3 and Xbox 360 emulation changes the question entirely. On RPCS3- and Xenia-class workloads the priority is simply holding full speed; a machine straining to emulate the system has no spare cycles to sell back as latency features. Fix Layers 1 to 3, skip 4 and 5.
How to Choose
Start by identifying which layer your complaint lives in. If every game on every system feels equally soft, the problem is almost certainly Layer 1 or 2 — controller connection or display. If one console feels fine and another does not, you are in the emulator layers, and the fix is per-system configuration.
On a handheld with a VRR panel, enable Sync to Exact Content Framerate, keep Threaded Video off, and let Automatic Frame Delay manage itself; add run-ahead only on the light systems, measured per game. On a desktop driving a television, game mode plus a correctly set refresh rate does most of the work. Either way, change one setting at a time — the documentation makes the same point — so you know which change helped.
Who Should Skip
Skip this whole exercise if your library is turn-based RPGs, strategy titles and menu-driven adventures: the stack is real there too, but nothing in those games asks you to notice it. Skip run-ahead on any core that cannot hold full speed without it, because a dropped frame costs more responsiveness than a lag frame does. And skip the hunt if your symptom is stutter, not softness — that is a performance problem to fix first.
Gear That Helps at Each Layer
8BitDo Pro 2 Bluetooth Controller (Hall Effect)
The Layer 1 fix in a single pad: pair it over Bluetooth on the couch, then plug in the USB-C cable when a game starts punishing late inputs.
Specs:
- Connectivity: Bluetooth 4.0 and wired USB-C
- Sticks: Hall Effect joysticks
- Extras: 2 Pro back paddle buttons, 3-profile switch
- Polling rate: not stated
Xbox Wireless Controller (Carbon Black)
Microsoft’s pad speaks XInput natively on Windows, consistent across RetroArch and standalone emulators, with the same Bluetooth-or-cable choice.
Specs:
- Connectivity: Bluetooth and USB-C wired
- Input: XInput on Windows PCs
- Power: 2 AA batteries
- Polling rate: not stated
Lenovo Legion Go S (Z2 Go, 16GB, 512GB, Windows 11)
The VRR layer built into a handheld: its panel sweeps a wide refresh range, so odd original game rates pace evenly without a television in the chain.
Specs:
- Processor: AMD Ryzen Z2 Go, 4 cores and 8 threads, up to 4.3GHz
- Memory: 16GB LPDDR5x-6400
- Display: 8-inch 1920×1200, 48 to 120Hz variable refresh rate
- Battery: 55.5Wh
Lenovo Legion Go 2 (Ryzen Z2 Extreme, 32GB, 2TB)
A 144Hz OLED shortens every refresh window, and the stronger chip widens the set of systems where frame delay and modest run-ahead values stay affordable.
Specs:
- Processor: AMD Ryzen Z2, 8 cores and 16 threads, up to 5.1GHz
- Memory: 16GB or 32GB LPDDR5X, soldered
- Display: 8.8-inch OLED 1920×1200, 144Hz
- Battery: 74Wh
Samsung T7 Portable SSD 1TB (MU-PC1T0T/AM)
Storage does not cut input lag directly, and this guide will not pretend otherwise. What fast storage removes is the other thing players misread as lag: asset-streaming hitches in disc-based games that break frame pacing mid-action.
Specs:
- Capacity: 1TB
- Interface: USB 3.2 Gen 2
- Model: MU-PC1T0T/AM
FAQ
Does run-ahead work on every core and game?
No. Run-Ahead relies on save states being fast and clean, so a core without solid save-state support cannot use it, and heavy cores rarely leave the CPU headroom it needs.
Why did raising frame delay make my game stutter?
Because frame delay works by postponing the frame’s preparation to the last viable moment. If the core cannot finish inside that shortened window, frames miss their display slot and pacing falls apart. Lower the value, or switch to Automatic Frame Delay and let RetroArch tune it down under load.
Is Bluetooth always the wrong choice for a controller?
No. For slower games it rarely matters. The point is diagnostic: when a fast game feels soft, testing the same pad wired separates the controller layer from everything else in one step, at no cost.
Can an emulator end up less laggy than the original console?
For light systems, yes. Original games carried internal lag frames of their own, and run-ahead can remove exactly those frames — something the real hardware could never do — while a high-refresh VRR panel shortens the display layer below what a period television offered.
Final Verdict
Emulator input lag is not a single fault to fix but a stack to work down. Wire the controller, give the frames a faster, more flexible display, clean up the presentation path, then spend CPU on frame delay and run-ahead only where the system is light enough to afford them — measured per game, never guessed. Do it in that order, and most of the softness blamed on emulation turns out to have been settings.










