Featured
If you grew up in the late 1990s with a beige PC under the desk, there’s a fair chance you remember Captain Claw — a 2D side-scrolling platformer about a swashbuckling pirate cat, originally released in 1997 by Monolith Productions. It was sharp, fast, and packed with personality, and for a particular generation of players it sits somewhere alongside Earthworm Jim or Jazz Jackrabbit 2 in the pantheon of late-90s platformers that defined a specific corner of PC gaming.
The trouble is, Captain Claw was built for a world that no longer exists. It expects a 1997 version of DirectX, talks to hardware that’s three decades gone, and was never properly updated for the move to Windows XP, let alone Windows 10 or 11. Getting the original to run cleanly on a modern machine is a journey involving virtual machines, community patches, and a lot of patience.
That’s the gap OpenClaw sets out to fill. It’s an open-source, community-built reimplementation of the game’s engine — a fresh codebase that loads the original assets and runs the game properly on modern hardware, no DOSBox required.
This guide walks through what OpenClaw is, why projects like it matter, how it works under the hood, and what you should know before you fire it up.
Quick summary: what OpenClaw is
In one line: OpenClaw is an open-source recreation of the original Captain Claw game engine, written in modern C++ on top of SDL, distributed on GitHub. A few important nuances:
- It’s the engine, not the assets. OpenClaw doesn’t ship the game’s levels, sprites, sound effects, or music. Those are still owned by the original rights holders. You provide your own copy of the original game, and OpenClaw uses its files.
- It runs on modern operating systems. Windows, Linux, and macOS, on hardware that didn’t exist when Claw was originally written.
- It’s a labour of love. Maintained by a small group of contributors who care enough about a 1997 platformer to write a new engine for it.
If you’ve ever heard of OpenMW (the open-source engine for Morrowind) or OpenRA (Red Alert), OpenClaw is the same idea applied to Captain Claw.
A brief refresher on Captain Claw
To understand why anyone would spend hundreds of hours rebuilding Claw from scratch, it helps to remember what made the original work. Captain Claw dropped in 1997, the same year Monolith shipped Blood and Quake II hit shelves. The PC gaming market was sprinting toward 3D — but Monolith bet against the trend with a high-budget, lovingly hand-animated 2D side-scroller. It worked. Claw shipped with:
- Sprawling levels split across pirate ports, frozen mountaintops, and an undead cemetery
- A real combat system with parries, special moves, and weapon swaps
- Pixel art and animation good enough to still hold up today
- A theme song you will absolutely have stuck in your head ten minutes after starting
It also had LAN multiplayer and a community of fan-made levels through a built-in editor — features that bred a small but dedicated modding scene that’s still around almost three decades later.
For most of its life, though, Claw has been gradually getting harder to play. Stock copies don’t run cleanly on modern Windows. Modern resolutions break the rendering. The game’s networking assumes a DirectPlay world that hasn’t existed for years.
That’s the problem space OpenClaw walked into.
Why projects like OpenClaw matter
It’s easy to dismiss “let’s rewrite a 1997 platformer” as nostalgia. It isn’t.
The story of digital media in the last 30 years is partly a story of disappearing software. Games tied to specific hardware, DRM servers that get switched off, file formats nobody documented — entire categories of work vanish quietly because nobody re-implements the runtime that played them. Once the original engine stops working, the game stops existing for most people, no matter how popular it once was.
Engine reimplementations are how the community fights back. The pattern looks like this:
- A studio releases a game with a custom engine.
- The engine eventually breaks on modern systems.
- The studio either no longer exists or has no commercial reason to update it.
- Fans, with no access to the original source, reverse-engineer the game’s data formats and write a new engine from scratch that loads those formats.
- The original artwork, music, and design survive — playable, modifiable, and crucially, runnable on hardware that doesn’t yet exist.
OpenMW does this for Morrowind. OpenRA does it for early Westwood RTS games. OpenTTD did it for Transport Tycoon Deluxe. ScummVM does it for a whole catalogue of point-and-click adventures. OpenClaw belongs to that family. It’s a small project for a smaller game, but it’s solving the same problem.
For developers, these projects are also a brilliant masterclass. Reverse-engineering a game’s level format and rebuilding its physics from scratch is the kind of exercise that turns mid-level programmers into senior ones. Look at any of these repos and you’ll see graphs of contributor commits where one person’s first PR was renaming a variable and their tenth PR was rewriting the collision system.
How OpenClaw works under the hood
You don’t need to be a C++ engineer to use OpenClaw, but a quick tour of the architecture explains a lot about what the project is and isn’t trying to do.
The engine: C++ and SDL
OpenClaw is written in modern C++ and built on top of the SDL (Simple DirectMedia Layer) library. SDL is the de facto standard for cross-platform game development at the low level — it abstracts away the differences between Windows, Linux, and macOS for things like windowing, input, audio, and 2D rendering.
That choice matters for two reasons:
- Portability. Because SDL runs everywhere, OpenClaw runs everywhere. Linux users who could never get the original game working on Wine suddenly have a clean path to playing it.
- Maintainability. SDL is actively maintained and will be for the foreseeable future. Building on top of it means OpenClaw inherits decades of platform-compatibility work for free.
The original game shipped on top of a Monolith-built engine that talked directly to Windows-only graphics and sound APIs of the era. OpenClaw replaces all of that with portable equivalents.
The assets: bring-your-own .rez files
Captain Claw stored its game data inside .rez archive files — a Monolith-specific format used in several of their late-90s games. Levels, sprites, music, sounds, and level scripts all live inside those archives.
OpenClaw’s contributors reverse-engineered the .rez format and built code to parse it. That means OpenClaw can read the original game’s files directly, without any conversion step. You point the engine at your existing Claw install directory, and it loads the levels exactly as they were shipped in 1997.
This is the legally and ethically careful part. OpenClaw never distributes copyrighted assets. It’s strictly an engine. You provide the data.
Physics, AI, and gameplay logic
This is the hardest part of any reimplementation project, and the reason these things take years.
The original engine’s behaviour — how Claw’s jump arc feels, how an enemy parries, the exact timing of a falling platform — is nowhere documented. It only exists as compiled machine code in a 1997 binary, and as a fuzzy memory in long-time players.
To rebuild it, contributors typically mix three techniques:
- Reverse-engineering the original binary to extract numeric constants
- Frame-by-frame video comparison between the original game and the new engine playing the same level
- Community testing where dozens of players report “this feels wrong” until the right tuning emerges
That’s why a reimplementation can hit “the game is playable” relatively quickly but take much longer to reach “the game feels right.” OpenClaw has spent a long time in the second category, and is the better for it.
The level editor and modding
One of the original game’s strengths was a fan modding scene around the built-in level editor. OpenClaw is engine-compatible enough that many community-built levels from the late 90s and 2000s still load and play.
For modders, this matters: levels they made twenty-plus years ago, that were slowly dying along with the original engine, now have a fresh runtime they can run on.
Getting started: what you’ll need
OpenClaw isn’t a one-click install. It’s a developer-flavoured project, which means there’s a small learning curve. Here’s what the typical setup looks like.
1. A copy of the original game
This is non-negotiable. Without the original Claw game files, OpenClaw has nothing to load. Original CDs still surface on second-hand markets, and the game has periodically been available on digital storefronts.
2. The OpenClaw release for your platform
The project’s GitHub page is the canonical source. It typically hosts:
- Pre-built binaries for Windows (and sometimes Linux), if you don’t want to compile.
- Source code, if you want to build it yourself.
For most users, the binaries are the fastest path.
3. Point OpenClaw at your game files
The typical flow is: drop OpenClaw into the directory where your Captain Claw files live, or configure OpenClaw to point at that directory. It expects the original .rez archives in the place the original game put them.
After that, it’s mostly: launch the executable, pick a level, play.
4. Optional — building from source
If you’re comfortable with a C++ toolchain (CMake, a compiler, SDL development libraries) you can build OpenClaw from source and run the latest in-progress code. This is also the path if you want to contribute fixes or features back to the project. The README in the GitHub repo documents the current build steps.
What’s playable, and what isn’t
OpenClaw’s progress isn’t binary — different parts of the original game are reimplemented to different degrees. A broad snapshot:
- Singleplayer levels. The main campaign is largely playable. Some level scripting, cutscene triggers, or specific enemy behaviours may differ subtly from the original.
- Combat and movement. The core feel — running, jumping, sword combat — is well within the right zone, though long-time players will sometimes notice minor differences in timing.
- Audio. Music and sound effects load from the original assets and play correctly.
- Multiplayer. The original game’s weakest area on modern systems, and similarly a lower-priority area in OpenClaw.
- Save states and quality-of-life. Things like save points, in-game settings menus, and resolution scaling have gradually been modernised.
Because OpenClaw is community-built, the right place to check the current state of any specific feature is the project’s GitHub issues and release notes, not a blog post that ages. Treat this article as a map, not a manual.
The legal model — engine reimplementations explained
People often assume an open-source remake of a copyrighted game is legally questionable. It usually isn’t, as long as a careful line is drawn.
The line is roughly this:
- Original code is copyrighted. You can’t copy it, decompile it, and republish it.
- Original assets are copyrighted. You can’t bundle the sprites, music, levels, or text.
- File formats and gameplay behaviour are generally not copyrightable. You’re allowed to study how a file is structured and write your own code that reads or writes that format.
- Independently written code that reads someone else’s file format is your own work.
This is the doctrine engine reimplementation projects live under, and it’s well-established by decades of case law. OpenMW, OpenRA, OpenTTD, ScummVM — all of them follow the same model. They ship engines, not assets, and they require the user to provide a legitimate copy of the original game.
OpenClaw plays by the same rules. That’s why every setup guide insists on the original game files.
Who OpenClaw is for
It’s worth being honest about the audience. You’ll get a lot out of OpenClaw if:
- You played Captain Claw in the 1990s and want to revisit it on a modern machine
- You’re a Linux or macOS user who could never get the original to run cleanly
- You’re a developer curious about how engine reimplementation projects work in practice
- You’re a modder who wants community levels from the original era to keep running
You probably won’t get much out of it if:
- You’ve never played Captain Claw and you’re not specifically into late-90s platformers — there are many modern games doing similar things with better polish
- You want a fully turn-key, pixel-perfect, identical-to-the-original experience — small differences will exist
- You don’t have access to the original game files
For everyone in between, it’s a genuinely lovely piece of software preservation.
How to contribute (or just follow the project)
The OpenClaw repository on GitHub is the centre of gravity for everything. If you want to participate, the well-trodden onramp looks like:
- Star and watch the repo to get release notifications.
- Read existing issues before opening new ones. Many “bugs” are already known and tagged.
- Pick up a “good first issue” if you want to write code. These are usually small, scoped tasks that don’t require deep knowledge of the engine internals.
- Test new builds and report regressions. Even non-coders are useful here — gameplay testers who can describe what feels wrong in a specific level are extremely valuable.
- Document things. Setup guides for specific platforms, FAQs, and tutorials all help newcomers and rarely require touching code.
Engine reimplementation projects almost always have more demand for testers, documentation writers, and triagers than for new C++ engineers. If you’ve ever wanted to contribute to an open-source project but felt outclassed by the codebase, OpenClaw’s adjacent work (issue triage, docs, testing) is a very welcoming on-ramp.
What OpenClaw says about the broader open-source preservation movement
OpenClaw is small. It’s one engine for one game with a niche audience. But the pattern it represents — fans rewriting commercial software from scratch to keep it alive on modern hardware — is one of the more quietly important things happening in software right now.
A few observations to close on.
Preservation is engineering
When most people think about preserving old games, they think about museums, emulators, or ROM archives. Those have their place, but they’re surface-level fixes. An emulator preserves the original hardware. An engine reimplementation preserves the game itself, freed from any specific hardware era. The latter is harder and more valuable, but it requires real engineering effort — exactly what OpenClaw is.
Open source is how niche software survives
A commercial vendor will never put resources into making a 1997 platformer run on the operating system of 2036. There’s no business case. Open-source projects, sustained by communities of people who simply care, are how niche software stays alive across decades. The cost of caring about niche software has been pushed entirely onto volunteers, and projects like OpenClaw are the result.
The lessons travel
The patterns in OpenClaw — reverse-engineering file formats, abstracting a platform layer, rebuilding gameplay through observation and tuning — are exactly the patterns engineers use when working with legacy systems in their day jobs. If you ever have to “modernise a fifteen-year-old internal application,” you are doing a more boring version of what OpenClaw contributors do for fun.
That’s worth respecting.
Bottom line
OpenClaw is an open-source reimplementation of a 1997 platformer’s engine, built in modern C++ on top of SDL, distributed via GitHub. You bring your own copy of the original game files; the engine handles the rest. It runs on Windows, Linux, and macOS, and it’s the cleanest way to play Captain Claw on a modern machine.
If you’re looking for nostalgia, it delivers. If you’re looking for a window into how open-source software preservation actually works in practice, it’s a lovely small case study — short enough to read in an evening, complete enough to teach you the shape of the problem.
For anyone of a certain age, simply seeing the title screen render correctly at 4K on a Linux laptop in 2026 is its own small kind of magic.