DuckStation has become the default way to play PlayStation 1 games on a modern PC, phone, or Steam Deck. It replaced older tools like ePSXe and PCSX-Reloaded by pairing accurate emulation with modern conveniences. Save states, resolution upscaling, and a geometry fix called PGXP all come built in. PGXP alone is worth the install, since it stops PS1 models from wobbling at the edges the way they did on real hardware.
Getting it running well takes more than a download and a double-click. You need a BIOS file you dumped yourself, a renderer that matches your hardware, and a library organized well enough that you’re not hunting for files six months from now. This walkthrough covers all 13 steps in about 60 minutes, current as of August 2026, from picking the right build to converting a folder of scattered BIN and CUE files into a clean CHD library, plus the pitfalls and fixes that catch first-time users.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Quick-Start: All 13 Steps at a Glance
Short on time? Here’s the full sequence in one place before the step-by-step walkthrough below. Budget about 60 minutes for a first-time setup, and get DuckStation only from duckstation.org or the project’s GitHub Releases page, never a third-party bundle.
- Download the right build for your platform
- Install and launch DuckStation
- Understand BIOS legality before you do anything else
- Dump your BIOS and verify the checksum
- Add BIOS files to DuckStation
- Run first-time setup
- Choose and configure your renderer
- Turn on PGXP, upscaling, and texture filtering
- Map your controller
- Organize your game library and convert to CHD
- Boot your first game
- Set up memory cards and save states
- Apply cheats, widescreen hacks, and keep DuckStation updated
What Is DuckStation, and Why Everyone Recommends It Now
DuckStation is a free PlayStation 1 emulator originally written by developer Connor McLaughlin, who goes by stenzek. The project lives on GitHub at stenzek/duckstation and has spent the past few years pulling ahead of older-generation PS1 emulators by focusing on three things: accuracy, speed, and features that actually help players rather than just developers.
That shows up in the small details. DuckStation supports multiple rendering backends, including Vulkan, Direct3D 11, Direct3D 12, and OpenGL, plus a software fallback for machines without a dedicated GPU. It runs on x86_64 chips as well as AArch32, AArch64, and RISC-V hardware, which is part of why it shows up on everything from gaming laptops to Android phones to Steam Deck.
The feature that gets the most attention is PGXP, a geometry correction system originally built for PCSX-Reloaded and later folded into DuckStation. The PS1’s GPU did all its 3D math with fixed-point integers instead of floating-point numbers, which is why classic PS1 games have that distinctive jittery, warping look on polygon edges. PGXP recalculates that geometry with more precision, and the wobble mostly disappears. It is optional, reversible, and one of the first settings most players turn on.
None of this makes DuckStation the only option. RetroArch still ships a capable PS1 core for players who want one front end for every console, and we cover that setup in our RetroArch installation guide. But for a dedicated, PS1-only experience with the deepest feature set, DuckStation is where most communities point beginners in 2026.
Part of why PS1 emulation still draws so much active development in 2026 comes down to preservation. Original hardware is three decades old now, laser assemblies fail, memory cards corrode, and discs degrade in ways that make physical PS1 collections genuinely fragile. A well-configured software emulator running from verified, self-dumped files is, for a lot of collectors, the more durable way to keep a library playable for another thirty years.
Is DuckStation Still Open Source? The 2024 License Change
Before you install anything, it helps to understand a change that reshaped how DuckStation gets distributed. Through most of its life, DuckStation was licensed under the GPLv3, a standard open-source license. That changed in September 2024. On September 1, the project switched to the PolyForm Strict License, then on September 13 moved again to CC BY-NC-ND 4.0, a Creative Commons license that blocks commercial use and blocks derivative works.
Practically, that means DuckStation is still free to download and free to use, and its source code is still publicly visible on GitHub. What changed is what other people are allowed to do with that code. Packagers can no longer legally redistribute modified builds, which is why some Linux distributions and community repositories quietly dropped it. Coverage of the change from GamingOnLinux at the time detailed the developer’s reasoning: the license shift was aimed at parties who had stripped attribution and copyright notices from earlier releases, with blocking third-party repackaging as a secondary effect.
The emulation community’s response was mixed. A hard fork called Swanstation appeared under the libretro organization, preserving the last GPL-licensed codebase at github.com/libretro/swanstation for anyone who specifically wants a fully open-source PS1 core. If license terms matter to you as a matter of principle, that fork is worth knowing about even if you end up running mainline DuckStation for its newer features.
For most players this is a footnote rather than a blocker. You are not redistributing modified builds, you are just installing and playing, and CC BY-NC-ND 4.0 does not restrict that kind of personal use. The one place it does matter is Flatpak distribution, which is why Steam Deck and Linux users need to pay closer attention to where they get their build. More on that in Step 1.
DuckStation System Requirements for 2026
PS1 emulation is not demanding by 2026 standards. The console’s original hardware ran at 33.8 MHz, so the actual CPU and GPU simulation is light. Where DuckStation asks more of your system is in the extras: PGXP, high internal resolution multipliers, and texture filtering all add overhead that the base emulation core does not need. The table below breaks down what each supported platform expects.
| Platform | Minimum OS | CPU | Renderer Support |
|---|---|---|---|
| Windows | Windows 10 or 11, 64-bit | x86_64 with SSE4.1 (most Intel chips since 2008, AMD since 2011) | Vulkan, Direct3D 11, Direct3D 12, OpenGL, Software |
| Linux | Any modern 64-bit distribution | x86_64, AArch64, or RISC-V (RV64) | Vulkan, OpenGL, Software |
| macOS | Recent macOS release (experimental support) | Apple Silicon or Intel | Metal, OpenGL (experimental) |
| Android | Android 8.0 or newer | ARMv7 (AArch32) or ARMv8 (AArch64) | Vulkan, OpenGL ES |
| Steam Deck | SteamOS or a Linux gaming distro | AMD Zen 2 APU (stock hardware) | Vulkan (recommended) |
The project’s own documentation is blunt about how modest the baseline requirement is, joking that PS1 emulation needs little more than a CPU that outperforms a potato. Where you actually need horsepower is if you stack a 4x or higher internal resolution with PGXP and texture filtering on a demanding, FMV-heavy game. On integrated graphics, that combination can drop frame pacing below the PS1’s native 59.94 Hz (NTSC) or 50 Hz (PAL) refresh targets.
Prerequisites: What You Need Before You Start
Gather these before you open the installer. Nothing here is expensive or hard to find, but tracking it down mid-setup is the number one reason people abandon emulator tutorials halfway through.
- The latest DuckStation build from the official GitHub releases page (the project ships rolling releases rather than a numbered stable/beta split, so “latest” is the version you want)
- A PS1 console you own, for dumping your own BIOS file (see Step 3 for why this matters)
- Your own PS1 discs, either as physical media plus an optical drive, or as BIN/CUE images you have already ripped yourself
- A checksum tool: sha256sum on Linux/macOS (built in) or certutil on Windows (also built in)
- chdman, part of the MAME tools project, if you want to convert BIN/CUE images to the smaller CHD format
- A USB game controller, though a keyboard works fine for initial setup and menu navigation
- About 60 minutes for a first-time setup (some shorter 2026 guides promise 30 minutes or even 5, but that skips BIOS verification, controller mapping, and CHD conversion), less on repeat installs once you have your BIOS and library organized
Step 1: Download the Right Build for Your Platform
Head to the official site at duckstation.org or straight to the GitHub releases page. Windows users want the x64 build for a standard PC, or the ARM64 build if you’re on a Snapdragon-class Windows-on-Arm laptop. Linux users get an AppImage, which runs without installation. macOS support is still labeled experimental by the project, so expect occasional rough edges there. Those two are the only official sources. Treat any third-party site offering a ready-made “DuckStation + BIOS” bundle as a scam rather than a shortcut.
Because of the 2024 license change, Flatpak availability is inconsistent across distributions. Some Flathub listings for DuckStation have been pulled or frozen at older versions, so if you’re on Linux or Steam Deck, downloading the AppImage directly from GitHub is the more reliable path in 2026. Check Flathub first if you prefer that workflow, but don’t be surprised if it’s missing or outdated.
Android users should know that maintenance on the Android build has slowed considerably. Community reporting in 2026 pointed to no meaningful Android update since May 2025, so treat that build as usable but no longer actively developed. If mobile emulation is your main use case, that’s worth factoring in before you commit your library to it.
Windows, Linux, and macOS: What Actually Differs
The core emulation is identical across desktop platforms, since it’s the same codebase. What differs is packaging and renderer defaults. Windows defaults to Direct3D 11 in many builds, Linux leans on Vulkan or OpenGL, and macOS uses Metal. If a renderer misbehaves on your system, switching to a different one in Settings is usually a faster fix than reinstalling.
Step 2: Install and Launch DuckStation
On Windows, extract the downloaded archive to a folder you control, such as a dedicated Games directory rather than Program Files. The official Windows build ships as a ZIP with no root folder of its own, so create a subdirectory first (for example, Games\DuckStation) and extract into that, rather than letting every file spill loose into Downloads. DuckStation stores its configuration alongside the executable by default in portable-friendly setups, so keeping it out of a permissions-locked folder saves headaches later.
On Linux, make the AppImage executable and run it directly. This is also a good moment to decide on a folder structure, since DuckStation will ask where to keep BIOS files, game images, memory cards, and save states the first time it launches.
mkdir -p ~/Games/DuckStation/{bios,roms,memcards,savestates,covers}
cd ~/Games/DuckStation
chmod +x duckstation-qt-x64.AppImage
./duckstation-qt-x64.AppImageDuckStation will open to a setup wizard on first launch. Don’t rush through it. The BIOS and game directory prompts you see here determine how much reorganizing you’ll be doing later, so it’s worth pointing them at the folders you just created instead of accepting whatever default path the wizard suggests.
Step 3: Understand BIOS Legality Before You Do Anything Else
DuckStation does not ship with a BIOS file, and for good reason. The PS1 BIOS is Sony’s copyrighted firmware, and distributing it isn’t something any legitimate emulator project does. The project’s documentation is explicit that you’re expected to dump the BIOS from a console you own.
The good news is that this is simpler than it sounds and doesn’t require modding your console. The BIOS chip on a PS1 can be read out using established dumping tools designed for exactly this purpose, and plenty of PS1 preservation communities document the process step by step. The output is a small binary file, historically 512KB (524,288 bytes) in size, that DuckStation loads at startup.
Different console revisions and regions produce differently named BIOS dumps. You’ll commonly see references to filenames like SCPH1001.bin (an early NTSC-U revision), SCPH5501.bin and SCPH7001.bin (later NTSC-U revisions), SCPH7003.bin (PAL/European consoles), and SCPH1000.bin (NTSC-J, Japan). The exact filename your dump gets isn’t critical since DuckStation identifies BIOS files by their contents, but knowing these names helps when you’re troubleshooting which region your dump came from.
DuckStation is region-free in practice. A BIOS from any region will boot games from any other region, though pairing them correctly avoids occasional edge-case compatibility quirks. If you only have one console to dump, whatever region it is will work fine for your whole library.
| Common Filename | Region | Console Family |
|---|---|---|
| SCPH1001.bin | NTSC-U (North America) | Early original PS1 (SCPH-100x series) |
| SCPH5501.bin | NTSC-U (North America) | Mid-generation original PS1 |
| SCPH7001.bin | NTSC-U (North America) | Later original PS1 revisions |
| SCPH7003.bin | PAL (Europe) | Later original PS1 revisions |
| SCPH1000.bin | NTSC-J (Japan) | Early original PS1 |
These names are a long-standing convention across the PS1 preservation community rather than an official Sony naming scheme, and DuckStation reads the file’s contents rather than its filename to identify the region. Treat the table as a reference for recognizing what you likely have, not a checklist you need to match exactly.
Ripping Your Own Discs the Legal Way
The same ownership principle that applies to your BIOS applies to your game library. Ripping a PS1 disc you own to a BIN/CUE image for backup and personal use is a well-established practice, and any PC with an optical drive can do it using standard disc-imaging software. What you do with someone else’s discs, or images downloaded from strangers online, is a different legal question entirely and not one this guide covers.
A few practical notes make ripping smoother. Clean your discs before imaging, since PS1-era discs are old enough now that read errors from scratches or disc rot are common and will corrupt the resulting image. Rip at the slowest reliable speed your drive supports for scratched media, and always verify the resulting CUE file references the correct number of tracks, especially for games with CD-quality audio tracks mixed in alongside the data track.
Step 4: Dump Your BIOS and Verify the Checksum
Once you have a BIOS file, verify it before trusting it. A corrupted or incomplete dump is one of the most common reasons DuckStation refuses to boot anything, and the file will often look fine at a glance since the size can be close to correct even when a dump went wrong.
On Linux or macOS, run a checksum against the file and compare it to records from your own prior dumps or documentation you trust:
sha256sum SCPH1001.binOn Windows, the built-in certutil tool does the same job without installing anything extra:
certutil -hashfile SCPH1001.bin SHA256Move the verified file into the bios folder you created in Step 2. Keep the original filename intact rather than renaming it, since it makes future troubleshooting easier if you ever need to identify which revision you’re running.
Step 5: Add BIOS Files to DuckStation
Open Settings, then the BIOS tab. Point the BIOS directory field at the folder where you saved your dumped file. DuckStation scans that folder automatically and lists any valid BIOS images it finds, along with the region it detected for each one.
If your BIOS shows up with a green checkmark or a filled-in region label, it passed validation and you’re ready to move on. If the field stays empty or shows a warning icon, the file is either corrupted, incomplete, or not a genuine PS1 BIOS. Go back to Step 4 and re-verify the checksum before trying again.
Step 6: Run First-Time Setup
With a valid BIOS in place, work through the rest of the setup wizard or the Settings menu directly. Set your preferred language and region defaults, then point the Game Directory setting at the roms folder from Step 2. DuckStation will scan it and build a library list, complete with box art if you’ve added cover images to the covers folder.
This is also a sensible point to enable automatic updates if the option is available in your build, since DuckStation’s rolling release model means compatibility fixes land frequently rather than in occasional big-version jumps.
Step 7: Choose and Configure Your Renderer
The Graphics tab controls which rendering backend DuckStation uses. For most modern systems, Vulkan gives the best combination of performance and feature support, including the highest upscaling multipliers. Direct3D 12 is a solid alternative on newer Windows systems, while Direct3D 11 remains the safest fallback on older Windows hardware or GPUs with shaky Vulkan drivers.
| Renderer | Minimum API Version | Best For |
|---|---|---|
| Vulkan | Vulkan 1.0 | Modern GPUs on Windows, Linux, and Steam Deck |
| Direct3D 12 | Feature Level 12 | Recent Windows systems wanting the newest backend |
| Direct3D 11 | Feature Level 10.0 | Older or budget Windows GPUs |
| OpenGL | OpenGL 3.1 | Linux systems without solid Vulkan drivers |
| Metal | macOS default | Apple Silicon and Intel Macs |
| Software | None (CPU-based) | Systems without a usable GPU, or debugging renderer issues |
If you’re not sure which to pick, start with Vulkan. It’s the renderer most actively optimized for DuckStation’s newer features, and it’s what the project itself recommends for non-Linux systems in current guidance. Switch away from it only if you hit specific glitches that a different backend resolves.
Step 8: Turn On PGXP, Upscaling, and Texture Filtering
These three settings, all in the Enhancements tab, do the most visible work in modernizing how PS1 games look. Enable PGXP Geometry Correction first. It’s the single change that has the biggest impact, since it fixes the warping and wobbling you’ll otherwise see on every 3D model in every game.
Internal resolution scaling multiplies the PS1’s native output, which was roughly 256×224 to 384×480 depending on the game and mode. A 4x or 5x multiplier gets you a sharp, modern-looking image without pushing most hardware. Going higher than that mostly matters on large TVs or high-resolution monitors where the extra detail is actually visible.
Texture filtering smooths out the blocky, low-resolution textures the PS1 originally used. It’s a matter of taste. Some players prefer the crisper, more period-accurate look of filtering left off, while others prefer the smoother modern appearance with it on. Try both, since it costs nothing to toggle and preview live.
Step 9: Map Your Controller
Connect your controller before opening the Controller Settings tab, then select it from the detected device list. DuckStation supports standard input APIs, including SDL, XInput, and DInput on Windows, so most Xbox-style and DualShock/DualSense-style pads work immediately without extra drivers.
Map the face buttons, shoulder buttons, and analog sticks to their PS1 equivalents, and enable rumble if your controller supports it and you want that feedback forwarded from the emulated game. Save the profile once you’re happy with it, and consider creating per-game profiles for titles with unusual control schemes, such as light-gun games that work better mapped to a mouse.
Step 10: Organize Your Game Library and Convert to CHD
Most PS1 game dumps come as BIN/CUE pairs, which work fine in DuckStation but take up more disk space than necessary and scatter each game across multiple files. Converting to CHD (Compressed Hunks of Data) compresses the image and bundles everything into a single file, which makes a large library dramatically easier to manage.
The chdman tool, part of the MAME project, handles this conversion. For a single game:
chdman createcd -i "Final Fantasy VII (USA) (Disc 1).cue" -o "Final Fantasy VII (USA) (Disc 1).chd"For multi-disc games, convert each disc separately and keep them in the same folder with consistent naming, so DuckStation’s disc-switching feature can find the other discs when a game prompts you to swap.
Handling Multi-Disc Games Cleanly
A surprising number of the PS1’s best-remembered titles shipped across two, three, or even four discs. Final Fantasy VII, Final Fantasy VIII, Final Fantasy IX, Xenogears, and Metal Gear Solid all split their campaigns across multiple discs, and each one needs to be named and placed consistently for DuckStation to treat them as a single game with an in-emulator disc-swap prompt instead of several unrelated titles cluttering your library list.
Keep the disc number clearly marked in each filename, for example ending in “(Disc 1).chd” and “(Disc 2).chd” with everything else identical, and store all discs for one game in the same folder. When the game itself prompts you to insert the next disc, use DuckStation’s disc-change control (found in the System menu or a bound hotkey) rather than closing and reopening the emulator, which keeps your save data and in-progress state intact.
A clean folder structure once everything’s converted looks roughly like this:
DuckStation/
├── bios/
│ ├── SCPH1001.bin
│ └── SCPH5501.bin
├── roms/
│ ├── Final Fantasy VII (USA) (Disc 1).chd
│ └── Metal Gear Solid (USA).chd
├── memcards/
├── savestates/
└── covers/Step 11: Boot Your First Game
Double-click any title in your library list to launch it. You should see the PS1 startup sequence play out, followed by the game’s own boot logo and, eventually, its main menu. If PGXP is working correctly, you’ll notice it most in the first 3D cutscene or menu, where edges that used to shimmer and swim now hold steady.
Check the frame counter in the DuckStation overlay or window title. NTSC games should settle around 59.94 fps, PAL games around 50 fps, matching the console’s original television timing. Consistent numbers at those targets mean your renderer and enhancement settings are well matched to your hardware.
Step 12: Set Up Memory Cards and Save States
DuckStation gives you two separate ways to save progress, and they solve different problems. Memory cards emulate the real PS1 memory card, storing save data the same way a physical card would, in a format the game itself understands. Save states are an emulator-only feature that freezes the entire system at any moment, letting you resume from that exact instant later.
In the Memory Cards tab, DuckStation can automatically create a separate virtual card per game, which prevents one title’s saves from crowding out another’s the way physical 1-block PS1 saves used to. This per-game switching is one of the more underrated quality-of-life features in the whole emulator.
Save states live in the savestates folder and are bound to specific save slots you can trigger with hotkeys. Use them for quick checkpoints before a difficult section, but don’t treat them as a replacement for proper in-game saves, since save state files can lose compatibility across major emulator updates in a way memory card saves never do.
Step 13: Apply Cheats, Widescreen Hacks, and Keep DuckStation Updated
DuckStation includes a built-in cheat and patch system for games that support it, along with widescreen hack support for titles the community has patched to render outside the PS1’s native 4:3 frame. Both live in the per-game properties menu, accessible by right-clicking a title in your library.
Widescreen hacks are hit or miss depending on the game’s engine. Some titles adapt cleanly, while others stretch HUD elements or reveal geometry the developers never intended players to see off to the sides. Test each game individually rather than assuming the setting is safe to leave on globally.
Because DuckStation ships rolling releases instead of infrequent major versions, checking for updates every few weeks is worth the habit. Compatibility fixes, new PGXP refinements, and renderer improvements land continuously rather than in big batches, so a build from six months ago is missing more than you’d expect.
A Repeatable Setup Script for Linux and Steam Deck
If you’re setting DuckStation up on more than one machine, or rebuilding a library after a fresh install, this script automates the repetitive part: creating a consistent folder layout and batch-converting an entire folder of BIN/CUE images to CHD in one pass.
#!/bin/bash
# batch-convert-chd.sh
# Converts every BIN/CUE pair in the current folder to CHD
# and leaves the original files untouched.
set -e
mkdir -p chd_output
for cue in *.cue; do
name="${cue%.cue}"
echo "Converting: $name"
chdman createcd -i "$cue" -o "chd_output/${name}.chd"
done
echo "Done. Converted files are in chd_output/"Save it as batch-convert-chd.sh, make it executable with chmod +x, then run it from inside a folder full of BIN/CUE pairs. Combined with the folder structure from Step 10, this turns library setup from an evening of manual file-shuffling into a few minutes of waiting. Together with steps 1 through 13, this is a genuinely complete, working setup, not just an emulator that opens, but an organized library with a verified BIOS, converted disc images, and controller mapping ready to go.
5 Common Pitfalls When Setting Up DuckStation
- Downloading from a third-party mirror instead of GitHub. Since Flathub listings have gone stale or disappeared for some distributions after the 2024 license change, it’s tempting to grab a build from a random file-hosting site. Don’t, and be especially wary of sites advertising a pre-packaged “DuckStation + BIOS” bundle. A legitimate BIOS can only come from a console you dumped yourself (Step 3), so one bundled with the emulator is a reliable sign of a tampered or malware-loaded build. Stick to duckstation.org or the official GitHub releases page.
- Using a BIOS file that isn’t a genuine console dump. Files claiming to be “HLE” or high-level emulation replacements for the real BIOS circulate online, but they’re unreliable and cause compatibility problems DuckStation’s own documentation doesn’t support troubleshooting. Dump your own.
- Skipping CHD conversion until the library is huge. Converting 200 games at once is a long wait. Converting them as you add each one keeps the job small and keeps your BIN/CUE originals from piling up unconverted in the background.
- Maxing out PGXP and upscaling on a handheld. Steam Deck and similar devices handle PS1 emulation easily at native or moderate upscaling, but stacking 8x resolution with every enhancement enabled on FMV-heavy games can tank frame pacing and cause audio crackle.
- Losing memory card saves during a reinstall. Because memory cards and save states live in folders separate from the DuckStation executable, a careless reinstall that wipes the whole directory can take your saves with it. Back up the memcards folder before any major change.
Troubleshooting DuckStation: 10 Problems and Fixes
Most DuckStation problems trace back to one of a handful of root causes. Here’s what to check, in the order that resolves issues fastest.
| Symptom | Likely Cause | Fix |
|---|---|---|
| BIOS shows a warning or red icon | Corrupted or incomplete dump | Re-dump the BIOS and re-verify the checksum before re-adding it |
| Black screen after launching a game | Wrong or mismatched renderer for your GPU driver | Switch renderers in the Graphics tab, starting with Vulkan then Direct3D 11 |
| Game won’t appear in the library list | BIN/CUE files placed in a folder DuckStation isn’t scanning | Confirm the Game Directory setting points at your actual roms folder and rescan |
| Controller not detected | Input API mismatch or controller connected after DuckStation launched | Reconnect the controller, then reopen Controller Settings to force re-detection |
| Audio crackling or popping | Audio buffer too small for your system, or CPU overload from heavy enhancements | Increase the audio buffer size in Settings, or reduce internal resolution |
| Save states won’t load after an update | Save state format changed between DuckStation versions | Load your last memory card save instead, and treat states as short-term checkpoints only |
| 3D models still look warped with PGXP on | PGXP’s sub-options (Culling, Depth Buffer) not fully enabled | Check all three PGXP sub-toggles, not just the main Geometry Correction switch |
| Widescreen hack breaks the HUD | Game-specific patch incompatibility | Disable the widescreen hack for that title and keep native 4:3 for it |
| DuckStation missing from Flathub on Linux | Post-2024 license change packaging gap | Download the AppImage directly from the GitHub releases page instead |
| Game runs slower than expected on real hardware pace | Software renderer active instead of a hardware backend | Switch from Software to Vulkan or your platform’s native renderer |
Advanced Tips for DuckStation Power Users
Once the basics are solid, a few deeper features are worth exploring. RetroAchievements support is built in, and enabling it in Hardcore Mode disables save states and fast-forward for a more authentic, achievement-tracked playthrough, which some players prefer for replaying childhood favorites with actual stakes.
Per-game configuration overrides let you fine-tune settings for individual titles without changing your global defaults. This matters more than it sounds, since some PS1 games (particularly ones with unusual FMV codecs or unstable geometry in specific scenes) run better with PGXP’s depth buffer option toggled off even when the rest of PGXP works fine.
If you’re chasing maximum accuracy over convenience, the emulator also exposes a CPU clock speed override, sometimes called an overclock hack, that can smooth out slowdown in a handful of games that were CPU-bound even on original hardware. Use it sparingly since it can also introduce timing bugs the developers never tested for.
Community texture replacement packs are another rabbit hole worth knowing about, separate from DuckStation’s built-in filtering. These are hand-made or AI-upscaled texture sets for specific games that swap out the PS1’s original low-resolution art with higher-detail replacements, loaded through the emulator’s texture replacement folder. Quality varies enormously by game and by the pack’s creator, so treat any pack as optional polish rather than something to chase for every title in your library.
Finally, check the project’s GitHub wiki periodically. Because DuckStation ships rolling releases, documentation on newer features tends to land there before it makes it into any third-party guide, including this one.
Performance Tuning for Older or Low-End Hardware
Not everyone is running a recent gaming PC, and DuckStation still has room to flex on weaker hardware if you know which settings cost the most. Internal resolution is the biggest lever. Dropping from 4x back to native or 2x resolution recovers far more performance than it costs in visual quality on a small screen, and it’s the first setting worth touching on an aging laptop or a budget handheld.
PGXP’s individual sub-options aren’t equally expensive. Geometry Correction costs very little, while the Depth Buffer option costs more on weaker GPUs since it changes how the renderer handles overlapping geometry. If a game runs fine with Geometry Correction alone but stutters once you add Depth Buffer, leave the extra option off for that title rather than disabling PGXP entirely.
On genuinely constrained systems, such as an older laptop with integrated graphics, the software renderer is worth testing directly rather than assuming a hardware backend will always win. It bypasses driver overhead entirely, and for a console as old as the PS1, a modern CPU running the software path can sometimes outperform a weak or poorly supported GPU.
DuckStation vs ePSXe vs Mednafen vs RetroArch’s PS1 Core
DuckStation didn’t become the default choice in a vacuum. It’s worth knowing what it replaced and what still competes with it, especially if you’re coming from an older setup and wondering whether switching is worth the effort.
| Emulator | Development Status | Key Strength | Best For |
|---|---|---|---|
| DuckStation | Active, rolling releases | PGXP, upscaling, modern UI, per-game memory cards | Most players in 2026, on any platform |
| ePSXe | Largely legacy | Long-standing plugin ecosystem | Users with existing plugin-based setups |
| Mednafen (PSX core) | Active, accuracy-focused | Reference-grade timing accuracy | Preservationists and accuracy purists |
| RetroArch PS1 core | Active | One front end for dozens of systems | Players who want PS1 alongside other consoles in one app |
Mednafen’s core still has a reputation for the tightest low-level accuracy, and it’s the core RetroArch itself can load if you want that reference behavior inside a multi-system front end. But for the combination of visual upgrades, ease of setup, and active development, DuckStation is the one most 2026 guides converge on. If you’re already running RetroArch for other consoles, you can run both side by side without conflict.
DuckStation on Steam Deck and Linux Handhelds
Steam Deck’s Linux base makes it a natural fit for DuckStation, and Vulkan performance on the stock AMD Zen 2 APU handles even upscaled, PGXP-enabled games without trouble. If you’ve already set up an emulation-focused installer, note that DuckStation is typically bundled as part of a broader multi-emulator package rather than something you add standalone. Our EmuDeck tutorial covers that bundled path if you’d rather configure a dozen emulators at once instead of DuckStation alone.
Players running Bazzite or another SteamOS-style distro instead of stock SteamOS should follow the same AppImage-based install from Step 1. If you haven’t picked a base OS for your handheld yet, our Bazzite installation guide covers that decision in more detail. Either way, adding more storage before you build out a large CHD library is worth planning ahead for, and our Steam Deck SSD upgrade guide walks through that process.
What a Working Setup Looks Like
When everything’s configured correctly, here’s what you should be seeing at each stage. In Settings > BIOS, your dumped file shows a filled-in region label instead of a blank or warning state. Your library list in the main window displays box art (if you added cover images) alongside each game’s title and region tag.
A successful CHD conversion in the terminal looks roughly like this:
Converting: Final Fantasy VII (USA) (Disc 1)
Input: Final Fantasy VII (USA) (Disc 1).cue
Output: chd_output/Final Fantasy VII (USA) (Disc 1).chd
Compression complete, ratio approximately 45-55% of original size
Done. Converted files are in chd_output/In-game, the frame rate counter should hold steady near 59.94 fps for NTSC titles or 50 fps for PAL titles, PGXP-enabled 3D scenes should render without the classic wobble, and controller input should feel immediate with no perceptible lag between a button press and the on-screen response.
Frequently Asked Questions
Is DuckStation legal to use?
Yes. The emulator itself contains no Sony code and is legal to download and run in most jurisdictions. Legal risk comes from how you source BIOS files and games, not from running the emulator. Dump your BIOS and rip your discs from hardware you personally own.
Do I need my original PS1 to get a BIOS?
You need access to a PS1 console you own, whether that’s the one you grew up with or one you’ve since acquired secondhand. There’s no legitimate substitute file the emulator will accept as a proper replacement for a real dump.
Is DuckStation still open source in 2026?
Not in the traditional sense. It moved from GPLv3 to CC BY-NC-ND 4.0 in September 2024, which blocks commercial use and derivative works while keeping the source visible and the software free to use. A GPL-licensed fork called Swanstation exists if the license itself matters to you.
What’s the deal with DuckStation’s version numbers?
DuckStation doesn’t follow a traditional major-version release cycle. It ships continuous, rolling builds through its GitHub releases page, so there’s no single “current version” the way there might be for other software. Downloading the latest release is the standard approach.
Why did DuckStation disappear from Flathub or my Linux app store?
The September 2024 license change made some existing distribution channels legally uncertain for packagers to maintain, so several Linux repositories dropped or froze their listings. The GitHub releases page remains the reliable source regardless of what your distro’s app store shows.
Can DuckStation run without a BIOS file?
No. The BIOS handles boot logic the emulator relies on, and DuckStation will refuse to start a game without a valid one loaded. This is a deliberate, standard design choice across nearly all PS1 emulators, not a DuckStation-specific limitation.
What’s the difference between save states and memory cards?
Memory cards emulate the real PS1 save format that games themselves read and write. Save states are an emulator-only snapshot of the entire system at a single instant. Use memory cards for saves you want to keep long-term, and save states for short-term checkpoints during a session.
Does DuckStation work on Steam Deck?
Yes, and Vulkan performance on Steam Deck’s hardware handles PS1 emulation, including PGXP and moderate upscaling, without issue. Most Steam Deck users install it as part of a bundled multi-emulator package rather than standalone, though a direct AppImage install works too.
Does DuckStation support online netplay?
DuckStation’s development has focused on single-player accuracy and visual enhancements rather than online play. If playing PS1 games online with a friend is your main goal, check the project’s current feature list and wiki before assuming it’s supported, since this is an area that can change between rolling releases.
What internal resolution should I actually use?
4x is a reasonable default for most modern GPUs and most screen sizes, sharp enough to look modern without adding much load. Go higher only if you’re on a large 4K display and want to confirm the extra detail is worth the performance cost on your specific hardware.
How long does DuckStation setup actually take?
Budget about 60 minutes for a first-time setup across all 13 steps in this guide, including dumping and verifying your BIOS, mapping a controller, and converting a starter library to CHD. Repeat installs go faster once your BIOS and games are already organized.
Where should I actually download DuckStation from?
Only two sources are official: duckstation.org and the project’s GitHub Releases page. Grab the x64 build for a standard Windows PC or ARM64 for a Snapdragon-class Windows-on-Arm device, and avoid any third-party site bundling the emulator with a BIOS file, which is a reliable sign of a tampered or malware-loaded build.
Related Coverage
- PCSX2 Setup: PlayStation 2 Emulator in 10 Steps, 45 Min [2026]
- RPCS3 Setup: PS3 Emulation in 12 Steps, 40 Min [2026]
- Dolphin Emulator: GameCube & Wii in 12 Steps, 40 Min [2026]
- RetroArch Setup: 100+ Cores in 12 Steps [2026]
- EmuDeck Tutorial: Steam Deck Emulation in 12 Steps [2026]
- Bazzite Install: Gaming Linux in 12 Steps, 70 Min [2026]
- Decky Loader Setup 2026: Install Plugins in 10 Steps
