How a Lone Developer Reverse Engineered Fallout's Secret Source Code

What if I told you that one of the most influential RPGs ever made was secretly being rebuilt from scratch—and you can compile it yourself tonight?

For twenty-seven years, Fallout's original source code sat locked away in the vaults of Interplay, then Bethesda, then Microsoft. Modders hacked at binaries. Fans dreamed of fixes that never came. And then, in 2022, a developer named Alex Batalov did something that sounds impossible: he reverse engineered the entire game down to readable, compilable C code. The result? fallout1-re—a drop-in replacement for the original executable that runs your legally purchased copy without emulation, without wrappers, without compromise.

This isn't a remaster. This isn't a remake. This is the original Fallout, reconstructed neuron by neuron from its compiled binary, like reconstructing a dinosaur from fossilized DNA. And it's complete enough to finish the entire game.

If you're a developer, a game preservationist, or simply someone who believes classics deserve to live forever, what follows will blow your mind. We're diving deep into how fallout1-re works, why it matters for software archaeology, and exactly how you can build it yourself.

What Is fallout1-re?

fallout1-re is the Fallout Reference Edition—a fully reverse engineered source code repository for Fallout: A Post Nuclear Role Playing Game (1997). Created by independent developer Alex Batalov, this project represents one of the most ambitious acts of software preservation in gaming history.

The repository contains C source code that, when compiled, produces fallout-re.exe—a binary that serves as a drop-in replacement for the original falloutw.exe. No emulation layer. No compatibility shims. Just native code that speaks directly to your modern system while behaving identically to the 1997 release.

The Engine Heritage

Batalov didn't start from zero. This project builds directly on his earlier Fallout 2 Reference Edition, which he had already decompiled. The original Fallout engine is simpler than its sequel in many respects—no car travel system, no party control mechanics, a more straightforward dialogue system—yet it's fundamentally a different game. Rather than forcing both titles into a unified codebase, Batalov made the architecturally sound decision to maintain separate projects. This preserves each game's unique quirks and simplifies debugging.

Why Now? Why This Matters

Game preservation faces a crisis. Original source code for landmark titles vanishes in corporate mergers. Storage media degrades. Build environments become unrecoverable. When Microsoft acquired Bethesda in 2021, Fallout's future became even more uncertain. fallout1-re represents insurance against digital extinction—a fully documented, compilable backup that exists outside any single company's control.

The project operates under the Sustainable Use License, a modern license designed to balance open access with responsible stewardship. This isn't abandonware ethics; it's structured, legal preservation with clear boundaries.

Key Features That Make fallout1-re Extraordinary

Let's dissect what makes this project technically remarkable:

Binary-Accurate Decompilation

Batalov's goal isn't to "improve" Fallout—it's to restore the original source code with all its imperfections intact. That Windows/x86/640x480 constraint? Preserved deliberately. The original's DOS and Mac OS X ports are explicitly out of scope, maintaining laser focus on the most widely played version.

Drop-In Replacement Architecture

The compiled fallout-re.exe doesn't require game file conversion, asset extraction, or configuration wizardry. Copy one file into your existing Fallout directory. Run it. That's it. This architectural decision demonstrates profound respect for user experience and legal boundaries—you must own the game to play.

Fallout 2 Codebase Synergy

Approximately 94% of functions are fully reviewed and verified. The remaining 6% under review comes from shared Fallout 2 engine code. A small number of functions remain intentionally undecompiled—they're never invoked during gameplay, making them low-priority for preservation purposes.

Completion-Verified Fidelity

The project status is unambiguous: "The game can be completed from start to finish." This isn't theoretical completeness. Testers have finished the entire main quest, side content, and critical paths using the rebuilt engine.

Modern Build System

Unlike the original's presumably lost or obsolete build environment, fallout1-re uses contemporary tooling. You can compile with modern compilers, debug with modern tools, and extend with modern practices.

Real-World Use Cases: Where fallout1-re Changes Everything

1. Game Preservation & Archival

Museums, libraries, and academic institutions can now maintain buildable, documented source code for a landmark CRPG. When the original binaries eventually fail on future Windows versions, this repository ensures Fallout remains playable and studyable.

2. Bug Fix Research & Verification

Ever wondered if that infamous Junktown bug was really fixed in patches? With source code, researchers can diff versions, verify patch notes against actual changes, and understand why certain behaviors persisted across releases.

3. Modding Foundation

