Thousands of classic point-and-click adventure games from the 1990s and early 2000s simply will not run on a modern PC. The original executables were built for MS-DOS, Windows 3.1, or a specific version of Mac OS System 7 — operating systems that no longer exist outside of a virtual machine. ScummVM solves that problem by reimplementing the game engines themselves, not the operating systems they ran on, so titles like Monkey Island, King’s Quest, and Beneath a Steel Sky run natively on Windows, macOS, Linux, Android, and even a Steam Deck.

The project is entirely free and open source, sits at 2,753 GitHub stars as of this writing, and just shipped version 2026.3.0 “Carousels & Killer Whales” on 20 June 2026 with new game support and a Google Summer of Code-driven interface overhaul. This tutorial walks through installing ScummVM on every major platform, legally sourcing game data, configuring MIDI audio and graphics filters, and building a small automated script that batch-imports an entire library of freeware adventure games in one pass — a complete, working setup by the time you finish.

What Is ScummVM?

ScummVM stands for “Script Creation Utility for Maniac Mansion Virtual Machine” — a name that describes exactly what the project started as. It began in September 2001 when Swedish computer science student Ludvig Strigeus wanted to replay LucasArts’ Monkey Island 2 on Linux and found no way to do it. Vincent Hamm joined shortly after, and the first public release, version 0.0.1, went out on 9 October 2001. A Slashdot feature that November brought in the project’s first wave of outside contributors. Both founders moved on in 2002, and James “Ender” Brown took over leading development from there.

What started as a single-engine tool for one LucasArts adventure has grown into a multi-engine interpreter covering 325+ supported adventure games from LucasArts, Sierra On-Line, Revolution Software, Cyan Inc., and Westwood Studios, according to the official ScummVM homepage. The codebase is C++, licensed under GPL-3.0, and — checked live for this tutorial — currently sits at 2,753 stars, 1,338 forks, and 38 open issues on GitHub, with commits landing the same day this was written. That is an unusually active pace for a 25-year-old open-source project.

Why ScummVM Isn’t a Console Emulator

It is worth being precise about what ScummVM actually does, because the word “emulator” gets attached to it constantly and the label is misleading. A console emulator like Dolphin or RPCS3 reproduces a game console’s processor, memory layout, and graphics hardware in software, then runs the original, unmodified game binary on top of that simulated hardware — which is why those tools usually require a legally-dumped BIOS file. ScummVM does something different: it replaces the original game’s executable outright with a new, hand-written interpreter for that game’s underlying script engine, and reads only the original game’s data files (graphics, sound, dialogue, level scripts).

“ScummVM actually replaces the original executable file that shipped with the game.” “Your games can run on platforms they were never designed for!”

ScummVM official FAQ, docs.scummvm.org

That distinction matters in practice. No BIOS extraction, no firmware dumps, no simulated CPU — just a modern program reading old data files. It gives ScummVM a cleaner legal footing than most console emulators, though the project is still firm about where it draws the line: it will not distribute copyrighted game content, and it expects you to own what you play. On abandonware specifically, the FAQ is blunt: “‘abandonware’ is not a proper legal concept in any country.” More on getting game files legally in Step 6 below.

Prerequisites: Versions, Platforms, and What You’ll Need

ScummVM’s install footprint is small and its requirements are refreshingly light compared to console emulators — there is no BIOS to dump, no firmware to extract, and no discrete GPU requirement. Here is everything to have ready before Step 1.

RequirementDetails
Current version2026.3.0 “Carousels & Killer Whales” (released 20 June 2026)
LicenseGPL-3.0 (fully open source)
Supported desktop OSWindows (32-bit and 64-bit), macOS, Linux
Supported mobile/handheld OSAndroid, iOS, Steam Deck (native Linux, no Proton needed), muOS, Knulli, ROCKNIX, ArkOS
Disk space~50-250MB per game (varies by title; the ScummVM program itself is well under 200MB)
Game dataLegally-owned copies of the games you want to play, OR one of the 11 official freeware titles (Step 7)
Optional: MT-32 ROM filesOnly needed for authentic Roland MT-32 MIDI emulation (Step 10); not bundled, must be legally sourced separately

One documentation note worth flagging before you start: the official install guide warns that Linux distribution repositories “might not contain the most up-to-date version of ScummVM.” If you want 2026.3.0 specifically rather than whatever your distro packaged months ago, Flatpak is the more reliable route — covered in Step 4.

