DuckStation: a PS1 emulator built for speed and low-end hardware

What DuckStation solves, and for whom

DuckStation emulates the Sony PlayStation. The README frames the goal as being "as accurate as possible while maintaining performance suitable for low-end devices", and it explicitly discourages hack options: the default configuration is meant to run playable games, with only some enhancements causing compatibility problems.

The audience follows from that. Someone with an older laptop, a Raspberry Pi class board or a handheld wants a PS1 emulator that does not demand a discrete GPU. Someone with a modern desktop wants the opposite: upscaling, texture filtering, 24-bit colour, PGXP geometry correction and post-processing shader chains. DuckStation tries to serve both from one codebase by making the accuracy and performance trade-offs configurable rather than baked in.

The repository is C++, licensed under a CC-BY-NC-ND style term (the LICENSE file is present but GitHub reports the licence as NOASSERTION, so read it yourself rather than trusting a label). The last push was on 2026-09-21, and releases ship in three tracks: a rolling "latest", a per-commit "preview", and numbered builds such as v0.1-11826.

JIT recompilation, hardware renderers and the BIOS dependency

The emulation core is a CPU recompiler, or JIT, with backends for x86-64, armv7/AArch32, AArch64 and RISC-V/RV64. That list is the real portability story: the same emulator targets desktop x86, 32-bit and 64-bit ARM, and RISC-V, which is why Linux builds are published as AppImages for x86_64, ARM32 and ARM64.

Rendering is split between a vectorized, multi-threaded software renderer and a hardware renderer supporting D3D11, D3D12, OpenGL, Vulkan and Metal. The hardware path is where the visual features live: upscaling, texture filtering, true colour, PGXP for geometry precision and depth buffer emulation, accurate blending via Rasterizer Order Views or Fragment Shader Interlock, and a texture replacement system. Those techniques are GPU-API dependent, so what you get varies by backend and by what your driver supports.

One architectural decision shapes everything: a PS1 or PS2 BIOS ROM image is required to start the emulator and play games. DuckStation does not ship one. The README says to dump it from your own console using Caetla or other means, and notes that mismatching game and BIOS regions can cause compatibility issues. This is not a missing feature to be worked around; it is a hard prerequisite.

Installing DuckStation on Windows, Linux or macOS

DuckStation is distributed as prebuilt binaries through GitHub Releases, built automatically on every commit. The README points at the releases page for the latest build, with Windows x64/ARM64, Linux AppImage x86_64/ARM32/ARM64 and macOS 13.3+ Universal packages. There is no package-manager command documented in the README, so download the archive or installer for your platform rather than expecting an install line.

On Windows you choose between two formats. The installer extracts to your user-local programs directory and can create shortcuts; the zip is the portable option. The README states Windows 10 or 11 version 1809 or newer is required, and that DuckStation will not run on Windows 7, 8 or 8.1.

The first launch is where the BIOS requirement lands. The emulator will not start a game until a BIOS image is configured, and the README is clear that you supply your own dump. After that, the Qt frontend is the main interface; a fullscreen TV-style UI built on Dear ImGui is also included for couch use.

For x86 machines, the default build needs SSE4.1, which the README ties to Intel CPUs from after 2007 and AMD CPUs from after 2011. Older CPUs need the separate SSE2 build, which the README describes as lower performance but still supported.

Once a game is running, the features worth knowing about are save states with runahead and rewind, per-game configuration and controller presets, an optional per-game memory card switch, and automatic content scanning with English and native titles.

Where DuckStation refuses to help you

The BIOS rule is the first wall, and it is deliberate. No ROM image ships with the emulator, for legal reasons, and the README directs you to dump it from your own console. If you do not own the hardware, DuckStation is the wrong tool, not a tool with a missing step.

The second wall is the operating system floor. Windows 10 1809 or newer is a requirement, not a recommendation. The README names v0.1-5624 as the last version that runs on older Windows and says those builds are no longer supported and will not receive assistance. If you are pinned to Windows 7, that is your ceiling.

The third is the CPU instruction set. The normal x86 build assumes SSE4.1. Hardware from before 2007 (Intel) or 2011 (AMD) needs the SSE2 build and accepts the performance cost. The GPU bar is much lower by comparison: OpenGL 3.1, OpenGL ES 3.1, Direct3D 11 Feature Level 10.0 or Vulkan 1.0, which the README describes as anything made in roughly the last ten years.

Finally, the update channels are a real decision. Preview builds are produced whenever a commit is pushed and the README says they have had minimal testing and may contain bugs. Stable tracks the "latest" release and has had more testing. The updater follows whichever channel you downloaded from unless you change it under Settings, Interface, Updates.

How DuckStation differs from RetroArch's Beetle PSX cores

The obvious alternative for a PS1 emulator is RetroArch with a Beetle PSX core, and the difference is architectural rather than cosmetic. RetroArch is a frontend that hosts many emulator cores; DuckStation is a single emulator with its own frontend, and its README describes a fully-featured Qt interface plus a Dear ImGui fullscreen UI rather than a host application.

That changes what you configure. In RetroArch you pick a core, then tune options through the frontend's menu system, and your library spans many consoles. With DuckStation you get per-game configuration, controller presets, merged multi-disc games with shared memory cards, a memory card editor, a cheat database the README says covers over 4,000 games, and a patch database for visual, frame rate and aspect ratio enhancements, all inside one application.

The rendering approach also differs in emphasis. DuckStation leans on modern GPU features for correctness, naming Rasterizer Order Views and Fragment Shader Interlock for accurate blending, and offers PGXP for geometry precision and depth buffer emulation. If your goal is one console emulated well on modest hardware, DuckStation's single-purpose design is the shorter path. If your goal is one interface for a shelf of consoles, a multi-core frontend is the better fit, and DuckStation's own frontend is not trying to be that.

Licence terms and what upgrades cost you

The README states redistribution of unmodified releases and code is permitted under CC-BY-NC-ND, that the project would prefer you link to duckstation.org instead, and that pre-configured settings and packages count as modifications. That last clause is the one that matters in practice: repackaging DuckStation with your own defaults, or shipping it inside a bundle, is treated as a modification rather than a redistribution. GitHub reports the repository licence as NOASSERTION, so the LICENSE file is the authority, and none of this is legal advice.

Maintenance cost on your side is low but not zero. The emulator has an automatic updater with Stable and Preview channels, so staying current is a setting rather than a manual download. The trade-off is that Preview tracks every push to the repository, and the README says those builds have minimal testing. If you value a working setup over early fixes, leave the updater on Stable.

The releases page keeps only the last 30 releases because of updater limitations; older builds live in a separate old-releases repository. If you depend on a specific build for a specific game, archive it yourself rather than assuming it stays reachable.

Editorial conclusion

Adopt DuckStation if you have a PS1 BIOS image you dumped from your own console and a machine with SSE4.1 support, and you want hardware rendering, PGXP geometry correction and save states without reaching for a heavier emulator. Skip it if you are on Windows 7 or 8.1, on a pre-2007 Intel CPU without the SSE2 build, or you expect the emulator to supply a BIOS. Before committing, check your CPU generation against the SSE4.1 requirement, confirm you are downloading from the releases page or duckstation.org rather than a pre-configured repackage, and decide whether you want the Stable or Preview update channel.

Frequently asked questions

Official sources

1. Issues
2. README
3. Releases
4. stenzek/duckstation on GitHub