Flint

About

Flint is a 3D game engine that inverts the traditional paradigm. Instead of building a visual editor with programmatic access bolted on as an afterthought, Flint makes the CLI and plain-text files the primary interface. Every operation — from spawning entities to querying scene state — is a composable shell command. Visual tools like the built-in viewer exist solely to validate results, not to create them.

The engine is designed from the ground up for a world where AI agents are first-class collaborators in game development.

Flint includes a full interactive runtime — you can walk through scenes in first-person with physics, spatial audio, and animated characters. Property animations are defined in TOML, skeletal animations are imported from glTF with GPU vertex skinning and crossfade blending, and the Rapier physics engine handles collisions and movement. A Rhai scripting layer lets you define entity behaviors, HUD overlays, and game logic entirely in script — no engine recompilation needed.

Games built with Flint include the engine as a git subtree and layer their own schemas, scripts, and assets on top. Float — a contemplative first-person experience on an endless stylized ocean — is the engine’s most demanding test case and the origin of most of its recent rendering work: the Gerstner wave pipeline, the procedural sky, weather, and the render-mode system all exist because a game needed them. Flint Kart, a low-poly kart racer with spline-based tracks, was the second demonstration of the same subtree architecture — and the family has kept growing: Trike (stunt racing), Starchild (rhythm), FlintLeap (3D platforming), Doom FPS (an all-Rhai shooter), Junior (vector card games), and Keep It Warm (2D mobile) all carry the engine the same way, and each has pushed a different subsystem forward.

Design Principles

• CLI-First — Every operation expressible as a composable command; no GUI-only features
• Introspectable — Query any aspect of engine state as structured data
• Deterministic — Same inputs always produce identical outputs
• Text-Based — Scenes and schemas in human-readable, diffable TOML
• Constraint-Driven — Declarative rules define valid scenes with auto-fix

Architecture

Flint is structured as a 24-crate Rust workspace:

• flint-core — Fundamental types (EntityId, Transform, Vec3, Color, ContentHash) and the Gerstner ocean spectrum
• flint-schema — Dynamic component and archetype definitions via TOML
• flint-ecs — hecs wrapper with stable entity IDs and parent-child hierarchy
• flint-scene — TOML scene serialization as the single source of truth
• flint-query — PEG-based query language for filtering entities
• flint-constraint — Validation engine with auto-fix capabilities
• flint-asset — Content-addressed pipeline with SHA-256 hashing
• flint-asset-gen — AI asset generation with pluggable providers (Flux, Meshy, ElevenLabs)
• flint-import — glTF/GLB importer for meshes, materials, textures, skeletons, and animations
• flint-render — wgpu-based PBR renderer with shadow mapping, GPU skinning, and the ocean, sky and post-processing pipelines
• flint-viewer — Hot-reload viewer with orbit camera and egui inspector
• flint-runtime — Game loop with fixed-timestep accumulator, config-driven input, and event bus
• flint-physics — Rapier 3D integration with kinematic character controller
• flint-audio — Kira spatial audio with 3D positioning and a music/sfx mixer bus split
• flint-animation — Property tweens, skeletal animation, crossfade blending, and additive layers
• flint-script — Rhai scripting engine with entity/input/audio/animation/ocean APIs and hot-reload
• flint-particles — GPU-instanced particle system with velocity-aligned billboard stretching
• flint-terrain — Heightmap terrain with splat-map blending and GPU grass
• flint-debug-ui — Component-driven F3 tuning panels with scene write-back
• flint-procgen / flint-procgen-ai — Procedural mesh and texture generation, with AI-assisted spec authoring
• flint-player — Standalone game player with first-person controls and script-driven HUD
• flint-android — Android entry point (NativeActivity, APK asset extraction)
• flint-cli — Entry point tying everything together

Features

• Interactive Runtime — Walk through your scenes in first-person with WASD/mouse controls, physics, and spatial audio
• Gerstner Ocean — An endless sea from a JONSWAP wind spectrum with real dispersion, Jacobian-derived foam, contact splash around hulls, and rain impact rings. The wave math lives in one place on the CPU and the GPU only sums what it is handed, so a script asking for the surface height gets the surface you can see — which is what makes buoyancy possible at all
• Procedural Sky — Gradient, sun disc slaved to the scene light, hashed starfield, and FBM clouds, all driven from a single component. Time of day belongs to the game, not the engine
• Render Modes — Whole-screen stylizations branching after tonemapping: falling code, a blood sea, a drunken lean, a Tron wire-world, and a true underwater view masked by a real waterline. Scripts drive them transiently, so a crashed script heals the world instead of stranding it
• Cook-Torrance PBR — Physically-based rendering with cascaded shadow maps, tone mapping, and a skinned mesh pipeline
• Animation System — TOML property tweens, glTF skeletal animation with GPU skinning, crossfade blending, and additive layers that survive those crossfades
• Rapier 3D Physics — Kinematic character controller with gravity, jumping, and collision against static world geometry
• Spatial Audio — Kira-powered 3D positioned sound over a music/sfx bus split, with a master low-pass filter scripts can drive
• GPU Particles — Instanced rendering with pooling, blend modes, emission shapes, and velocity-aligned stretching for rain and sparks
• Debug Panels — F3 opens live tuning panels for whichever systems a scene actually uses, and commits your tuning back into the scene TOML
• Query Language — Filter and inspect entities with expressive syntax: entities where archetype == 'door'
• Headless Rendering — Render scenes to PNG from the command line for CI and automation, including stylized modes
• Rhai Scripting — Entity behaviors, NPC AI, world events, and HUD overlays defined entirely in script with hot-reload
• Content-Addressed Assets — Immutable, deduplicated storage with SHA-256 hashing
• Extensible Input — Config-driven action bindings for keyboard, mouse, and gamepad with runtime rebinding
• AI Asset Generation — Pluggable providers (Flux textures, Meshy 3D, ElevenLabs audio) with style guides and batch resolution
• Game Project Architecture — Games include the engine as a git subtree, layering custom schemas, scripts, and assets

Technical Details

• Language: Rust (Edition 2021)
• Rendering: wgpu 23 with Cook-Torrance BRDF, HDR post-processing, and GPU skinning
• Physics: Rapier 3D with kinematic character controller
• Audio: Kira 0.11 with spatial 3D positioning and mixer buses
• ECS: hecs with stable 64-bit entity IDs
• Windowing: winit 0.30
• GUI: egui 0.30
• Formats: TOML (scenes/schemas/animation clips), glTF (3D assets/skeletons/animations), WGSL (shaders)