Each phase ends with something you can run.

Edit > Project Settings, a tab beside the Scene view: Tags and Layers, Physics and Physics 2D (gravity, and the layer collision matrix as Unity's triangle of checkboxes), Time, Quality (the level and its vsync, anti-aliasing and shadows), the Input Manager's axes (each field, added and removed) and the Player's company, product name and default icon, read from the project's ProjectSettings files and each edit saved as the line it changes. The runtime applies a changed file at once (editor_settings_changed), so the next play obeys it. Agents can't change these over MCP yet.

File > Build Settings, a tab beside the Scene view: the scenes in the build, ticked in or out, reordered and removed, the open one added, saved into EditorBuildSettings.asset (the runtime takes the new order at once); and Build, which packages the project into a folder with the player and runtime the editor runs on, on its own thread with its steps in a progress bar, then offers to show the game in its folder. The packaging is tassix_package, shared with cargo xtask package (which keeps the NativeAOT step).

Window > Lighting, a tab beside the Inspector: the open scene's RenderSettings as Unity's Environment tab has them: the skybox material (Unity's default, none or the project's), ambient light from the skybox, a gradient or a colour, reflections (source, resolution, intensity, bounces), fog (colour, mode, its start and end or density), halo and flares. Each change is the SetRenderSettings command agents use, one undo step, and shows in the Scene and Game views at once; a setting put back to its default is cleared from the scene.

A NavMeshSurface's Inspector has Bake and Clear, as Unity's; a bake builds it in the edit scene (editor_navmesh), says its triangles and walkable area, and the Scene view draws the navmesh over the scene in translucent blue, depth-tested, until it's cleared or baked again. The bake isn't saved with the scene yet (Unity keeps it as a NavMeshData asset); play bakes surfaces as they start.

Window > Profiler, beside the Console: while playing, each frame's time split into the game's scripts, its physics (the 3D and 2D steps, timed in the script host), rendering the views and the editor's own UI, a stacked bar per frame over the last 300 with lines at 60 and 30 fps; Record and Clear; a click picks a frame and shows its parts. A slow script's frames stand out as tall blue bars.

Pivot or Center (Z; in Center a rotation turns the selection about its middle), Global or Local (X), the Transform tool (Y: move arrows, rotation rings beyond them, a uniform scale at the centre), snapping by vertex (hold V: the selection's vertex nearest the pointer carried onto the nearest vertex of what's under it), draw modes (Shaded, Wireframe, Shaded Wireframe), the selected camera's view in the bottom-right corner, GameObject > Move To View, Align With View and Align View to Selected, and the Hierarchy's eye and lock (hidden objects leave the Scene view but not the Game view; hidden and locked ones aren't picked, a click going through to what's behind). Visibility isn't kept between sessions yet.

A Unity scene's Open Scene Additive (the Project pane's menu) opens it beside the open one, its objects under its own row in the Hierarchy (folding away; Remove Scene closes it), drawn and edited with the first's (its ids start after the first's, first_id on export). Saving writes each scene's objects into its own file, and rebuilds (prefabs, model settings) carry every scene through. Not yet: moving objects between scenes, choosing the active scene (new objects go in the first), and play loading them as separate scenes.

