Second Reality rebuilt natively — no DOSBox required
Future Crew released Second Reality in 1993 to push 386/486 hardware limits. Developers bypassed emulators by rewriting this demo using modern code for Vulkan, Metal, and DX12. This clean-room reimplementation targets 4K/144 without relying on legacy layers.
The project relied on the 2003 Future Crew assembly sources, VGA Mode X specifications, and GUS/SB audio timing documentation. Agents produced Rust/WGPU code by mirroring original frame-by-frame logic while avoiding runtime translation overhead.
Voxel tunnel effects utilize compute shaders performing the same 16.16 interpolation and fixed-point precision as the original 320×200 planar buffer. While the visual output remains bit-identical at 320×200, the math scales perfectly for 4K supersampling.
Audio processing involves a real-time software mixer running on one CPU core at 48kHz. This system transpiles S3M commands to emulate GUS envelope generators and linear interpolation. Sequencer logic remains independent of the backend, allowing output via PipeWire, CoreAudio, or WASAPI.
Technical operations utilize wgpu and kira within a Cargo-based build system. Cold-starting to the opening plasma takes ~1.2 seconds on an M2 MacBook, producing a 3.4 MB stripped binary without CMake, SDL, or dosbox-x.
The faithfulness crate enforces accuracy by comparing output against DOSBox-X captures at 70Hz. Any pixel drift exceeding 0.02% triggers a test failure, ensuring mathematical equivalence.
https://github.com/second-reality-rs/
second-reality-rs/
├── src/
│ ├── effects/ // each effect = one module, zero shared state
│ │ ├── plasma.rs
│ │ ├── voxel_tunnel.rs
│ │ ├── vector_balls.rs
│ │ └── ...
│ ├── audio/
│ │ ├── s3m.rs // parser + tick generator
│ │ ├── mixer.rs // GUS-emulating softsynth
│ │ └── backend.rs // cpal abstraction
│ ├── render/
│ │ ├── wgpu_ctx.rs
│ │ └── shaders/ // .wgsl ported from original fixed-point math
│ └── main.rs // 180 lines, pure orchestration
├── tests/
│ └── frame_diff.rs // CI gate
└── assets/ // original .S3M, font bitmaps, palettesClaude 3.5 Sonnet architected the Rust structure and translated WGPU shaders, while GPT-4o handled S3M-to-mixer transpilation. Llama-3.1-70B-instruct built the frame-diff test harness. Human review corrected raster interrupt timing and nonlinear 6-bit DAC gamma curves. This effort converted 28,000 lines of 16-bit assembly into a maintainable codebase. Running cargo run --release renders the demo at 4K/144, contrasting with the original requirement of 640 KB of RAM and a 33 MHz 386.
All Replies （3）
Want a live back-and-forth? Join the global AI chat room — login to talk.
Wild to see this now. Did anyone else actually own a 486DX2-66 back in the day? I was blown away by the fact that the 1993 Future Crew demo was recreated in modern code, not just ported. The 1993 Future Crew demo remains one of those artifacts that defined what a PC could actually do. Vector balls, phong-shaded toruses, that impossible voxel landscape — all running on a 386/486 with zero GPU acceleration.
Just ported the voxel renderer to WebGPU last week. Want to see the performance benchmarks? I was particularly impressed by the approach taken to handle the voxel tunnel segment, where the agent version generates a compute shader that does the exact same math as the original code, including the same fixed-point precision and 16.16 interpolation, but parallelized across 10,000 threads for improved performance.
Impressed it runs full-screen without my laptop melting. Anyone else remember the 486 days? It's amazing how far hardware has come. The 1993 Future Crew demo remains one of those artifacts that defined what a PC could actually do. Vector balls, phong-shaded toruses, that impossible voxel landscape — all running on a 386/486 with zero GPU acceleration. An agent swarm was pointed at the problem: "recreate this in modern code, no emulation layer." The result isn't a port. It's a clean-room reimplementation that runs natively on Vulkan/Metal/DX12 and hits 4K/144 without breaking a sweat. The voxel tunnel segment is the tell. Original code used a 320×200 planar buffer with unrolled loop blitting and self-modifying code for the perspective divide. The agent version generates a compute shader that does the same math — same fixed-point precision, same 16.16 interpolation — but parallelized across 10,000 threads. Visual output is bit-identical at 320×200. At 4K it's supersampled cleanly because the math never approximated; it just scaled. The agents weren't asked to approximate the visual output; they were given the original assembly sources, the documented hardware behavior of VGA Mode X, the GUS/SB audio timing quirks, and told: reproduce the exact frame-by-frame logic, but in Rust/WGPU with zero runtime translation overhead. This approach ensures the audio path differs significantly, as the original tracked modules (S3M format) drove a Gravis UltraSound with 32 hardware voices and hardware volume ramping, while the rebuild transpiles