Features

Everything Unity scripts expect, on a Rust core.

Tassix is a general-purpose 2D and 3D game engine in Rust. It runs the C# you wrote for Unity unmodified, plays Unity projects from their files, and has an editor that AI agents drive through the same commands people do. Everything it does is checked against recordings made in real Unity.

Your Unity scripts, unmodified

MonoBehaviour scripts compile against Tassix's own UnityEngine and behave as they do in Unity: the lifecycle and execution order, coroutines, fake null, Invoke, physics callbacks, SceneManager, Resources, PlayerPrefs and JsonUtility. The API is reimplemented clean-room from public documentation and observed behavior.

Scripts run on .NET 10, at Unity's C# 9 / .NET Standard 2.1 level
Callbacks come from generated tables, not reflection: NativeAOT-ready
Hot reload keeps field values and references

Unity projects, from their files

Point the player at a Unity project and it plays its first build scene: .unity scenes, prefabs, ScriptableObjects, materials, .meta GUIDs, assembly definitions and plugin DLLs, read from Unity's text format. The editor opens the same scenes and saves them back as Unity writes them.

FBX and glTF models, textures and sprites with Unity's import settings
Animator controllers, animation clips, Input System actions
An open-source project corpus ranks what real projects still miss

An editor agents can use

The editor is a headless core that the GUI and an MCP server both drive. Every edit is a typed command with undo, so an agent's edits land in the same history as yours, as one reviewable step you can accept or revert.

scene_query, scene_edit, play_step, view_screenshot and more over MCP
Deterministic play mode: step 300 frames holding D, then check the result
The GUI shows where an agent is working, live

Speed first

Performance decides every design question that Unity compatibility leaves open. Transforms live in dense arrays updated in parallel; managed code reads them without crossing into native code; the simulation allocates nothing per frame.

GetComponent in about a nanosecond, 10,000 scripted objects in under half a millisecond a frame
GPU culling, indirect draws, bindless materials and mesh LODs
Frame-time budgets gate CI, measured side by side with Unity

Rendering on wgpu

A render graph on wgpu with reverse-Z, sorted and instanced draws, and the simulation running a frame ahead of rendering. Materials match URP's Lit look: PBR maps, shadows, HDR, reflection probes, skyboxes and URP's post-processing.

2D: sprites, URP 2D lights, soft shadows and normal maps, tilemaps
Particles with collision, noise and trails; line and trail renderers
Projects' own ShaderLab vertex and fragment shaders compile

Gameplay systems

The systems games are built from, with Unity's behavior: 3D and 2D physics with joints and CharacterController, NavMesh agents with off-mesh links and avoidance, the Animator with layers and root motion, uGUI and TextMeshPro, audio, and the Input System with gamepads.

Unity.Mathematics, Unity.Collections and the C# Job System on the engine's job scheduler
IMGUI and UI Toolkit
Rumble and DualSense support

Proven against Unity

A conformance suite runs the same C# in Unity and in Tassix and compares what each observes, event by event: callback order, values, error messages. CI runs it on the JIT runtime, with Unity scenes, and on a NativeAOT build.

A public compatibility matrix, area by area
API coverage counted assembly by assembly against Unity's
Binding checks for precompiled plugins

Ship a game folder

cargo xtask package makes a folder to ship: the player named after the game, its files with their assets cooked, and the .NET runtime it needs, so players install nothing. With --aot the runtime and scripts compile ahead of time into one native library: half the size, a third of the start-up time.

A splash screen while the game loads, with the project's own logos
Starts with a double-click, still takes --headless

Showcase

Sample scenes from the repository, rendered headless by the player.

Showroom rendered by Tassix — Showroom PBR materials, reflection probes, a skybox and URP post-processing. `dotnet/samples/scenes/showroom.json`

3D platformer rendered by Tassix — 3D platformer A character, a follow camera and Kenney's 3D models, driven by MonoBehaviours. `dotnet/samples/scenes/platformer3d.json`

2D platformer at night rendered by Tassix — 2D platformer at night Sprites lit by URP 2D lights, with shadows and normal maps. `dotnet/samples/scenes/platformer2d_night.json`

Particle effects rendered by Tassix — Particle effects ParticleSystems with bursts, curves, gradients, collision and trails. `dotnet/samples/scenes/particles_fx.json`

Navigation crowd rendered by Tassix — Navigation crowd NavMesh agents baked at start, walking with avoidance. `dotnet/samples/scenes/navigation_crowd.json`

Physics rendered by Tassix — Physics Rigidbodies, colliders and joints with Unity's callbacks. `dotnet/samples/scenes/physics.json`

LOD groups rendered by Tassix — LOD groups LODGroups, mesh LODs and GPU culling. `dotnet/samples/scenes/lod_demo.json`

2D lights and shadows rendered by Tassix — 2D lights and shadows A point light through a window cookie, with ShadowCaster2D shadows. `dotnet/samples/scenes/lights2d.json`

TextMeshPro effects rendered by Tassix — TextMeshPro effects Distance field text with outlines, shadows and dilation. `dotnet/samples/scenes/text_effects.json`