EmuDeck: Best Settings for Every System (NES to PS2)

EmuDeck's Easy Mode gets you most of the way. This guide covers what is left, with a bias towards settings that visibly change something rather than settings that exist mainly to be adjusted.

One principle first, because it saves a lot of time: the further back the system, the less there is to configure. An SNES emulator on a Steam Deck is running a machine roughly a thousand times slower than the hardware emulating it, so accuracy is effectively free and the defaults are already correct. Everything interesting happens from the 32-bit era onward, where you start trading accuracy against frame rate.

The 8-bit and 16-bit Systems

NES, SNES, Master System, Genesis, Game Boy and the rest run perfectly out of the box, and the honest advice is to change almost nothing.

The one setting genuinely worth finding is Run Ahead, in RetroArch's latency options. Emulators inherently add input lag, because a frame has to be produced and then displayed. Run Ahead works around this by internally running the emulation a frame or two further forward than it shows you, so your input is registered earlier than it otherwise would be. Set to one frame it removes a frame of lag; the cost is running the core more than once per displayed frame, which these systems have the headroom for.

It is the single change most likely to make a platformer feel different, and it is the reason a well configured emulator can feel more responsive than original hardware on a modern television.

Beyond that: leave the region setting on automatic so PAL and NTSC releases are detected rather than forced, and treat integer scaling as a matter of taste rather than correctness.

Nintendo 64

The N64 is the awkward one, and its settings deserve their own treatment, which is why there is a separate guide to N64 emulation covering why the machine is difficult in the first place.

The short version for Steam Deck: use paraLLEl-RDP as the graphics plugin. It reimplements the N64's rasteriser as Vulkan compute shaders and at native resolution produces output that matches real hardware exactly, which the Deck's GPU handles comfortably. Upscaling to 2x or 3x is where most people land.

Two corrections to advice that circulates widely, including in the earlier version of this guide:

Do not reach for GLideN64 to fix Indiana Jones and the Infernal Machine. GLideN64 has a known open lighting bug affecting that game. The Factor 5 microcodes it uses were fully solved years ago, so this is not the microcode problem people assume it is.

Pokemon Snap needs the accurate renderer, not framebuffer tweaks. Its photo evaluation depends on depth precision that the high-level renderer approximates, and it is one of the few titles genuinely better served by paraLLEl-RDP or Angrylion than by the faster option.

Also worth knowing: World Driver Championship and Stunt Racer 64 currently fail to boot with the paraLLEl RSP plugin and work with the older CXD4 one. The symptom is a black screen with no explanation, so try that before assuming your ROM is bad.

PlayStation

PS1 emulation on the Deck is essentially solved, and the settings that matter are about how much you want to correct the original hardware's quirks.

PGXP is the big one. The PlayStation had no floating point in its geometry pipeline and no depth buffer, which produced the two effects everyone recognises: vertices that jitter and swim as the camera moves, and textures that warp across large polygons. PGXP reconstructs the missing precision, and turning it on genuinely transforms how these games look. Whether you want that is a real question rather than a rhetorical one, because it is a departure from what the hardware did.

Internal resolution can go high without trouble. The Deck has ample headroom here, and unlike the N64 there are few games that break when upscaled.

A caveat worth flagging, because it affects Linux specifically. DuckStation, long the default recommendation, changed to a non-open-source licence in late 2024 that forbids derivatives and commercial redistribution, its Flathub package was deprecated in October 2025, and its developer has publicly weighed dropping Linux support, noting Linux is a small share of its users. The emulator itself remains excellent. But if you would rather not build a setup on a component whose Linux future is being openly questioned, Beetle PSX HW inside RetroArch is the free-software alternative, with Vulkan rendering and PGXP of its own.

PlayStation 2

The most demanding system the Deck handles, and the one where per-game settings genuinely earn their keep.

Vulkan is the renderer to use. Internal resolution is where you spend your performance budget, and the honest guidance is to start at 2x and come down rather than up, because PS2 games vary enormously in how much headroom they leave.

Blending accuracy is the setting people miss. The PS2 did framebuffer blending in ways modern GPUs do not replicate directly, so emulators offer a ladder of increasingly expensive approximations. Low settings are fast and produce visible artefacts in games that lean on those effects; high settings fix them and cost real performance. If something looks wrong in a way that resolution changes do not affect, this is usually the setting to try.

Be sceptical of long lists of per-game hacks, including the ones the previous version of this guide carried. PCSX2's own per-game database applies known fixes automatically, and it is better maintained than any list published in an article. Reach for manual hacks when something is visibly broken, not pre-emptively.

Shadow of the Colossus deserves its reputation as the stress case: it pushed the original hardware past its limits, and no amount of emulator configuration changes that it was a game running at an unstable frame rate by design.

GameCube

Dolphin is mature, well optimised, and the Deck handles most of the library comfortably at native or moderately upscaled resolution.

The performance settings worth knowing about concern the embedded framebuffer. GameCube games sometimes read rendered output back for effects, and emulating that faithfully is expensive. Dolphin offers options to skip or approximate it, which are large performance wins that break a small number of games. They are on by default for good reason; if a specific game shows missing effects, that is the first thing to turn off.

Saturn and Dreamcast

Two systems the earlier version of this guide skipped entirely, which is a strange omission given both are well within the Deck's reach.

The Saturn's dual-CPU design made it notoriously hard to emulate, and it took far longer than its contemporaries to become reliable. It is now in good shape, and the practical constraint is that Saturn emulation is more CPU-bound than the systems around it, so it benefits less from the Deck's GPU headroom than PS1 does.

The Dreamcast is comfortably handled and is one of the more satisfying systems to play on the Deck, since its games were designed for a controller and largely run at 60fps. Its main configuration question is the same as everywhere else: how far to upscale before the frame rate suffers.

The Setting That Matters Most

None of the above will help as much as getting the power limit right, which is covered in the advanced tweaks guide. A 16-bit system does not need the Deck running flat out, and the difference between a default profile and a considered one is measured in hours of battery rather than frames per second.