▶ Play the demo — self-contained HTML, no install required. Press spacebar to start. X to toggle classic ↔ remastered.

A web-based recreation of Second Reality (Future Crew, Assembly'93) built with WebGL2 shaders and Web Audio, paired with a timeline editor for sequencing and scrubbing through the demo in real time.

https://github.com/mtuomi/SecondReality — original source code

Second Reality is a legendary DOS demo by Future Crew that won the Assembly 1993 demo competition. It pushed 486-era PCs to their limits with hand-optimized x86 assembly, producing effects like voxel landscapes, plasma fields, 3D polygon flyovers, and glenz vectors — all perfectly synchronized to Skaven's tracker music.

This project rebuilds those effects using modern web technologies while staying faithful to the original 320×256 PAL aesthetic.

A bit of personal context — feel free to skip to the next section.

I was a young teenager when this demo came out. It blew my mind then, and it still boggles my mind today that a group of teenagers pulled this off in 1992-93. Sure, a lot of these effects haven't necessarily aged well or even look that impressive, but you have to put it into context. Very little available online resources. Michael Abrash's Graphics Programming Black Book didn't come out until 1997. A combination of creativity, ingenuity, genius, experimentation, trial and error and luck brought us this and many many other amazing demos.

I'll be honest, I probably peaked at Second Reality. I wanted to understand it, pull it apart, tinker with it. Graphics programming called to me in a way nothing else did. But life happened. I became a software engineer who occasionally dabbled with a few toy projects. Graphics was always on the sidelines, never quite in reach. One of many ideas filed under "I'll never have the time to do it or learn how to do it, but I'd love to one day..."

That is, until 2026. I'd spent years scoffing, denying, being frustrated, scared, and who knows what else, about... yes, LLMs. Around mid-2025 something fundamental shifted. I began relying on them more and more at work, at first in small projects that wouldn't justify the ROI. Results were good, then got better. By January 2026 I decided to go all-in. I've been writing code professionally since 2003 and tinkering with it since I was 14. As of March 2026 I have barely written a line of code myself. The ability to work on ambitious and complex ideas at the speed of thought is just astonishing to me.

Here's the thing: while I absolutely love writing code, my true passion has always been building systems. Most code I write and review isn't novel — I've seen it before, shaped slightly differently, wired differently, but it's all familiar. The real complexity lives in the architecture, the emerging concepts and sub-systems and how they all interconnect. Code has to be written for systems to exist, but that takes time, patience, and usually many build cycles. I don't want to know how much of my life has been spent waiting for builds and CI jobs to finish — never getting that time back.

LLMs like Claude fundamentally changed this for people like me. The physical constraints that lead to slow cycles still exist, but you can now parallelise across meaningful complex projects, focusing your attention on the systems you want to build rather than the boilerplate that connects them.

So this project. I didn't just sit down one day, fire up Claude and say "remaster Second Reality, let me know when you're done". What you see here is code 100% LLM-written and 100% supervised and directed by me. It's a joint effort where I drive the vision and architecture while Claude takes care of the maths and shader code I could never have gotten to on my own. At the same time, I'm turning this into a learning repository — creating per-effect guides for people like me, who wished they had them when they were just a kid.

This project is intentionally learning-focused and design-centric:

• Every effect is reverse-engineered from the original x86 assembly, understood deeply, and documented in a dedicated design doc before implementation begins.
• Design documents in docs/effects/ capture the how and why — algorithms, data layouts, projection maths, palette structures — not just the what.
• Remastered variants are designed on paper first (docs/effects/*-remastered.md) with architecture diagrams, shader breakdowns, and parameter tables before a line of GPU code is written.
• A growing collection of learning guides uses the effects themselves as teaching material, unpacking real-time graphics techniques from first principles for anyone who wants to understand them.

The goal is not just to recreate Second Reality, but to make the techniques behind it accessible to anyone curious about graphics programming.

The project has two entry points:

• Player (src/player/) — a standalone vanilla JS runtime that plays the demo fullscreen, synced to the original S3M soundtrack via Web Audio.
• Editor (src/editor/) — a React + Vite creative tool with a video-editor-style timeline for sequencing effects, authoring beat maps, and scrubbing through the demo.

Both share a common core (src/core/) that handles the orchestrator, clock, beat map, MOD player, and WebGL helpers.

graph TD
    %% ── Assets ──
    PJ[("project.json<br/>25 clips · transitions · beat map")]
    S3M[("S3M Soundtrack<br/>MUSIC0 + MUSIC1")]
    TEX[("Effect Assets<br/>Textures · Sprites · Binary data")]

    %% ── Entry Points ──
    subgraph Entry["Entry Points"]
        Editor["<b>Editor</b><br/>React 18 · Vite · Tailwind · Zustand<br/>Timeline · Preview · Scrubbing"]
        Player["<b>Player</b><br/>Vanilla JS · No build step<br/>Fullscreen 320×256"]
    end

    %% ── Core Runtime ──
    subgraph Core["src/core/ — Shared Runtime (vanilla ES modules · zero dependencies)"]
        Proj["<b>Project Loader</b><br/>Load & validate project.json<br/>Resolve clips & transitions"]

        subgraph Audio["Audio Pipeline"]
            MSync["<b>Music Sync</b><br/>80 named sync points<br/>3 playback regions<br/>time ↔ music position"]
            ModPlay["<b>Mod Player</b><br/>Dual S3M engine<br/>Sample-counted Δt<br/>Music switching"]
            AC["<b>AudioContext</b><br/>Web Audio API"]
        end

        Clock["<b>Master Clock</b><br/>AudioContext.currentTime<br/>Play · Pause · Seek"]
        BeatMap["<b>Beat Map</b><br/>Beat/bar position (0.0–1.0)<br/>Nearest-beat snapping"]
        Orch["<b>Orchestrator</b><br/>rAF tick loop<br/>Clip scheduling<br/>Effect pre-warming"]
        Trans["<b>Transitions</b><br/>GLSL post-process overlays<br/>Fade · Flash · CRT · Checkerboard"]
        WGL["<b>WebGL Helpers</b><br/>createShader · createProgram<br/>Fullscreen quad VAO"]
    end

    %% ── Effects Layer ──
    subgraph FX["src/effects/ — init() · render(gl, t, beat, params) · destroy()"]
        Reg["<b>Effect Registry</b><br/>registerEffect() · getEffect(name, variant)"]
        Classic["<b>25 Classic Variants</b><br/>CPU software rasterize<br/>→ texSubImage2D<br/>320×256 faithful"]
        Remastered["<b>22 Remastered Variants</b><br/>Full GLSL pipeline<br/>4K · Bloom · PBR · Raymarching"]
        Bonus["<b>8 Bonus Effects</b><br/>Starfield · Fire · Tunnel<br/>Copper Bars · Grid · Wireframe"]
    end

    %% ── Output ──
    Canvas["<b>WebGL2 Canvas</b><br/>Final composited output"]
    Export["<b>tools/export.js</b><br/>→ Single self-contained HTML"]

    %% ── Asset loading ──
    PJ --> Proj
    S3M --> ModPlay
    TEX --> FX

    %% ── Audio chain ──
    MSync --> ModPlay
    ModPlay --> AC
    AC --> Clock

    %% ── Core data flow ──
    Proj --> Orch
    Clock --> Orch
    BeatMap --> Orch

    %% ── Entry points drive the orchestrator ──
    Editor --> Orch
    Player --> Orch

    %% ── Effect resolution ──
    Orch --> Reg
    Reg --> Classic
    Reg --> Remastered
    Reg --> Bonus

    %% ── Render pipeline ──
    Classic --> WGL
    Remastered --> WGL
    Bonus --> WGL
    Orch --> Trans
    Trans --> WGL
    WGL --> Canvas

    %% ── Distribution ──
    Player -.-> Export
    Core -.-> Export
    FX -.-> Export

Each visual effect is a self-contained ES module with a three-method interface (init, render, destroy). The orchestrator pre-warms effects before their clip starts, ensuring zero-hitch transitions. Effects come in two variants:

• Classic — faithful 1:1 reproduction of the original algorithm at 320×256
• Remastered — optional enhanced version with modern techniques (4K, better lighting/shading)

No frameworks or bundlers required for the player — vanilla JS and raw WebGL.

All 25 parts of the original demo are implemented as classic variants:

Starfield, Copper Bars, Fire, Wireframe 3D, Vector Balls, Bouncing Bitmap, Grid, Tunnel

#	Effect	Classic	Remastered
1	Scrolling landscape credits (ALKU)
2	3D polygon ships flyover (U2A)
3	Pre-rendered explosion (PAM)
4	Title card (BEGLOGO)
5	Checkerboard fall (GLENZ_TRANSITION)
6	Translucent rotating polyhedra (GLENZ_3D)
7	Dot tunnel (TUNNELI)
8	Circle interference (TECHNO_CIRCLES)
9	Bars transition (TECHNO_BARS_TRANSITION)
10	Rotating bars (TECHNO_BARS)
11	Troll picture (TECHNO_TROLL)
12	Mountain scroller (FOREST)
13	Lens slide-in (LENS_TRANSITION)
14	Bouncing crystal ball (LENS)
15	Rotozoom (LENS_ROTO)
16	Plasma waves (PLZ_PLASMA)
17	Plasma cube (PLZ_CUBE)
18	Mini vector balls (DOTS)
19	Mirror ball scroller (WATER)
20	3D sinusfield (COMAN)
21	Jelly logo (JPLOGO)
22	3D city flyover (U2E)
23	End picture (ENDLOGO)
24	Scrolling credits (CREDITS)
25	Greetings scroll (ENDSCRL)

The docs/learning/ directory contains deep-dive tutorials that use effects from this project to teach real-time graphics programming. Each guide is self-contained with inline code snippets — readable on GitHub without cloning the repo. Every guide follows the same structure: an overview, numbered technical chapters building layer by layer, and a final learning-path chapter with hands-on exercises.

Detailed technical design docs live in docs/effects/. Each effect has a classic doc and optionally a remastered doc:

Additional docs:

Player — open src/player/index.html in a browser (serve over HTTP for ES module support).

Editor:

cd src/editor
npm install
npm run dev

src/
  core/           Shared runtime (orchestrator, clock, beatmap, modplayer, webgl)
  effects/        One subfolder per effect (classic + optional remastered variant)
  editor/         React + Vite editor UI
  player/         Standalone vanilla JS player
assets/
  project.json    Demo timeline definition (clips, transitions, beat map)
  MUSIC0.S3M      Original Skaven soundtrack (part 1)
  MUSIC1.S3M      Original Skaven soundtrack (part 2)
  effects/        Per-effect textures and sprite sheets
lib/
  webaudio-mod-player/   Vendored S3M playback engine (MIT)
tools/            Asset extraction and project generation scripts
docs/
  effects/        Per-effect design documents (classic + remastered)
  learning/       Learning guides and tutorials
  patterns/       Reusable engineering patterns
reference/        Code from the JS port used as implementation reference

• Original demo: Future Crew (1993) — Psi, Trug, Wildfire, Gore, Marvel, Skaven
• Music: Purple Motion (Jonne Valtonen) & Skaven (Peter Hajba) — S3M tracker modules
• JS reference port: covalichou/second-reality-js
• Code review: Fabien Sanglard's Second Reality series

This is a non-commercial fan recreation for educational and preservation purposes. The original Second Reality demo and its assets are the property of Future Crew / Futuremark.