- Top Pick: Valve Steam Deck OLED 512GB
- Runner-up: Samsung T9 Portable SSD 2TB
- Also consider: 8BitDo Ultimate 2 Bluetooth Controller
Some of the best ways to play classic PC games on Linux do not involve the original programs at all. Over the past two decades, volunteer teams have rebuilt the engines behind games like Morrowind, Doom and Diablo from scratch, or on top of source code the original developers released, and published the results as open-source software. The rebuilt engine is only half of the package: it contains no levels, art or music, so it reads those from a copy of the game you already own.
The result is a useful hybrid. The code is new — maintained, portable and still being fixed — while the game itself is exactly the one you bought years ago, now running natively on Linux with modern resolutions and controllers, no compatibility layer required. This explainer covers how the model works, the engines that matter most, what they add over the originals, and where the honest limits sit.
As an Amazon Associate, we earn from qualifying purchases.
Quick answer
Open-source engine reimplementations replace the original game program with a modern, community-built engine while reusing the art, levels and sound from a copy you own. OpenMW runs Morrowind, GZDoom runs the Doom family, DevilutionX runs Diablo and OpenRA rebuilds early Command and Conquer — all natively on Linux, with widescreen, gamepad support and decades of bug fixes included.
Not an emulator, not a port: how the model works
An emulator pretends to be old hardware. A reimplementation does something different: it is a new program, written to read the original game’s data files and follow the original engine’s rules, so the game behaves as it did on entirely modern code. Some projects are clean-room rewrites built by studying the original game’s behaviour. Others are source ports, which exist because a developer — id Software most famously — published the original engine code, letting the community carry it forward.
The split between engine and data is what makes the model legal and durable. The engine, the part volunteers wrote, is free software you can download from your distribution’s repositories or Flathub. The data — levels, textures, sounds, video — stays copyrighted, and the engine is useless without it. You supply it from a copy you own: the data files from your original discs, or from the GOG or Steam installation in your library. Every project below documents exactly which files it needs. Nothing here points you at data downloads, because the arrangement only works, legally and practically, when the game on screen is the game you bought.
Linux is the natural home for this scene. The engines are built with portable toolkits, most ship official Linux builds, and several sit in mainstream repositories, so installing one is usually a single package-manager command.
The headline engines
OpenMW: Morrowind, rebuilt
OpenMW is a from-scratch reimplementation of the engine behind The Elder Scrolls III: Morrowind. Point it at the data files from your own copy — the project recommends the Game of the Year edition, which bundles the Tribunal and Bloodmoon expansions — and Morrowind runs natively on Linux with a modern renderer, widescreen resolutions the original never offered, and an active modding ecosystem that treats OpenMW as its primary target, plus fixes for long-standing bugs in the original engine. It is the clearest proof of the model: a 2002 game whose engine is newer than most remasters.
GZDoom: the Doom family and everything built on it
GZDoom is the most developed descendant of the Doom engine, whose source code id Software released in the 1990s. It plays Doom, Doom II, Heretic, Hexen, Strife and other games built on the same technology, reading the IWAD data files from copies you own. Around that base sits the largest mod scene in classic gaming: decades of community levels and total conversions are written for GZDoom. Its hardware renderer adds dynamic lighting and high resolutions, and Linux is a first-class platform for it.
DevilutionX: Diablo without the archaeology
DevilutionX rebuilds Diablo’s engine so the game runs on modern systems. It needs one file, DIABDAT.MPQ, taken from your own Diablo disc or GOG copy; the Hellfire expansion uses its own data files the same way. In return you get widescreen resolutions, gamepad support good enough for a handheld, cross-platform multiplayer, and fixes for bugs the original shipped with. It is a good first reimplementation to try because the setup is a single file.
OpenRA: Command and Conquer as a modern RTS
OpenRA reimplements the early Command and Conquer games — Tiberian Dawn, Red Alert and Dune 2000 — as one modern real-time strategy engine with online multiplayer, replays and a skirmish AI. The Tiberian Dawn and Red Alert asset packs were officially released as freeware by EA, and OpenRA can fetch those itself; Dune 2000 draws on data from your own copy. Where the other engines here mostly preserve, OpenRA also modernises: balance and interface follow contemporary RTS expectations while the units stay faithful.
The long tail: dhewm3, ioquake3 and friends
Beyond the headliners, the pattern repeats across PC history. dhewm3 keeps Doom 3 running natively using data from your own copy, with widescreen and modern input. ioquake3 does the same for Quake III Arena, reading the pak files from an installed copy. ScummVM, covered elsewhere on this site, applies a sibling version of the idea to adventure games. The shared recipe never changes: free engine, your data, modern system.
What the new engines add
Four gains show up in almost every project. The first is display support: resolutions, aspect ratios and refresh behaviour from this decade, applied to games designed for CRT monitors. The second is input — proper gamepad support and remappable controls, which is why so many of these engines feel at home on a Steam Deck. The third is fixes: reimplementation teams repair crashes, save corruption and logic bugs the original developers never patched, and their changelogs are public. The fourth is the mod ecosystem: because the engines are open and current, modders build for them today, so a game from 1996 can have a more active content scene than it did at launch.
There is also a preservation argument: an open engine does not depend on a storefront staying up or a licence server answering, so as long as you keep your game data, the combination keeps working.
The honest limits
The model has real edges. You still need the game: if you never owned Morrowind, OpenMW does nothing for you, and no engine here includes the data. Some projects are picky about versions, expecting a specific edition or expansion set, so check the project’s file list against your edition. Multiplayer varies — OpenRA and DevilutionX treat it as a headline feature, while other engines focus on the single-player original. And a reimplementation is a reading of the original engine, not the original binary; tiny behavioural differences exist, which matters to speedrunners and few others.
How to choose
Start from the game you want to replay, not the engine. Own Morrowind and want it modern: OpenMW. Own the Doom family or want the deepest mod library in classic gaming: GZDoom. Own Diablo: DevilutionX. Miss early Command and Conquer and want online matches: OpenRA. Then check the project’s documentation for its data-file requirements against the edition you own, and install the engine the way your distribution prefers — repository package or Flatpak. If a game has no reimplementation, that is what emulators and Proton are for.
Who should skip this
Skip this route if you do not already own the games, since the engines ship without data and this article will not help you find any. Skip it if you want a one-click storefront experience with no file handling at all — the setup is simple, but it does ask you to locate and copy data files once. Skip it if you need the original binary’s exact behaviour for speedrunning or archival purposes.
The hardware that suits these engines
None of these engines needs a powerful machine, so the useful hardware is about storage for your game library, controllers for engines with gamepad support, and a good pointer for the strategy titles.
Valve Steam Deck OLED 512GB
The natural home for this scene in handheld form. SteamOS is Linux, the engines above install from Flathub, and the gamepad support in GZDoom and DevilutionX maps cleanly onto the Deck’s controls.
Specs:
– Display: 7.4-inch HDR OLED, 90 Hz
– Storage: 512 GB NVMe SSD
– Memory: 16 GB LPDDR5
– System: SteamOS 3
– Input: dual trackpads, touchscreen, full gamepad controls
– Model: 814585022254
Samsung T9 Portable SSD 2TB
A fast external drive for carrying an installed game library — the data files these engines read — between a desktop, a laptop and a docked handheld.
Specs:
– Capacity: 2 TB
– Interface: USB 3.2 Gen 2×2
– Sequential read: up to 2,000 MB/s, maker-stated, on a host that supports Gen 2×2
– Model: MU-PG2T0B/AM
– Dimensions: 3.46 x 2.36 x 0.55 inches
– Weight: 4.3 ounces
8BitDo Ultimate 2 Bluetooth Controller
A modern pad for the engines that gained gamepad support in their second lives, connecting over Bluetooth, a 2.4 GHz adapter or a cable.
Specs:
– Sticks: TMR joysticks
– Triggers: switchable Hall effect and tactile modes
– Connection: Bluetooth, 2.4 GHz and wired USB-C
– Extras: charging dock included, motion control on supported platforms
– Model: 80ND
8BitDo Pro 2 Bluetooth Controller
The retro-leaning alternative, with a classic layout that suits the 1990s games these engines revive, plus back buttons for the keyboard shortcuts older games assume.
Specs:
– Sticks: Hall effect joysticks
– Buttons: 2 pro back paddle buttons, 3 switchable profiles
– Connection: Bluetooth 4.0 and USB-C wired
– Battery: 1,000 mAh rechargeable, 20 play hours maker-stated
– Model: 6922621505051
Kensington Expert Mouse Wired Trackball (K64325)
For OpenRA and the strategy shelf, a stationary trackball gives precise cursor control without needing desk space for mouse travel, and its wired USB connection needs no pairing on Linux.
Specs:
– Ball: 55 mm, DiamondEye optical tracking
– Controls: 4 buttons with ScrollRing
– Connection: wired USB-A
– Design: ambidextrous, detachable wrist rest included
– Model: K64325
– Warranty: 5-year, maker-stated
FAQ
Is this legal?
The engines are free, open-source software, and downloading one is no different from installing any other Linux package. The game data is the copyrighted part, which is why every project requires files from a copy you own — your discs or your GOG and Steam installs.
How is this different from a remaster?
A remaster is a commercial product: new assets, a new licence, a store page. A reimplementation is community software that reuses your existing copy’s assets, keeping the original art and levels exactly as they were while replacing only the code. It also stays maintained independently of any publisher’s plans.
Do my old save games work?
Often, yes, because the engines read the original data formats, but it varies by project. OpenMW uses its own save format rather than the original’s, while DevilutionX and GZDoom sit closer to theirs. Check the project’s documentation before assuming an old save will carry over.
Where do I install these on Linux?
Most headline engines are packaged for major distributions and available on Flathub, and the Steam Deck’s Discover store fronts the same Flatpak catalogue. Install the engine first, then follow the project’s guide for which data files to copy from your game installation.
Final verdict
Engine reimplementations are the quiet success story of classic gaming on Linux. They ask one thing of you — a copy of the game you own — and in return hand back that game running natively, at modern resolutions, with modern controls and an engine still maintained today. If your shelves or store library hold Morrowind, Doom, Diablo or early Command and Conquer, OpenMW, GZDoom, DevilutionX and OpenRA are the best versions of those games you can play on Linux, and the most durable ones too.