Step 1: Choose Your Installation Method

ScummVM ships through more channels than most open-source tools this size. Before picking one, it helps to know what each option gets you:

  • Official installer/DMG — always the current release, no distro lag, works offline once downloaded. Best for Windows and macOS.
  • Linux package manager (apt/dnf/pacman) — most convenient, but can trail behind the latest release by months.
  • Flatpak (org.scummvm.ScummVM) — current release, sandboxed, works identically across most Linux distros and on Steam Deck’s Discover store.
  • Steam or GOG — useful if you’re already buying ScummVM-ready adventure games there and want everything in one library (Step 6).
  • Official Android/iOS app — for phones and tablets, plus a GitHub-distributed APK if you prefer sideloading.

The rest of this tutorial covers each in order. If you already know which platform you’re installing on, feel free to jump straight to that step.

Step 2: Install ScummVM on Windows

Download the Windows installer directly from the official ScummVM downloads page — both 32-bit and 64-bit builds are available. Run the installer and accept the defaults unless you have a specific reason to change the install path. Since version 2.6.0, ScummVM also ships a portable ZIP build with no installer at all, which is handy if you want to run it from a USB stick or keep it outside Program Files.

After installation, launch it from Start > All Apps > ScummVM. The first window you see is the Launcher — this is ScummVM’s home screen, and it is where every game you add in later steps will show up as a clickable entry.

Step 3: Install ScummVM on macOS

Download the macOS build (.dmg) from the same downloads page, open it, and drag ScummVM.app into your Applications folder. One thing to expect: the official documentation notes plainly that “ScummVM is not available from the App Store,” which means macOS Gatekeeper will flag it as coming from an unidentified developer on first launch.

To get past that warning, right-click (or Control-click) ScummVM.app in Finder and choose Open, then confirm in the dialog that appears. You only need to do this once — after the first successful launch, macOS remembers your choice and opens it normally going forward.

Step 4: Install ScummVM on Linux

Every major Linux distribution packages ScummVM, and Flatpak/Snap cover the rest. Pick whichever matches your setup:

# Debian / Ubuntu and derivatives
sudo apt update && sudo apt install scummvm

# Fedora
sudo dnf install scummvm

# Arch Linux / Manjaro
sudo pacman -S scummvm

# Universal — Flatpak (recommended for the latest release)
flatpak install flathub org.scummvm.ScummVM

# Universal — Snap
sudo snap install scummvm

As flagged in the prerequisites, the apt/dnf/pacman routes install whatever version your distribution’s maintainers last packaged, which can lag behind the current 2026.3.0 release by a release cycle or more. If you specifically want new-game support added in 2026.1.0 through 2026.3.0 (covered in the Advanced Tips section below), use the Flatpak install instead — it tracks upstream releases far more closely.

Step 5: Install on Steam Deck, Android, and Handhelds

Steam Deck

Switch to Desktop Mode, open the Discover software store, search “ScummVM,” and install the Flatpak build. Because Steam Deck runs a genuine Linux distribution (SteamOS), this is a native build — there’s no Proton translation layer involved, unlike most Windows games on the platform. ScummVM also has its own listing on Steam itself, so installing through your existing Steam library works too and adds a Gaming Mode shortcut automatically.

Android and iOS

Install the official ScummVM app from the Play Store, or grab the APK directly from the project’s GitHub releases if you prefer to sideload. An iOS build is also available for jailbroken or sideloaded installs through the same channels.

Retro handheld firmwares

If you run a custom firmware like muOS, Knulli, ROCKNIX, or ArkOS on a retro handheld, ScummVM typically ships either bundled as a RetroArch core or as a standalone app in the firmware’s app store — check your device’s package manager first before manually compiling anything. Readers setting up a broader multi-emulator handheld from scratch may also want our Batocera setup guide or EmuDeck on Steam Deck walkthrough, both of which bundle ScummVM alongside dozens of console emulators.

This is the step every ScummVM tutorial has to be explicit about: ScummVM itself provides zero copyrighted game data. Installing it gets you an empty Launcher and nothing to play until you add game files you legally own. The project’s own FAQ is direct about this: “Our project has a strict no-piracy policy. Hence, we do not provide any support when it becomes evident that you did not obtain your game copy legally.”

