Deep Unity Integration

Built Deep for Unity

UnityIDE doesn't just support Unity — it's built around it. From C# parsing to scene graph analysis to live Editor integration, every feature is purpose-built for game developers.

Download Free Read the Docs

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
  • Writes are validated first — invalid UXML or USS is refused, not written with a warning
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

More than thirty tools, most of them Unity-specific.

  • 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
  • External agents are supported over ACP — bring Claude Code or another agent and keep the same Unity tools
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

Ready to build faster?

Download UnityIDE for free and experience Unity development with AI that actually understands your project.

Download Free Read the Docs