Second Reality: 32 Years of Demoscene Excellence

Thirty-two years ago today, on October 7, 1993, Future Crew released Second Reality at Assembly ‘93 in Helsinki, Finland. It won first place in the PC demo competition and changed what people thought was possible on IBM-compatible hardware. For a generation of developers, including me, it was the moment computing stopped being a tool and became an art form.

I still remember the anticipation. The modem’s carrier tone. The glacial progress bar as the file downloaded from a local BBS at 14.4 kbps. The nervous excitement of typing SECOND.EXE and hoping my 486 DX2/66 was fast enough. Then the screen exploded with impossible graphics, pulsing to a soundtrack that shouldn’t have been possible on PC hardware.

That moment changed everything for me. Today you can see it for yourself, instantly, in the browser, with nothing to download: doskit.net/?app=secondreality

The BBS Era: When Demos Were Treasures

The demoscene of the early 1990s lived in a completely different world. There was no YouTube to watch demos. No GitHub to download source code. No Discord servers to discuss techniques. There were BBSes, hundreds of them, each a small island of digital culture reachable only through a direct modem connection.

Finding Second Reality meant:

1. Discovery: Hearing about it through word-of-mouth, reading about it in a text file, or seeing it mentioned in another demo’s credits
2. Location: Finding a BBS that had it (not guaranteed; many boards had limited storage)
3. Access: Hoping the BBS wasn’t busy (most had 1-4 phone lines maximum)
4. Download: Waiting hours for the 2.4MB file to transfer, praying the connection didn’t drop
5. Verification: Checking the file wasn’t corrupted during transfer
6. Experience: Finally running it on your hardware, hoping it was compatible

This friction made demos precious. You didn’t casually click a link and watch. You invested time, effort, and often money (long-distance phone charges were real). When you finally got Second Reality running, you’d watched that progress bar for hours. You’d earned it.

Technical Achievements That Defined an Era

What made Second Reality legendary wasn’t how it looked. It did things people thought were impossible on PC hardware.

The Architecture: Elegant Modularity

When the source code was released in 2013 for the demo’s 20th anniversary, the demoscene expected a monolithic mess of assembly code. Instead they found a modular architecture with real software engineering behind it.

The structure was unusual for the time:

• The Loader: A minimal 20KB engine that handled initialization and part sequencing
• The DIS (Demo Interrupt Server): A custom interrupt handler providing services to all parts
• 32 Independent Executables: Each visual effect was a self-contained DOS program

This let development run in parallel. Multiple team members could work on different parts at once without conflicts. Each part had a 450KB memory budget and full autonomy within it. When a part finished, the loader overwrote it with the next one. Simple memory management that worked.

The codebase metrics tell the story:

Language                files       code
Assembly                   99     33,350
C++                       121     24,551
C/C++ Header                8        654
Make                       17        294
DOS Batch                  71        253
Total:                    316     59,102

This wasn’t assembly hackers pushing hardware limits. It was a team picking the right tool for each job: assembly for performance-critical rendering, C++ for logic and coordination, makefiles for build automation. The codebase was nearly twice the size of the original Doom engine, and it stayed maintainable because the architecture was disciplined.

The Copper Simulator: Amiga Envy Solved

One of Second Reality’s best tricks was simulating the Amiga’s Copper coprocessor on PC hardware. The Copper was a favorite feature of Amiga computers: a specialized processor that could run programmed instruction streams in sync with the video hardware, which made effects possible that were difficult or impossible on PCs.

Future Crew didn’t accept this limitation. They built a Copper simulator using the PC’s 8254 Programmable Interval Timer (PIT) and 8259 Programmable Interrupt Controller (PIC). By carefully programming timer interrupts synchronized with VGA vertical retrace, they achieved similar capabilities:

• Triggering custom routines at specific scanline positions
• Changing palettes mid-frame for color cycling effects
• Synchronizing visual effects with music timing
• Enabling effects previously thought to require dedicated hardware

That took real systems-level engineering: a deep understanding of PC hardware architecture, interrupt handling, and precise timing control.

Development vs. Production: Seamless Workflow

The attention to developer experience was well ahead of its time. The team built infrastructure that made moving from development to production painless:

Development Mode:

• DIS loaded as a TSR (Terminate and Stay Resident) program
• Each part ran as an independent executable
• Individual testing without running the full demo
• Standard DOS file I/O for loading assets

Production Mode:

• DIS embedded in the main executable
• All parts encrypted and appended to SECOND.EXE
• Custom DOS interrupt handlers for file operations
• Single 1.45MB executable containing everything

The clever part was that a part didn’t need to know which mode it was running in. The same code worked in both. It’s the kind of abstraction modern developers take for granted in tools like Docker, and Future Crew built it in 1993 with assembly and C++.

Cultural Impact: From Demoscene to Game Industry

Second Reality’s influence reached well beyond the demoscene. Several Future Crew members went on to found Remedy Entertainment, the studio behind Max Payne, Alan Wake, and Control. The same skill and vision that went into Second Reality became the foundation of a major game studio.

