Maximum playable reality from minimum executable law.
RGPUF is a research framework for extracting, formalizing, and extending the hidden physics, compression strategies, control systems, and ontology patterns embedded in early video game engines.
RGPUF — the Retro Game Physics Unified Framework — is a multi-decade synthesis of game-physics principles extracted from early interactive systems, arcade machines, wireframe engines, filled-polygon worlds, flight simulators, procedural galaxies, and resource-constrained 3D simulations.
The central claim is simple but powerful:
Retro physics = maximum playable reality from minimum executable law.
Early game engines were not merely crude approximations. They were compressed executable models of reality. Under extreme hardware limits, they discovered reusable patterns for:
- ballistic motion
- orbital mechanics
- collision and reflection
- resource thermodynamics
- procedural world generation
- wireframe and polygonal projection
- discrete-to-continuous physics transitions
- line-of-sight algorithms
- pressure, heat, fuel, and energy systems
- player cognition as part of the simulation loop
RGPUF treats these systems as a unified design lineage: physics as gameplay, gameplay as compressed law, and compression as ontology.
The main framework documents are stored in /docs/:
| File | Purpose |
|---|---|
docs/Unified_Framework_RGPUF.pdf |
Canonical compiled framework document |
docs/Unified_Framework_RGPUF.tex |
Editable LaTeX source for the framework |
The PDF is the fastest way to read the framework. The .tex file is the source of truth for revision, expansion, formalization, and future papers.
RGPUF studies how old systems produced convincing worlds by compressing physics into tiny executable rule sets.
perceived world fidelity
+ player agency
+ mathematical stability
-------------------------------- = retro-physics efficiency
compute + memory + display limits
A retro engine succeeds when it creates a world that feels larger, deeper, and more lawful than the machine should be able to support.
That is the real breakthrough of retro physics.
The current unified framework covers three major historical layers:
The first playable physics primitives emerged before the commercial game industry existed:
- Tennis for Two — parabolic trajectory, gravity, bounce, wind
- Spacewar! — central gravity, inertia, thrust, orbital maneuvering
- Lunar Lander — optimal control, fuel depletion, safe descent
- Hamurabi — stochastic resource simulation
- Missile — guided projectile control
- Marienbad — Nim-sum as a conserved discrete invariant
This era establishes the base vocabulary: gravity, momentum, stochastic forcing, resource conservation, and state transitions.
The 1970s transformed equations into reflexive, public, embodied play:
- Pong — elastic collision and paddle response
- Asteroids — inertia as skill
- Lunar Lander — arcade optimal control
- Stunt Cycle — projectile jump physics and crash thresholds
- Gun Fight — microprocessor ballistics
- Jet Rocket — analog first-person 3D projection
- Kollidoskop! — particle collision as educational simulation
This era makes physics tactile: motion, timing, collision, crash, acceleration, and predictive aiming.
The 1980s pushed home computers into full simulated worlds:
- 3-Demon — first-person wireframe grid cognition
- Elite — procedural galaxy, hybrid Newtonian flight, energy economy
- Microsoft Flight Simulator — real-time aerodynamic modeling
- Starglider — wireframe combat, sampled speech, energy harvesting
- Driller — filled-polygon Freescape environments and pressure logic
- The Colony — cell-compressed 3D, teleport topology, toroidal navigation
This era reveals the full RGPUF stack: projection, compression, topology, procedural determinism, modular physics, and cognitive world modeling.
RGPUF organizes retro game physics into eight abstraction layers:
| Layer | Domain | Description | Example |
|---|---|---|---|
| L0 | Discrete Approximation | Grid cells, integer steps, tile logic | 3-Demon |
| L1 | Continuous Newtonian Motion | Force integration, thrust, drag, inertia | Spacewar!, Elite |
| L2 | Resource Thermodynamics | Heat, fuel, pressure, grain, energy | Lunar Lander, Driller |
| L3 | Information Compression | Seeds, lookup tables, wireframes, cell maps | Elite, The Colony |
| L4 | Non-Hermitian Knowledge | Deterministic/stochastic dual systems | pursuit AI, mystery bonuses |
| L5 | Semantic Field Dynamics | Meaning, curvature, player cognition | MHAF layer |
| L6 | Fractal Renormalization | Scale transitions and abstraction flow | MOGOPS layer |
| L7 | Meta-Causality | Self-reference, recursive play, engine-as-law | unified RGPUF layer |
The important move is not to pretend every old game was secretly modern physics. The move is to identify where small executable mechanics behave like compressed versions of broader mathematical structures.
RGPUF uses several master equations to unify retro mechanics across decades.
This captures the core line from Spacewar! to Asteroids, Lunar Lander, Elite, and later vehicle simulations.
Where R may represent fuel, grain, pressure, heat, energy, shield charge, or mystery yield.
This links Gun Fight, Spacewar!, Asteroids, Elite, flight simulators, missile guidance, and modern lead-prediction systems.
A compact way to score how much world-feel a system extracts from constrained hardware.
RGPUF is useful because retro engines expose design truths that modern systems often bury under brute force.
Modern engines can simulate more, but retro engines often reveal why the simulation works at all.
The framework is useful for:
- retro game physics analysis
- emulator-preservation research
- procedural generation design
- minimal simulation engines
- AI-world modeling
- symbolic physics experiments
- compression-first game architecture
- ontology-driven engine design
- educational physics tools
- reverse-engineering historical game feel
The long-term goal is to convert the RGPUF framework into a practical retro physics ontology engine: a simulation system that can classify, reproduce, mutate, and recombine early game-physics primitives into new engines.
Recommended layout:
.
├── README.md
├── docs/
│ ├── Unified_Framework_RGPUF.pdf
│ └── Unified_Framework_RGPUF.tex
├── examples/
│ └── README.md
├── src/
│ └── rgpuf/
├── tests/
└── LICENSE.md
Current required documentation lives in docs/. Future implementation work can build around the proposed src/, examples/, and tests/ directories.
- Maintain the PDF and LaTeX framework in
/docs/ - Add glossary of RGPUF/MOGOPS/MHAF terms
- Add game-index metadata for every analyzed title
- Add equation registry with stable IDs
Implement reusable primitives:
- parabolic trajectory
- central gravity
- elastic/inelastic collision
- fuel depletion
- pressure diffusion
- heat accumulation
- discrete grid movement
- 256-step rotation
- line-of-sight via Bresenham
- seed-based procedural generation
Build tools to infer old-game physics parameters from footage, telemetry, or reconstructed traces:
gameplay trace → candidate equations → parameter fit → simulator twin
Target outputs:
- inferred gravity
- drag coefficient
- collision restitution
- AI decision latency
- projectile speed
- fuel or heat depletion rates
- frame-rate dependent artifacts
Create a modular simulation engine where mechanics can be composed as ontology layers:
L0 grid
+ L1 force integration
+ L2 resource thermodynamics
+ L3 compression/projection
= playable retro physics system
RGPUF favors:
- falsifiable claims
- compact equations
- implementation-ready metrics
- historical grounding
- cross-era comparison
- reproducible simulations
- clear separation between confirmed mechanics and speculative extrapolation
A good RGPUF claim should be able to answer:
What system does this describe?
What variable can be measured?
What equation or algorithm models it?
What would falsify it?
What modern system does it help explain?
From the repository root:
cd docs
pdflatex Unified_Framework_RGPUF.tex
pdflatex Unified_Framework_RGPUF.texRun twice so the table of contents and internal references resolve correctly.
For a cleaner build directory:
mkdir -p build
pdflatex -output-directory=build docs/Unified_Framework_RGPUF.tex
pdflatex -output-directory=build docs/Unified_Framework_RGPUF.texWhen citing this framework, use:
RGPUF Research Collective. Retro Game Physics Unified Framework (RGPUF), v1.0.
Suggested BibTeX:
@misc{rgpuf2026,
title = {Retro Game Physics Unified Framework (RGPUF)},
author = {{RGPUF Research Collective}},
year = {2026},
version = {1.0},
note = {Unified framework for retro game physics, MOGOPS, and MHAF}
}Add a LICENSE.md file before public release. For research and open collaboration, recommended licenses are:
- MIT for code
- CC BY 4.0 for written framework material
- Apache 2.0 if patent protection language is desired for future tooling
Current state: research framework and documentation core.
Next target: convert the framework into a testable primitive registry and simulator scaffold.
retro games → extracted mechanics → equation registry → falsifiable simulator → ontology engine
The old machines were not weak.
They were strict.
Their limits forced game engines to compress reality into its most playable mathematical bones. RGPUF exists to recover those bones, name them, test them, and use them to build new simulation systems where every byte has physics, every rule has meaning, and every constraint becomes a world.