Engine architecture
Explore the mechanisms behind Asterune's world state, script execution, physics, replication, and presentation.
Asterune separates authoritative world state from the devices that present it. The shared game core owns instances, Luau execution, animation, terrain, and physics. Client hosts synchronize that state into GPU, audio, and input systems. A dedicated server runs simulation and replication without creating those presentation devices.
A dedicated server runs the game core and replicates its state to clients. Each client runs the same game core, sends character reports to the server, and synchronizes its world into rendering, audio, and interface systems.
An engine frame therefore crosses several boundaries. Script coroutines resume at scheduled phases; physics consumes fixed substeps; replication compares retained state; presentation interpolates poses and reconstructs images. These systems share object identities and revisions while retaining their own clocks, caches, and histories.
World state and execution
Instance state and lifetime explains stable IDs over reusable storage, copy-on-write snapshots, revision tracking, hierarchy mutation, and delayed reclamation. These mechanisms let systems retain an earlier view without confusing a destroyed instance with a newly allocated object.
Script execution and scheduling follows script admission, coroutine suspension, phase queues, authority checks, and execution-group workers. Component storage and system queries explains typed columns, query membership caches, change readers, schema replacement, and the commit of parallel writes.
These chapters describe runtime mechanisms. The corresponding Luau operations and programming patterns remain in the scripting guides and generated API reference.
Simulation and multiplayer state
Physics stepping and spatial queries traces incremental body synchronization, assembly topology, constraint control, collision detection, contact delivery, and the spatial indexes used outside the solver. Character movement and navigation covers swept motion, support surfaces, gravity frames, and path search over collision snapshots. Terrain surfaces and chunk updates follows voxel changes through surface extraction, rendering jobs, and collision caches. Mesh topology and solid operations explains how editable polygons become render triangles, solid combinations, and independently retained collision shapes.
Transport and packet delivery explains connection establishment, protected records, delivery lanes, fragmentation, retransmission, and backpressure. State replication and streaming separates instance baselines, property changes, component updates, audience selection, and spatial motion interest. Prediction and reconciliation traces the movement inputs and retained states used to reconcile local and remote characters.
Image formation
Rendering architecture connects scene preparation to lighting, temporal reconstruction, lens processing, and display composition. Its technical chapters follow the resources and algorithms within those stages:
- Frame pipeline and resources
- Geometry, depth, and transparency
- Mesh simplification and impostors
- Material evaluation and shader variants
- Temporal anti-aliasing and reconstruction
- Anti-aliasing and render resolution
- Lighting and reflections
- Atmosphere, clouds, and volumetric light
- Water surfaces and optical depth
- Particle simulation and ribbons
- Lens effects and display processing
Animation, sound, and interfaces
Animation evaluation and blending explains pose sampling, per-joint mixing, graph transitions, blend spaces, and extracted root motion. Retargeting and procedural rigs follows pose conversion between rest frames and the constraints that modify the resulting rig.
Audio processing and mixing traces source preparation, per-voice processing, bus topology, spatial gain, and generated-sample queues. Interface layout and input routing explains layout dependencies, invalidation, clipping, and hit testing. Text shaping and glyph rendering separates Unicode text layout from glyph rasterization, atlas residency, and draw batching.
XR frames and tracking spaces connects the runtime's predicted frame clock to eye images, tracked poses, world transforms, and room-scale collision. Its lifecycle differs from ordinary window presentation even when both paths use the same world renderer.