Current Fallout modding operates at the binary level—hex editing, memory patching, fragile hacks. fallout1-re opens the door to source-level modifications: cleaner fixes, new features built with proper engineering practices, and mods that don't break with every Windows update.

4. Educational Resource

Computer science programs studying game engine architecture, 1990s programming practices, or reverse engineering methodology now have a legally accessible, complete case study. Students can trace how a shipped RPG handled memory management, rendering, scripting, and save systems.

5. Platform Portability Research

While the project explicitly targets Windows/x86/640x480, the documented source code enables researchers to understand what would be required for proper ports—information previously locked in opaque binaries.

Step-by-Step Installation & Setup Guide

Ready to build Fallout from source? Here's your complete path from clone to gameplay.

Prerequisites

You must legally own Fallout. Purchase from:

• GOG
• Steam

Step 1: Clone the Repository

# Clone the source code repository
git clone https://github.com/alexbatalov/fallout1-re.git

# Enter the project directory
cd fallout1-re

Step 2: Examine Build Requirements

The repository uses CMake for cross-platform build configuration. Ensure you have:

• CMake 3.10+
• C compiler (MSVC recommended for Windows authenticity, MinGW acceptable)
• Windows SDK (for original API compatibility)

# Verify CMake installation
cmake --version

Step 3: Configure Build

# Create build directory
mkdir build && cd build

# Generate build files (adjust generator for your environment)
cmake .. -G "Visual Studio 17 2022" -A Win32

# Or for MinGW:
# cmake .. -G "MinGW Makefiles"

Step 4: Compile

# Build the project
cmake --build . --config Release

# Or with MSBuild directly:
# msbuild fallout1-re.sln /p:Configuration=Release

Step 5: Deploy to Your Game Directory

# The build produces fallout-re.exe in your build output
# Copy this file to your Fallout installation directory

# Example path (adjust to your installation):
copy Release\fallout-re.exe "C:\Games\Fallout\"

# Navigate to your Fallout directory and run
cd "C:\Games\Fallout"
fallout-re.exe

Verification

Launch the game. If you see the iconic "War. War never changes." intro, you've successfully built and run reverse engineered Fallout. The fallout-re.exe replaces falloutw.exe completely—your original executable remains untouched as backup.

REAL Code Examples: Inside the Engine

Let's examine actual patterns from the fallout1-re codebase and documentation.

Example 1: The Drop-In Replacement Design

The README's core deployment instruction reveals elegant architectural thinking:

// The compiled output follows this deployment pattern:
// fallout-re.exe → replaces → falloutw.exe
// 
// This is NOT a reimplementation that requires:
// - Asset conversion
// - Configuration migration  
// - Save game compatibility layers
//
// The binary speaks the same file formats, same protocols,
// same everything as the original 1997 executable.

Why this matters: Most reverse engineering projects produce something that resembles the original but requires migration work. Batalov's approach—matching the original's external interface exactly—means preservation without friction. The executable is a behavioral clone at the system boundary.

Example 2: Project Scope Boundaries

The README explicitly defines architectural constraints:

// Target platform specification from documentation:
// - OS: Windows (original target)
// - Architecture: x86 (32-bit, matching 1997 release)
// - Resolution: 640x480 (original fixed resolution)
// 
// EXPLICITLY OUT OF SCOPE:
// - DOS port (different executable, different constraints)
// - Mac OS X port (different ABI, different system calls)
// 
// This disciplined scope prevents feature creep that
// would compromise the "reference edition" fidelity.

The engineering lesson: Scope discipline is preservation discipline. Every additional platform, every "improvement," introduces deviation from the reference. Batalov's explicit exclusions protect the project's core mission.

Example 3: Contribution Boundaries

The contribution guidelines reveal sophisticated understanding of reverse engineering ethics:

// CONTRIBUTION CONSTRAINTS (from project documentation):
// 
// ACCEPTABLE:
// - Bug reports with reproduction steps
// - Inconsistency reports with save files
// - Code matching verified original binary behavior
//
// EXPLICITLY REJECTED:
// - New features not present in Fallout 1 binary
// - Code from Fallout 2 (belongs in separate project)
// - "Improvements" that change original behavior
//
// FUTURE DEVELOPMENT PATH:
// - New repository will be created post-decompilation
// - This repository frozen for historical reference

Critical insight: This creates clean separation between preservation and evolution. The reference edition remains pristine—a snapshot of 1997 engineering—while future development can branch without corrupting the historical record.