Lock keeps the Inspector on the object it shows whatever's selected; Debug shows each component's instance ID and a script's private fields that aren't serialized (read-only, from the runtime: editor_debug); a component's menu has Reset (its fields back to their defaults) and Move Up and Move Down (taken out and put back with the same id and fields), each one undo step; and the Name field shows a dash across objects whose names differ. Debug mode shows the edit scene's values (the live Inspector while playing doesn't have it yet).

Edit > Preferences, a tab beside the Scene view: the theme, the External Script Editor (a program and its arguments, $(File), $(Line) and $(Project) filled in; VS Code, else the system's, when none), the Scene view's grid (shown, how strongly), its colours (the selection outline, wireframe, navmesh; each back to the theme's with Reset), and the editor's shortcuts, each changed by clicking it and pressing the keys (Escape leaves it, Backspace takes it off, Reset gives back the editor's own, two on the same keys said so). The menus show the shortcuts in force; everything's saved with the preferences.

Unity parity, phase 7: the Animator window shows a layer's sub-state machines as nodes (a box with cut corners), dragged as states are; a double-click goes in, to its own states (made, linked and made its default as the layer's are), and a breadcrumb above the graph (and the corner's name) goes back out. Create Sub-State Machine in the graph's menu; Make Transition from a state onto one goes into it (its default state plays); Delete Sub-State Machine takes everything in it with it. Transitions out of one to the states around it (Unity's Up node) aren't made in the window yet.

Unity parity, phase 7: a clip picked in the Project pane shows Loop Time (written into the .anim, an undo step; the runtime plays a clip without it once and holds its end), its length and sample rate, what it animates and its events (edited in the Animation window). Loop Pose and a clip's own Cycle Offset aren't offered: the runtime doesn't use them (a state's Cycle Offset it does). A controller shows its layers (blending, weight, how many states) and parameters, and Open in Animator shows it in the Animator window while the selection has no controller of its own.

Unity parity, phase 7: a project's .asset data picked in the Project pane shows its script and its fields in the script's order, with the editors a component's have (Unity's attributes too), each edit written into the file as Unity writes it (editor_data_asset_save, the rest of the file as it was) as an undo step; the project's ScriptableObjects with [CreateAssetMenu] are in the Project pane's Create menu, in submenus as their menu names have them, making a new asset named as the attribute says.

Unity parity, phase 6: File > Build And Run (Ctrl+B, and beside Build in Build Settings) packages the project as Build does, into Build Settings' folder, then starts the game; the build is followed every frame, whatever pane shows. Search (Ctrl+K) is one field over the scene's objects, the project's assets and the editor's menu commands, the matches under Scene, Project and Menu (those starting with what's typed first); the arrow keys move through them, Enter or a click goes to one (an object selected, an asset in the Inspector, a command run), Escape closes it.

Unity parity, phase 6: the Animator window's Layers tab (beside Parameters) lists the controller's layers, a click showing one's graph; + adds one (its own state machine, all its weight), its menu deletes it; the shown layer's name, weight, Override or Additive, and Avatar Mask. Create State > From New Blend Tree makes a state playing a blend tree (1D on the first Float parameter, or a new Blend one); its settings give the blend type (1D, the 2D kinds, Direct), its parameters, and its motions, each a clip with its threshold (a position in 2D, a parameter for Direct), + adding and − removing one. Each change writes the .controller as Unity does (fields the window doesn't show kept) and is an undo step; the runtime plays them.

Unity parity, phase 6: the Animation window's Events row under the ruler: Add Event at the playhead (or a double-click on the row), each event a marker that's picked by a click, dragged to another frame and deleted from its menu; the picked one's settings hang from it: its function, from the methods the animated object's scripts have that an event can call (editor_event_methods, as the Animator finds receivers), and the parameter that method takes. Saved into the .anim's m_Events as Unity writes them (an object parameter kept as written), each change an undo step; the runtime calls them while playing.

Unity parity, phase 6: Window > Layouts has Unity's Default, Tall (the Scene view over the Game view) and 2 by 3 (those beside the Hierarchy, Project and Inspector in columns), the layouts the person saved (Save Layout under a name; a name in use is replaced), each loaded by clicking it, and Delete Layout; kept with the preferences, so they come back after a restart. Reset Layout goes back to Default.

Unity parity, phase 6: canvases draw while editing, in the Game view and the Scene view, as Unity's do: laid out for the game's screen and their graphics built when the scene or the screen changes (editor_ui; frames do it while playing).

Unity parity, phase 6: the Game view's aspect drop-down (Free Aspect, 16:9, 16:10, 4:3, Full HD, and resolutions added from it), the game's screen letterboxed to it (a resolution at its own size when it fits, else scaled down) with Screen.width and height, and so canvases, following it (the Scene view's render leaves the screen as the game has it), the pointer mapped into it; Maximize On Play, Mute Audio (the mixer's output, whatever scripts set) and Stats (frame time, screen, cameras, draw calls, objects), kept with the preferences.

Unity parity, phase 6: a UI object's Transform section is its Rect Transform, as Unity's: the anchor presets (Unity's grid of sixteen; Shift sets the pivot, Alt the position), the position and size, or on a stretched axis its edges' distances from its anchors (Left, Right, Top, Bottom), the anchors and the pivot; every edit keeps the rect where it is in its parent (editor_parent_rect), as Unity's do. The runtime applies a RectTransform's anchored position after its other fields.

Error Pause in the Console pauses play when an error's logged (or thrown); the toolbar's time scale beside Play, Pause and Step is the game's Time.timeScale (editor_time_scale), set from the first frame; and a component's Copy Component in the live Inspector takes its values as the game has them that moment, to paste onto the scene's with Paste Component Values after Stop.

Create Prefab Variant on a prefab (a prefab instancing its base, as Unity writes one), edited in prefab mode as overrides of the base; a prefab placed inside another shows as its own instance (the runtime gives each object the chain of prefabs it comes from); Unpack Prefab (its nested prefabs stay instances) and Unpack Prefab Completely. Copies linked to a prefab become instances before a prefab changes, so they follow it.

Components added to an instance (marked, applied to the prefab or removed), prefab components removed from one (shown struck through, restored as themselves or the removal applied), objects added under one (marked in the Hierarchy, applied); and on the instance root its prefab with Open and an Overrides summary listing them all by object, with Revert All and Apply All. Applying rebuilds the scene so every instance takes the change.

A prefab opens on its own (double-click in the Project pane, or Open Prefab on an instance's row), the scene parked with its unsaved changes, a breadcrumb above the Scene view going back; going back saves the .prefab and rebuilds the scene so every instance takes the change (unsaved changes and unsaved prefab links carried through a copy in the project's Temp). Links to prefabs are kept per scene in the runtime. (The scene's undo history starts again when a prefab changed.)

A log names the object it's about (Debug.Log's context, or the behaviour a script exception came from) and its stack; clicking it selects the object (the live one while playing), its stack shows below in Unity's form with the script frames as links, and a link or a double-click opens the script at that line in VS Code (found on the PATH or where it installs; the system's opener otherwise). Scripts open from the Project pane (double-click) and the Inspector (Edit Script) too. Exceptions log as Unity's ("Type: message", the stack apart), and the MCP server's logs carry an error's stack.

An object dragged onto a Project folder becomes a .prefab (its children and components, in Unity's format, with its .meta), and the object an instance of it, saved into the scene as a PrefabInstance with what differs as overrides. Instance roots carry the prefab icon in the Hierarchy, with the prefab named on hover.

Create (Folder, C# Script from Unity's template, Material, Scene with a camera and a light), rename in place (a script's class with it), drag onto a folder to move, Delete to the recycle bin; each with its .meta, so GUIDs and the references to them hold, the runtime told where assets went, and the open scene followed when it moves.

Create Empty, Empty Child (Alt+Shift+N) and Empty Parent (Ctrl+Shift+G); 3D objects, Sprite, Particle System, Trail, Line, the four lights, Audio Source, Camera, and UI (Canvas with its EventSystem, Image, Text, Button), each with Unity's components, rotation, layer and built-in materials, font and sprite.

The selection outlined in amber (its meshes' silhouettes, children's too); colliders (box, sphere, capsule, character controller, 2D box and circle, mesh as its outline) in green; lights' range, cone or direction in amber; cameras' view; audio sources' ranges in blue.

Top bar, panels, tabs, Hierarchy and Project trees, Inspector headers and fields, Console, Review, History, empty states, focus ring, light theme.

Search, arrow keys, rename in place, drag to reorder or parent (the selection too), double-click to frame.

Fields that fit the panel, enum drop-downs, component and Static checkboxes, Add Field in the header menu, play-mode editors.

The components they share, differing values shown as —, one undo step. (The name field still shows the active object's.)

Ctrl keeps a handle drag to steps (1 unit, 15°, 0.1 scale), set in the scene tools' Snap menu.

Described between frames:

10,000 objects take about 2 ms a frame (the Hierarchy draws only the rows in view; the scene's snapshot is kept until it changes), held under 8 ms by tests/large_scene.rs in release builds.

A component field, or an object's tag, layer or Transform, that differs from its prefab is bold with a bar, and its menu (or the component's) applies it to the .prefab file, giving the scene's other instances the value, or reverts it.

References, names, positions and rotations stay, as Unity keeps them:

"Apply radius to Coin.prefab": undo and redo put the .prefab file back and forth, agents' undos included.