There are several legitimate ways to get game data:

  • Your own original discs or floppies — copy the full contents of the CD/floppy to a folder on your hard drive; ScummVM reads from a folder, not a physical drive.
  • GOG.com — sells dozens of classic adventures pre-packaged with the ScummVM engine built directly into the installer, so there’s nothing extra to configure. Browse GOG’s ScummVM-tagged catalog directly.
  • Steam — beyond ScummVM’s own free listing, Steam separately sells titles like Disney’s Maniac Mansion re-release that run on the ScummVM engine under the hood.
  • The 11 official freeware games — completely free and legal, covered in full in Step 7.

On the question of whether you strictly need the original hard copy, the FAQ softens slightly: “Ideally yes, however we know that a lot of people don’t! If you do not have any hard copy games, there are some digital options available, including some games that have been released as freeware.” That freeware category is where most people setting up ScummVM for the first time should start, since it requires zero purchases and zero legal ambiguity.

Step 7: 11 Official Freeware Games You Can Play Right Now

Both ScummVM’s own site and Wikipedia document 11 adventure games that their original rights-holders have explicitly released as freeware. These are the fastest way to test your install with zero legal questions attached.

GameStudioYearFreeware Since
Beneath a Steel SkyRevolution Software (UK)19942003
Flight of the Amazon QueenWarthog Games (UK)1995Freeware release
Lure of the TemptressRevolution Software (UK)1992Freeware release
Broken Sword 2.5: The Return of the TemplarsFan-made2009Fan project, free by design
Drascula: The Vampire Strikes BackAlcachofa Soft (Spain)20002008
DreamwebEmpire Interactive (UK)1994Freeware release
SoltysL.K. Avalon (Poland)1996Freeware release
SfinxIndependent (Poland)—Freeware release
The Griffon LegendIndependent—Freeware release
Nippon Safes, Inc.Dynabyte Software (Genoa, Italy)19922021
Mystery HouseOn-Line Systems / Sierra (USA)1980Public/freeware release

Two entries in that list are worth calling out. Nippon Safes, Inc. was built by Genoa-based studio Dynabyte Software in 1992 for MS-DOS and Amiga, with three playable protagonists — Doug the safecracker, Dino the boxer, and Donna the dancer — wrapped in an icon-driven, comic-style interface clearly inspired by LucasArts’ house style. It’s the only Italian-made title on the freeware list, and its original authors declared it freeware in 2021. Mystery House, meanwhile, is a genuine piece of history: released by Sierra’s predecessor On-Line Systems in 1980, it’s widely credited as the first graphic adventure game ever made.

Download links for all 11 are on the official ScummVM site; each is a self-contained package you can point the Launcher at directly, which makes for a clean first test in Step 8.

Step 8: Add Your First Game Through the GUI

With ScummVM installed and at least one legal game folder ready (Beneath a Steel Sky is a good first choice — it’s short, freeware, and one of the engines with the widest testing coverage), adding it is a five-click process:

  1. Open ScummVM — you land on the Launcher screen.
  2. Click Add Game in the bottom toolbar.
  3. Browse to the folder where you copied or extracted the game’s data files.
  4. ScummVM auto-detects the engine and game from the files present and shows a match. If multiple candidate matches appear (this happens with some regional/CD variants), pick the one matching your exact release.
  5. Click Add Game to confirm. The title now appears as a permanent entry in your Launcher list — double-click it any time to play.

Repeat for every additional game folder. There’s no practical limit to how many titles can sit in one Launcher list, and each keeps its own independent settings (audio, subtitles, save location) separate from the global defaults.

Step 9: Launch Games From the Command Line

Everything the GUI does, the command line can do too — which matters once you want to script installs (Step 15) or launch a specific game directly from a shortcut. The base syntax is simple:

scummvm [option] [game]

Official example commands, taken directly from ScummVM’s documentation, for launching Full Throttle (target scumm:ft) straight from a mounted disc path:

# Windows
C:\Program Files\ScummVM\scummvm.exe -f -n -p "D:\resource" scumm:ft

# macOS
/Applications/ScummVM.app/Contents/MacOS/scummvm -f -n -p "/Volumes/Full Throttle/resource" scumm:ft

# Linux
/usr/games/scummvm -f -n -p /cdrom/resource scumm:ft

A handful of flags cover most day-to-day use. The full reference lives in the official command-line documentation, which lists well over 80 options — the table below is the practical subset most people actually reach for.

