Proof Engine

A mathematical rendering engine for Rust. Every visual is the output of a real equation.

What is this?

Proof Engine renders mathematics, not graphics. A Lorenz attractor looks like a Lorenz attractor because particles follow the actual differential equations in real time. Entities are held together by force fields and dissolve into strange attractors when they die. Audio is synthesized from music theory, not audio files.

This is not a traditional game engine. It is a system where the math IS the visual.

Proof Editor

A visual staging environment for building scenes, placing force fields, and tweaking every parameter in real time. Built with egui on top of the engine viewport.

Download the editor: Releases page

Editor features

• Place glyphs, force fields, and entities by clicking in the viewport
• 10 force field types: Gravity, Vortex, Lorenz, Rossler, Chen, Thomas, Flow, Shockwave, and more
• Live property inspector with position, color, emission, glow sliders
• Hierarchy panel with search, filter, and collapsible tree structure
• Post-processing panel: bloom, chromatic aberration, film grain with preset buttons (Cinematic, Neon, Retro, Clean)
• Asset browser with prefab spawning (Lorenz Cluster, Vortex Ring, etc.)
• Console with command input and color-coded log
• Full undo/redo across all operations
• Save/load scenes to JSON
• Copy/paste, duplicate, box select, multi-select

Getting started

Run the editor

Download proof-editor.exe from the Releases page and double-click it.

Or build from source:

git clone https://github.com/Mattbusel/proof-engine.git
cd proof-engine/editor
cargo run --release

Run the demos

cd proof-engine
cargo run --release --example galaxy
cargo run --release --example supernova
cargo run --release --example math_rain
cargo run --release --example heartbeat

Use as a library

[dependencies]
proof-engine = { git = "https://github.com/Mattbusel/proof-engine.git" }

use proof_engine::prelude::*;

fn main() {
    let mut engine = ProofEngine::new(EngineConfig::default());

    engine.spawn_glyph(Glyph {
        character: '@',
        position: Vec3::ZERO,
        color: Vec4::new(0.0, 1.0, 0.8, 1.0),
        emission: 1.2,
        life_function: Some(MathFunction::Breathing { rate: 0.4, depth: 0.15 }),
        ..Default::default()
    });

    engine.add_field(ForceField::StrangeAttractor {
        attractor_type: AttractorType::Lorenz,
        scale: 0.2,
        strength: 0.4,
        center: Vec3::ZERO,
    });

    engine.run(|_engine, _dt| {});
}

Editor controls

Engine capabilities

Rendering: OpenGL 3.3, glyph instancing, bloom, chromatic aberration, film grain, vignette, scanlines, motion blur

Math functions: Lorenz, Rossler, Chen, Halvorsen, Aizawa, Thomas attractor integration. Sine, cosine, Perlin noise, logistic map, Collatz, golden spiral, Lissajous, Mandelbrot escape, spring-damper systems

Force fields: Gravity, vortex, electromagnetic, strange attractor, shockwave, tidal, flow, magnetic dipole. Composable with falloff (linear, inverse square, exponential, Gaussian)

Physics: 2D rigid body with SAT collision, soft body mass-spring, Eulerian fluid simulation, constraints and joints

Audio: 48kHz synthesis, ADSR envelopes, waveform oscillators, FM synthesis, music theory (scales, chords, progressions), spatial audio with stereo panning and room reverb

Entities: Amorphous glyph formations held together by force cohesion. HP-linked binding strength. Dissolve into attractors on death

Scripting: Custom bytecode VM with lexer, parser, compiler. Dynamic typing, closures, tables, metatables

Procedural generation: Tectonic plates, hydraulic/thermal erosion, climate simulation, biome classification, river networks, cave systems, settlement placement, civilization history, language generation, mythology, genetics

Ecology: Lotka-Volterra dynamics, food webs, migration, evolution, SIR disease models

Narrative: Story grammars, character motivation, dialogue generation, quest generation, drama management, NPC memory, procedural poetry

Architecture

460,000+ lines of Rust across the engine, editor, and game frontend.

License

MIT