Unity-aware C#

A C# language server, plus analysis that knows what this engine does at runtime.

csharp-ls language server: completions, hover, go-to-definition, find references and rename across the whole solution
Analyzers written for Unity, not for C# in general — allocations inside Update, GetComponent in hot paths, Camera.main lookups, WaitForSeconds allocated in a loop
Catches legacy Input calls in a project that has already moved to the Input System, and UI Toolkit queries that will not resolve
Flags fields that look serialized but will not be, and near-miss lifecycle names such as OnTriggerEnter2d that Unity will silently never call
Lifecycle methods marked in the gutter — Awake, Start, Update, FixedUpdate, OnEnable and the rest
Unity attribute completions and live templates: SerializeField, Header, Range, Tooltip, RequireComponent, CreateAssetMenu
FormerlySerializedAs generation so a field can be renamed without losing what the Inspector already saved
A debugger that attaches to the Editor, with call stack, variables and watch panels

unity-aware-c#

// PlayerController.cs

void Awake() lifecycle

void Update() lifecycle

---

GetComponent called every frame — cache it

Input.GetAxis in a project on the Input System

[SerializeField] float speed — shows in Inspector

Scenes, prefabs and serialized assets

Unity writes YAML. You should not have to read it.

Scenes, prefabs and materials open as a navigable structure — GameObjects, components and serialized fields — instead of raw YAML
A scene diff that reads as objects and components rather than as changed text lines
Bidirectional GUID resolution through .meta indexing, so a script reference can be traced to every scene and prefab using it
Raw editing is still one click away, behind a warning, because a hand edit to serialized YAML can break references silently
Files the agent creates get a valid GUID and a matching .meta written alongside them
Package cache sources open read-only so a stray keystroke cannot edit a dependency

scenes,-prefabs-and-serialized-assets

// Player.prefab

Player Transform Rigidbody

Camera Rig

Main Camera Camera

---

guid 8f3c1a2d9b7e -> PlayerController.cs

referenced by 3 scenes, 7 prefabs

ScriptableObjects

The Inspector for a .asset file, inside your editor.

A .asset resolves its m_Script GUID, finds the class behind it, and renders the real typed fields
Falls back to the structural view when a file is not a typed instance, rather than guessing
The agent can list ScriptableObject types and instances across the project
Drift between a class and the instances already saved against it can be detected and reconciled

scriptableobjects

// PlayerStats.asset

m_Script -> PlayerStats.cs

---

Max Health 100

Move Speed 5.5

Starting Weapon Pistol.asset

---

2 instances predate a field added to the class

reconciled

UI Toolkit

Game UI you can see while you build it.

UXML renders on a live preview canvas beside its source
An element inspector for whatever is under the cursor on the canvas
A design chat docks over the canvas, so the AI works on the screen you are looking at
USS variables, PanelSettings coordinate space and layout rules are part of what the AI is told about your project
Vetted screen templates the agent can scaffold from instead of inventing structure
The UI write tool blocks malformed UXML and specific stylesheet errors before saving; other findings can remain warnings, so verify the result in Unity

Explore UXML editing and UI Toolkit preview →

ui-toolkit

// MainMenu.uxml

VisualElement .menu-root

Label “NEON DRIFT”

Button #play .btn

---

write refused: unknown USS property flex-flow

corrected, written, MainMenu.uss.meta created

Input System

Your real action names, not invented ones.

Action maps, bindings and control schemes open as a readable table instead of JSON
The agent reads .inputactions directly, so generated handlers use the actions your project actually defines
Action assets can be edited through the agent as well as by hand
Input actions are indexed and available to @-mentions, search and the file pickers

input-system

// Gameplay.inputactions

Player Move WASD · Left Stick

Jump Space · Button South

UI Navigate

---

agent read 3 maps, 11 actions

Live Unity Editor integration

A connection to the Editor that is running right now.

Play, pause and stop Unity from the IDE toolbar
Console logs stream in live, with stack traces you can click through to the source line
Edit Mode and Play Mode tests run from the IDE and report results back when the run completes
Compilation status arrives the moment scripts rebuild — including while Unity is in the background and not the focused app
Scene and GameObject state can be read, and properties set, with Unity's own Undo stack intact
Menu items can be executed and assets refreshed without switching windows

live-unity-editor-integration

Connected to Unity 6000.3

---

Play | Pause | Stop

---

[LOG] Player spawned at (0, 1, 0)

[WARN] NavMesh not baked

[ERR] NullReferenceException at EnemyAI.cs:34

---

Tests: 12 passed, 0 failed

The AI agent

Code, asset and Editor tools in one Unity development workflow.

Reads the scene hierarchy, inspects GameObjects, resolves GUIDs and finds asset references
Searches the Unity API and Unity documentation rather than recalling it
Runs your tests, reads the console, and after each turn checks for errors it introduced and makes one bounded repair pass
Edits land as reviewable diffs, and checkpoints let a turn be rolled back after the fact
Approval gates stand in front of anything that mutates a scene or writes a Unity asset
Plans for larger work, with a live todo list and a stop button that actually stops
Claude Code connects through ACP on eligible paid plans; provider authentication and configured MCP servers determine its available tools

Explore AI agents for Unity development →

the-ai-agent

> Make the enemy drop loot on death

---

get_scene_hierarchy

unity_set_property Enemy.LootTable

unity_run_tests

---

3 files changed · checkpoint saved

console clean after recompile

Project knowledge graph

Indexed once, queried by the AI instead of guessed at.

C# parsing extracts classes, methods, fields, attributes and inheritance chains
Unity YAML parsing covers GameObjects, components, serialized fields and transform hierarchy
Input actions and assembly definitions are indexed alongside code and scenes
The graph is queryable: traverse relationships, explain why two things are connected, and find the path between them
Rebuilds incrementally as files change, so it does not go stale while you work

project-knowledge-graph

> What uses GetComponent<Rigidbody>?

---

graphify_query

PlayerController.cs:42

EnemyAI.cs:28

Projectile.cs:15

---

3 results, from an index 0.4s old

Version control

Git that understands what a Unity repository contains.

A source control panel with staging, commits, branches and history
UnityYAMLMerge is located and configured as the merge driver, so scene and prefab conflicts merge with Unity's own tool
Worktrees, for keeping a second branch checked out without disturbing the Library folder
Diffs for serialized assets read as structure rather than as YAML text

version-control

# scene conflict

Assets/Scenes/Main.unity

---

merged with UnityYAMLMerge

+2 GameObjects, ~1 component

---

worktree feature/hud -> ../hud

The IDE itself

The ordinary things, done properly.

An integrated terminal that handles interactive CLI tools, not just command output
Project-wide search and replace with regex, plus a searchable command palette
Six themes, applied consistently across the shell, the code editor and the terminal
Inline completions as you type, from the same models that power the chat
Markdown preview, an asset viewer, and folder icons for Unity's special directories
Automatic updates, signed and verified before they install

the-ide-itself

# terminal

$ dotnet test

---

Ctrl+P files

Ctrl+Shift+P commands

theme unityide-dark

---

Update 0.3.3 ready — signature verified

IDE tools built for Unity