FlagShortWhat it does
--path=PATH-pSets the folder where the game is installed
--fullscreen-fForces full-screen mode
--no-fullscreen-FForces windowed mode
--add-aAdds all detected games from the current or specified directory
--detect—Lists games with their game ID from a directory, without adding them
--auto-detect—Lists games in a directory and starts the first one automatically
--recursive—Used with –add or –detect to also scan subdirectories
--list-targets-tLists every game already configured, then exits
--list-games-zLists every game engine ScummVM supports, then exits
--language=-qSets language (en, de, fr, it, pt, es, jp, zh, kr, sv, gb, hb, ru, cz)
--save-slot=NUM-xLoads a specific save slot on launch (0 = autosave)
--version-vPrints the installed ScummVM version and exits

One documented convention worth knowing: any boolean flag can be inverted by adding a no- prefix (that’s how --fullscreen and --no-fullscreen both exist), and by default, simply typing scummvm with no arguments opens the Launcher rather than starting a game.

Here’s what --list-targets returns after you’ve added a couple of games through the GUI in Step 8 — a quick way to confirm ScummVM sees everything you’ve configured:

$ scummvm --list-targets
Target               Description
------------------   -----------------------------------------------
sky                  Beneath a Steel Sky (VGA/DOS/English)
queen                Flight of the Amazon Queen (DOS/English)
drascula             Drascula: The Vampire Strikes Back (DOS/English)

Each line on the left is the “target” name you can pass directly to launch that exact game — for example, scummvm sky jumps straight into Beneath a Steel Sky without touching the Launcher menu at all.

Step 10: Set Up MT-32 MIDI Emulation for Authentic Audio

Many late-80s and early-90s PC games were composed specifically for the Roland MT-32, a hardware MIDI synthesizer module, and sound noticeably thinner on generic General MIDI or AdLib/OPL playback. ScummVM restores the original intended sound by integrating Munt, an open-source MT-32 emulator project. ScummVM has shipped Munt’s mt32emu 2.5.1 since its own version 2.5.0 in October 2021.

ScummVM does not and cannot bundle MT-32 ROM files — like game data, they’re copyrighted, and you need to source your own legally (typically dumped from a real Roland MT-32 unit you own). Once you have them:

  1. Place the ROM files in ScummVM’s “Extra Path” — set this under Launcher > Game settings > Paths, or globally via Options > Paths.
  2. Enable true MT-32 mode with the --native-mt32 flag, which disables General MIDI emulation in favor of the authentic emulation path.
  3. Optionally pin a specific SoundFont for non-MT-32 titles with --soundfont=FILE.
# Force true MT-32 emulation and set MIDI gain for a specific game
scummvm --native-mt32 --midi-gain=100 --music-driver=mt32 sky

If you skip this step entirely, ScummVM still plays music fine through its default AdLib/General MIDI emulation — MT-32 setup is purely an authenticity upgrade for the subset of games composed specifically for that hardware, not a requirement to get audio working at all.

Step 11: Configure Graphics Filters and Display Scaling

Original adventure games rendered at resolutions like 320×200, which look blocky stretched across a 27-inch 1440p monitor without help. ScummVM’s scaler and filter options smooth that gap:

# Launch with a specific graphics mode, scaler, and stretch mode
scummvm --gfx-mode=opengl --scaler=hq --stretch-mode=fit_force_aspect sky

--scaler accepts normal, hq, edge, advmame, sai, supersai, supereagle, pm, dotmatrix, or tv, each applying a different pixel-interpolation algorithm — hq and edge tend to look cleanest on 2D pixel art without over-blurring detail. --stretch-mode controls how the scaled image fills your display window: center, pixel-perfect, even-pixels, fit, stretch, or fit_force_aspect (the last one is usually the best default, since it fills the screen without distorting the original 4:3 aspect ratio). All of these are also available as dropdown menus in the Launcher’s Graphics tab if you’d rather not touch the command line at all.

Step 12: Map Controls for Gamepads and Touchscreens

Point-and-click adventures were designed around a mouse, which is the main friction point when running ScummVM on a Steam Deck, Android tablet, or retro handheld. ScummVM’s built-in keymapper handles the translation — each physical button or touch gesture can be bound to a virtual mouse action or keyboard key, and mappings are stored per-device in the [keymapper] section of the configuration file (Step 13).