Example 4: Legal Framework Implementation

The license section demonstrates how modern open source intersects with reverse engineering law:

// LEGAL STRUCTURE (from README):
//
// Source production method: Reverse engineering of original binary
//
// DMCA EXCEPTIONS INVOKED:
// - Documentation (understanding system requirements)
// - Interoperability (running on modern systems)
// - Fair use (preservation of purchased software)
//
// PRACTICAL EXAMPLE OF INTEROPERABILITY:
// - Running legally purchased copy on Apple Silicon Mac
// - Would require x86 emulation without native recompilation
// - fallout1-re enables native execution through documented source
//
// LICENSE: Sustainable Use License
// - Permits use, study, modification
// - Contains provisions for responsible stewardship

The preservation strategy: Rather than hiding behind anonymity or jurisdictional ambiguity, Batalov documents his legal reasoning transparently. The reference to Issue #29 on the Fallout 2 project shows ongoing community legal discussion.

Advanced Usage & Best Practices

For Developers: Understanding the Build

Study the CMake configuration to understand how the project handles:

• Original Windows API dependencies: Which modern equivalents maintain behavioral compatibility?
• Assembly optimizations: Where does the decompiled C match original compiler output?
• Memory layout assumptions: How does the engine rely on 32-bit pointer arithmetic?

For Preservationists: Creating Derivatives

Once decompilation completes, the frozen repository becomes your canonical reference. Any derivative work should:

1. Fork from the final preserved state
2. Clearly document all behavioral deviations
3. Maintain compatibility with original save formats where possible

For Modders: Future-Proofing

The forthcoming "new repository" for continued development represents your opportunity. Subscribe to project notifications, prepare your modification plans, and engage with the community during transition.

For Researchers: Citation Practices

When referencing this work academically, cite:

• The specific commit hash (for reproducibility)
• The Sustainable Use License terms
• The original binary source (your purchased copy)

Comparison: fallout1-re vs. Alternatives

Why fallout1-re wins: It's the only approach combining source-level accessibility with verified behavioral fidelity and documented legal grounding.

FAQ: Your Burning Questions Answered

Do I need to own Fallout to use this?

Absolutely yes. The fallout-re.exe requires original game assets. The README explicitly directs purchase through GOG or Steam. This isn't optional—it's architectural and ethical design.

Is this legal? Will Bethesda shut it down?

The project operates under documented DMCA exceptions for documentation, interoperability, and fair use. However, the README candidly states: "Publishing this stuff to wide audience is questionable. Eventually it's up to Bethesda/Microsoft to takedown the project or leave it be." Download and participate while you can; preserve locally.

Can I use this to create a free version of Fallout?

No. The source code is useless without game assets. This preserves the engine, not the content. You still need your legally purchased copy.

How complete is the reverse engineering?

The game is fully completable from start to finish. ~6% of functions from the shared Fallout 2 codebase remain under review. Unused functions are intentionally skipped—decompiling dead code wastes effort without preservation value.

Will this run on Linux or macOS?

Not directly. The project targets Windows/x86/640x480 explicitly. However, the documented source code enables community ports. The legal framework specifically cites running on "modern Mac M1" as an interoperability goal.

Can I contribute new features?

Not to this repository. The project explicitly rejects new features. Wait for the post-decompilation "new repository" where continued development will occur. This repository will be frozen for historical integrity.

How do I report bugs?

Play through, document inconsistencies, and report with zipped save files. The project credits c6 for extensive gameplay testing—follow that model of thorough, evidence-based reporting.

Conclusion: Why fallout1-re Is Preservation Engineering at Its Finest

fallout1-re isn't nostalgia. It's infrastructure. Alex Batalov has built something that will outlive corporate ownership changes, platform obsolescence, and binary rot. When future historians study CRPG evolution, when educators teach game engine architecture, when fans want to experience the genuine 1997 article—they'll have this.

The discipline impresses me most. The explicit scope boundaries. The rejection of feature creep. The clean separation between preservation and evolution. This is how software heritage should be handled: documented, buildable, legally grounded, and community-engaged.

If you've ever bought Fallout and watched it struggle on modern systems, if you've ever wished you could study how the magic worked, if you believe classics deserve more than emulator approximation—clone the repository. Build it. Play it. Preserve it.

The vault door is open. The code is waiting.

→ Get fallout1-re on GitHub