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 now includes a full interactive runtime — you can walk through scenes in first-person with physics, spatial audio, and animated objects. Property animations are defined in TOML, skeletal animations are imported from glTF with GPU vertex skinning, 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. FlintKart, a low-poly kart racer with spline-based tracks and colorful terrain, is an early demonstration of this game project architecture.

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 19-crate Rust workspace:

• flint-core — Fundamental types (EntityId, Transform, Vec3, Color, ContentHash)
• 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-import — glTF/GLB importer for meshes, materials, textures, skeletons, and animations
• flint-render — wgpu-based PBR renderer with shadow mapping, billboard sprites, and GPU skinning
• 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, ambient loops, and event-driven triggers
• flint-animation — Property tween keyframes and skeletal animation with GPU vertex skinning
• flint-script — Rhai scripting engine with entity/input/audio/animation APIs and hot-reload
• flint-particles — GPU-instanced particle system with per-emitter pooling and emission shapes
• flint-asset-gen — AI asset generation with pluggable providers (Flux, Meshy, ElevenLabs)
• flint-player — Standalone game player with first-person controls and script-driven HUD
• 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
• Rapier 3D Physics — Kinematic character controller with gravity, jumping, and collision against static world geometry
• Spatial Audio — Kira-powered 3D positioned sounds with distance attenuation, ambient loops, and event-driven triggers
• Animation System — Two-tier animation: TOML-defined property tweens (doors, platforms) and skeletal animation with GPU vertex skinning from glTF
• Cook-Torrance PBR — Physically-based rendering with cascaded shadow maps, tone mapping, and skinned mesh pipeline
• Query Language — Filter and inspect entities with expressive syntax: entities where archetype == 'door'
• Hot-Reload Viewer — Scene changes on disk are reflected in real-time
• Headless Rendering — Render scenes to PNG from the command line for CI and automation
• Debug Visualization — Runtime-toggleable wireframe, normals, depth, UV, and metallic/roughness views
• Content-Addressed Assets — Immutable, deduplicated storage with SHA-256 hashing
• Rhai Scripting — Entity behaviors, NPC AI, combat systems, and HUD overlays defined entirely in script with hot-reload
• GPU Particle System — Instanced rendering with per-emitter pooling, alpha/additive blending, and configurable emission shapes
• 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 and GPU skinning pipeline
• Physics: Rapier 3D with kinematic character controller
• Audio: Kira 0.11 with spatial 3D positioning
• 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)