On desktop, enable a connected controller with --joystick=NUM (0 for the first detected controller). On Steam Deck specifically, Valve’s own Steam Input layer can also remap the trackpads to emulate a precise mouse cursor, which many users find more comfortable than ScummVM’s native joystick-to-cursor translation for fine point-and-click accuracy. On handheld firmwares like muOS or Knulli, control mapping is typically preconfigured out of the box since those images ship ScummVM pre-integrated.

Step 13: Understand and Edit scummvm.ini Directly

Every setting changed through the Launcher GUI gets written to one plain-text configuration file, scummvm.ini. Editing it directly is faster once you’re comfortable with the format, and it’s the only practical way to batch-configure a large number of games at once.

OSConfig file path
Windows%APPDATA%\ScummVM\scummvm.ini (or C:\WINDOWS\scummvm.ini on very old systems)
macOS~/Library/Preferences/ScummVM Preferences
Linux (native/XDG)~/.config/scummvm/scummvm.ini
Linux (Snap)~/snap/scummvm/current/.config/scummvm/scummvm.ini

The file structure uses three kinds of sections: [scummvm] for global defaults, [keymapper] for global control bindings, and one [gameid] section per installed game (named after that game’s short target ID, the same string --list-targets prints). Per-game sections override the global defaults. Here’s an annotated example straight from the official documentation:

[scummvm]
gfx_mode=supereagle
fullscreen=true
savepath=C:\saves\

[sky]
path=C:\games\SteelSky\

[tentacle]
path=C:\tentacle\
subtitles=true
music_volume=40
sfx_volume=255

Notice how the [tentacle] section (Day of the Tentacle) overrides its own subtitle and volume settings while leaving the global gfx_mode and fullscreen defaults from [scummvm] untouched. This is the fastest way to give one specific game different settings — quieter sound effects for a dialogue-heavy title, for instance — without changing anything for the rest of your library. Full field-by-field documentation is in the official configuration file reference.

Step 14: Manage Save States and Back Up Your Progress

ScummVM’s save system mirrors each original game’s own save format rather than imposing a universal save-state system like a console emulator would — so save compatibility with the original DOS or Windows release is generally preserved. Slot 0 is reserved for autosave by default; slots above that are manual saves, and --save-slot=NUM loads a specific one directly from the command line.

Two settings control where saves live, both changeable per-game or globally in scummvm.ini:

  • savepath=PATH — where save files are written; set this to a synced folder (Dropbox, Syncthing, a NAS mount) if you want saves to follow you across machines.
  • --list-saves --game=TARGET — command-line flag that prints every save slot for a given game, useful for scripting backups.

Because ScummVM stores configuration and saves as plain files rather than in an opaque database, a complete backup is just two things: your savepath folder, and scummvm.ini itself. Copy both somewhere safe before reinstalling an OS or migrating to new hardware, and your entire library — games, settings, and progress — comes back in one step once you reinstall and re-add the same game folders.

Step 15: Automate Batch Imports With a Script (Complete Working Project)

Everything from Steps 6 through 9 comes together here: a small, complete shell script that takes a folder full of legally-owned or freeware game subfolders and registers every single one with ScummVM in a single pass — no manual Add Game clicking required. This is genuinely useful once your library grows past four or five titles.

First, lay out your games in one parent directory, one subfolder per game — for example, using three of the freeware titles from Step 7:

~/scummvm-library/
├── beneath-a-steel-sky/
├── flight-of-the-amazon-queen/
└── drascula/

Then save this as import-library.sh and make it executable with chmod +x import-library.sh:

#!/bin/bash
# import-library.sh — batch-detect and register every game folder with ScummVM
set -euo pipefail

LIBRARY_DIR="$HOME/scummvm-library"

if [ ! -d "$LIBRARY_DIR" ]; then
  echo "Library folder not found: $LIBRARY_DIR"
  exit 1
fi

echo "Scanning $LIBRARY_DIR for games..."