This pattern repeated across the industry. The demoscene became a training ground for game developers, graphics programmers, and technical artists. The skills demos demanded (extreme optimization, creative problem-solving under constraints, real-time graphics programming) carried straight over to game development.

The demoscene taught a generation of developers that constraints breed creativity. When you have 450KB for an entire visual effect including code and assets, you learn to be resourceful. When you’re targeting a 486 CPU without hardware acceleration, you learn to optimize. When you’re competing at Assembly, you learn to push boundaries.

The Spirit of Second Reality in Modern Development

What strikes me most about Second Reality, three decades later, is how much of it still applies:

The part-based system anticipated modern microservices and component-based design: each part was independently testable, deployable, and replaceable. The dev/prod workflow anticipated a lot of what we now call developer experience, because the team understood that good tools let people do good work. The optimization those real-time effects demanded on limited hardware taught lessons that still apply to web performance, mobile development, and embedded systems.

The architecture also let people work in parallel with no source control at all, which teams with Git and CI/CD pipelines can still learn from. And none of it was only technical. The mix of music, visuals, and pacing added up to something you felt, not just something you admired.

From BBS to Browser: DosKit and Instant Access

The contrast between 1993 and 2025 is striking. What once required hours of downloading and specific hardware now runs instantly in any modern browser. That gap is what led me to build DosKit, a tool for making DOS software accessible straight from the browser.

DosKit uses WebAssembly to run a complete DOS environment in your browser. No installation. No configuration. No downloads. Just click:

Try Second Reality now: doskit.net/?app=secondreality

For complete technical details about DosKit’s architecture and implementation, see the DosKit project page.

The technical implementation combines several modern web technologies:

• js-dos: A DOS emulator compiled to WebAssembly
• URL-based configuration: Apps load via query parameters
• Instant initialization: Pre-configured DOS environment
• Cross-platform compatibility: Works on desktop, mobile, tablets

What took hours in 1993 now takes seconds. The BBS download that required dedication and patience is a single click today. The demo itself is unchanged: the same code, the same effects, the same music that amazed people 32 years ago.

This accessibility matters. Second Reality still works as a lesson in software engineering, graphics programming, and creative problem-solving. Making it easy to reach means new generations can run it, learn from it, and take something from it.

Lessons for Modern Developers

A few of those lessons hold up well past its era:

1. Constraints Drive Innovation

The 486 CPU, VGA graphics, and 450KB memory limit forced creative solutions. We usually have nearly unlimited resources now, but self-imposed constraints can still lead to better design. Try building a feature in half the memory budget. Optimize for slower devices. Limits like that expose waste and push you toward simpler solutions.

2. Architecture Enables Collaboration

The modular part system let developers work independently. Modern microservices and component architectures serve the same purpose. Good architecture isn’t about following patterns. It’s about letting your team work effectively.

3. Developer Experience Compounds

The smooth dev/prod workflow saved the team a lot of time. Time you put into tooling, build systems, and developer experience keeps paying off over a project’s life. The best teams treat developer experience as a first-class concern.

4. Performance Is a Feature

Second Reality’s optimization wasn’t optional. It was the whole point. Modern web applications often neglect performance and assume fast networks and fast devices. But performance is user experience. Every millisecond matters.

5. Technical Excellence Serves Artistic Vision

Second Reality wasn’t only impressive to engineers. It was beautiful, and it stuck with you. The technical work served the art. Modern software should aim for the same union of solid engineering and user experience.

The Enduring Legacy

Thirty-two years later, Second Reality still holds up. Not because the graphics impress (though they’re charming), but because the engineering, the problem-solving, and the artistic vision are still worth studying.

The demo represents a moment when a small team in Finland showed the world what was possible with dedication, skill, and creativity. They didn’t have the best tools, the fastest hardware, or unlimited resources. They had constraints, talent, and vision.

That combination produced something that outlasted the hardware it ran on, the BBS networks that distributed it, and the era that created it. Second Reality endures because the work was good: technical, artistic, and collaborative.

And now, with tools like DosKit, all of that is more accessible than ever. The hours-long BBS download is a single click. The specific hardware requirements are gone; it just runs in a browser. The treasure you once had to work for is free to anyone curious enough to click a link.

Experience Second Reality today: doskit.net/?app=secondreality

The demo that changed my life as a kid is now just a URL away. That would have looked like science fiction in 1993. Yet here we are, 32 years on, with the past instantly available in the present.

Happy anniversary, Second Reality. Thank you for showing us what’s possible.

---

Further Exploration:

• DosKit Project Page - Complete technical documentation and architecture details
• DosKit on GitHub - The open-source tool enabling instant DOS software access
• Try DosKit Live - Experience the platform with curated DOS software
• Second Reality Source Code - Released for the 20th anniversary
• Fabien Sanglard’s Code Review - Comprehensive technical analysis
• Second Reality on Pouët - Demoscene database entry with community comments

Have your own Second Reality memories? I’d love to hear them. The demoscene community thrives on shared experiences and collective nostalgia for an era when computing felt like magic.