for game_dir in "$LIBRARY_DIR"/*/; do
  name=$(basename "$game_dir")
  echo "--- Detecting: $name ---"
  scummvm --detect --path="$game_dir" || echo "  (no supported engine detected in $name, skipping)"
  echo "--- Adding: $name ---"
  scummvm --add --recursive --path="$game_dir"
done

echo ""
echo "Import complete. Registered targets:"
scummvm --list-targets

Run it with ./import-library.sh. The script loops through every subfolder, uses --detect to confirm ScummVM recognizes a supported engine before touching anything, then uses --add --recursive to register it — the --recursive flag matters if any game’s files are nested one level deeper than the top folder, which happens with some CD-image extractions. The final --list-targets call prints your complete, freshly-imported library as confirmation, in the same format shown back in Step 9.

From here, the natural extension is a cron job or systemd timer that re-runs the script whenever you drop a new folder into ~/scummvm-library/, giving you a fully hands-off adventure-game library that stays in sync with zero manual Launcher clicks.

Common Pitfalls When Setting Up ScummVM

Most ScummVM setup problems trace back to one of these five mistakes:

  1. Installing via a Linux package manager and assuming it’s current. Distro repositories can lag the official 2026.3.0 release by months, silently missing new-game support and bug fixes. Use Flatpak if version currency matters to you.
  2. Expecting ScummVM to include games out of the box. A fresh install is an empty Launcher. This trips up more first-time users than any technical issue on this list — see Step 6 for legal sourcing options.
  3. Assuming MIDI will sound “authentic” without MT-32 ROM files. Default playback uses AdLib/General MIDI emulation, which is perfectly functional but noticeably different from what MT-32-composed games were designed to sound like. Step 10 covers the fix.
  4. Picking the wrong match when multiple game variants are detected. Some titles shipped in several regional or CD/floppy variants with slightly different files; if the Add Game screen offers more than one candidate, pick the one matching your exact release, not just the first option.
  5. Forgetting --recursive when game files sit in a nested subfolder. Disc-image extractions sometimes place the actual data files one directory level deeper than expected, which makes plain --add or --detect return nothing until you add --recursive.

Troubleshooting: 8 Common ScummVM Problems Solved

If something isn’t working as expected, check this table before searching further — these cover the vast majority of setup issues reported by new users.

ProblemLikely causeFix
Game not detected when addingWrong folder selected, or files are one level deeper than expectedPoint directly at the folder containing the game’s actual data files; try --detect --recursive from the command line to confirm
No sound, or MIDI plays silentlyNo SoundFont configured, or --native-mt32 set without valid ROM files presentSet a SoundFont with --soundfont=FILE, or verify your MT-32 ROMs are in the correct Extra Path (Step 10)
Black screen immediately after launch (3D engine games)Renderer incompatibility with your graphics driverForce a specific renderer: --renderer=software as a safe fallback, or --renderer=opengl/opengl_shaders
Choppy or crackling audioOutput sample rate mismatch with your audio deviceSet an explicit rate, e.g. --output-rate=22050 or 44100, matching your system default
macOS says the app “can’t be opened” / unidentified developerGatekeeper blocking a non-App-Store app on first runRight-click ScummVM.app → Open → confirm in the dialog (Step 3); only needed once
Gamepad or controller not respondingJoystick input not enabled, or no keymap configured for that deviceLaunch with --joystick=0 (or the correct index), and check keymapper bindings in Options
Save games missing after a reinstall or migrationsavepath folder wasn’t backed up before wiping the old installRestore your backed-up save folder and confirm savepath in scummvm.ini points at it (Step 14)
Fullscreen toggle doesn’t work or gets stuckUsing the wrong flag, or the display backend doesn’t support the requested modeUse -f to force fullscreen and -F to force windowed explicitly rather than toggling; note --window-size only applies under OpenGL

Advanced Tips: Accessibility, TinyGL, and What’s New in 2026.3.0

Beyond basic setup, three recent releases are worth knowing about if you want to get the most out of a current ScummVM install.

2026.1.0 “Like a Version” (31 January 2026) was the biggest release of the year, adding 12 new engines in one go. It also introduced text-to-speech accessibility support across the ADL, AGI, CinE, Cruise, Draci, Drascula, Hugo, and EFH engines — a real accessibility upgrade for players who need screen-reader-style narration of on-screen text — plus full TinyGL software-rendering support for the Freescape engine, which powers 3D titles like Driller and Dark Side.

2026.3.0 “Carousels & Killer Whales” (20 June 2026), the current release, added new-game support for Nancy Drew: The Haunted Carousel, Nancy Drew: Danger on Deception Island, Noctropolis, Cartoon Carnival, Alfred Pelrock: En Busca de un Sueño, and several Pilot Brothers titles. Interface work driven by this year’s Google Summer of Code shipped alongside them:

“Highlight clickable links in the GUI with a cursor change” and implementation of “kinetic scrolling in GUI lists.” The About dialog received a scrollbar, close button, and drag functionality, plus fluid scrolling across multiple widgets.

ScummVM 2026.3.0 release notes, GitHub

The same release also fixed a launcher search bug where results could appear empty even when matches existed, added a new NULL OPL driver aimed at lower-spec systems, and welcomed 14 new contributors — a reasonable proxy for how active development still is nearly 25 years after the project’s first release. If you’re running an older Flatpak or repo build, that new-game list alone is a good reason to update before starting Step 4 again.

ScummVM vs RetroArch vs DOSBox: Which Should You Use?

These three tools get lumped together constantly because they all run “old games,” but they solve genuinely different problems, and knowing which fits your specific game matters more than picking a single favorite.

ToolWhat it actually doesNeeds a BIOS?Best for
ScummVMReimplements individual adventure-game script engines (SCUMM, AGI, SCI, and dozens more) from scratchNoPoint-and-click adventures specifically — best-in-class compatibility and audio/graphics options for this one genre
RetroArchA “libretro” frontend hosting 100+ interchangeable emulator cores, including console systemsSometimes (console cores like PS1/N64 typically need one)Broad multi-system retro gaming — consoles, arcade boards, and computers in one shell, including a ScummVM core itself
DOSBoxEmulates real x86 PC hardware (CPU, sound cards, memory) to run unmodified DOS softwareNo, but needs the original game’s DOS executableDOS games outside ScummVM’s supported engine list — strategy, RPGs, sims, and anything not adventure-genre

In practice these aren’t mutually exclusive — plenty of setups run all three side by side. If your library is exclusively 90s point-and-click adventures, ScummVM alone covers you with less configuration overhead than either alternative, since it needs no BIOS and no hardware-accuracy tuning. For a broader multi-system retro setup that bundles ScummVM alongside console emulation, see our RetroArch setup guide or the frontend comparison in our Lutris setup guide, which lists ScummVM as one of its supported runners.

Frequently Asked Questions

Is ScummVM legal to use?
Yes. ScummVM itself is free, open-source software (GPL-3.0) that contains no copyrighted game content whatsoever — it’s a game engine reimplementation, not a distribution of copyrighted material. Legality depends entirely on how you source the game data you run through it; the project enforces a strict no-piracy policy and expects users to own what they play.

Does ScummVM come with any games included?
No. A fresh install is an empty Launcher. You add game data yourself, either from originals you own, ScummVM-ready purchases on GOG or Steam, or the 11 official freeware titles covered in Step 7.

Do I need a BIOS file, like with console emulators?
No. This is one of ScummVM’s biggest practical advantages over tools like RPCS3 or Dolphin — because it reimplements each game’s engine directly rather than emulating console hardware, there’s no firmware or BIOS dump required at any point.

What’s the real difference between ScummVM and DOSBox?
DOSBox emulates an entire x86 PC and runs the original unmodified DOS executable on top of it, which works for virtually any DOS-era program but requires more manual configuration (memory, CPU cycles, sound card selection). ScummVM instead rewrites each supported game’s engine from scratch, which means faster performance and simpler setup, but only for the roughly 325+ adventure games it explicitly supports.

Can I run ScummVM on Steam Deck without Proton?
Yes — ScummVM ships a native Linux build, so on Steam Deck (which runs SteamOS, a Linux distribution) it runs directly with no Windows translation layer needed. Install it via Flatpak through the Discover store in Desktop Mode, or through your Steam library directly.

Where do I get MT-32 ROM files for authentic MIDI music?
ScummVM does not bundle them, and there’s no legal free source — you need to dump them yourself from a physical Roland MT-32 unit you own. If you don’t have access to real MT-32 hardware, ScummVM’s default General MIDI/AdLib emulation still plays every game’s music correctly, just with a different instrument character than the original hardware.

Does ScummVM support controllers and touchscreens?
Yes, through its built-in keymapper system, which translates buttons, sticks, and touch gestures into virtual mouse movement and clicks. Support is strongest on Android and pre-configured handheld firmwares like muOS or Knulli; on desktop, enable a connected gamepad with the --joystick=NUM flag.

How do I update ScummVM to the latest version?
It depends on how you installed it. Flatpak and Snap installs update via flatpak update or automatically in the background; Windows and macOS require re-downloading the installer from the official downloads page; Linux package-manager installs update on your distribution’s normal update cycle, which — as covered in Step 4 — can lag behind the latest GitHub release by a significant margin.

For more retro gaming and emulation coverage, visit the Gaming section.