Unity CLI release notes for September 2026

Learn about the Unity CLI releases in September 2026.

Read time 78 minutes

Last updated a day ago

This page contains the release notes for the Unity CLI versions released in September 2026, from newest to oldest.

1.0.0-beta.12

Release date: September 30, 2026

Security
- ```
unity collaboration jira server add
```
  ,
```
update
```
  , and
```
test
```
  now take
```
--key-from-stdin
```
  , which reads the Jira API token from stdin so it doesn't show in the process list or in CI logs that echo commands. Pipe the token in, for example
```
printf '%s' "$JIRA_TOKEN" | unity collaboration jira server test --organization-id <id> --url <url> --username <name> --key-from-stdin
```
  .
- The CLI's logs and crash reports now fully mask email addresses whose domain ends in an internationalized top-level domain, such as
```
.рф
```
  (written
```
xn--p1ai
```
  ). Previously, the end of the domain was left in the clear next to the mask.
- ```
unity bug
```
  now removes user names and passwords embedded in URLs from the logs it attaches, including debug logs. Before, a credentialed URL in a debug log record, or one whose host was an IP address or
```
localhost
```
  , was uploaded as written.
- ```
unity bug
```
  now also masks the OS account name embedded in the Unity auth broker's named pipe (
```
Unity-auth-broker-<account>
```
  , with or without a CoCreate slot) in the log files it collects, matching the CLI's own log writer and the native Hub. Previously, a collected Editor or Licensing Client log that mentioned the broker's pipe path was uploaded with the account name in the clear.
- On macOS, installing a plugin's runtime component now verifies the code signature of every native library it extracts, not just its main executable. Before, an unsigned or tampered library deep in the install could pass installation and only fail the first time something tried to load it.
- ```
unity plugin
```
  now refuses a plugin download URL that hides a
```
..
```
  behind an encoded slash or backslash (such as
```
..%2F
```
  ), or that contains a control character (such as a tab or a line break), written out or percent-encoded (such as
```
%0c
```
  ), or a non-ASCII character, or a
```
..
```
  or
```
.
```
  padded with spaces (such as
```
..%20
```
  ). A plugin catalog naming such a URL, or repeating a JSON key, is treated as invalid, and the CLI falls back to its cached or built-in catalog.
- A command run inside a piped
```
unity shell
```
  session, or one driven with
```
unity shell --protocol ndjson
```
  , can no longer read the lines meant for the shell. Before,
```
unity auth login --secret-from-stdin
```
  ,
```
--key-from-stdin
```
  , and
```
--git-token-stdin
```
  read from the same stdin as the shell, so the rest of a script could be sent to a server as the secret.
- The helper that sends crash reports no longer inherits your whole environment. It receives only the variables it needs, so a credential such as
```
UNITY_SERVICE_ACCOUNT_SECRET
```
  no longer reaches it.
Added
- ```
unity projects create --with-pipeline
```
  adds the Pipeline package (
```
com.unity.pipeline
```
  ) to the new project, so an AI agent can drive the Editor as soon as it opens, without a separate
```
unity pipeline install
```
  . The project is still created when the package can't be added (an editor older than Unity 6, or the registry is unreachable): you get a warning and exit code 0.
- ```
unity status --format json
```
  shows whether a game in Play mode is actually running. While the Editor is in Play mode, each instance row carries
```
frameCount
```
  and
```
playerLoopTicking
```
  , passed through from the Editor.
- ```
unity install
```
  ,
```
unity install-modules
```
  and
```
unity projects require
```
  accept
```
--no-wait
```
  and
```
--wait-timeout <seconds>
```
  for when the Hub or another CLI is already installing. By default they still wait until that install finishes.
- Experimental, unsupported: on a Linux arm64 host you can opt in to running the x86_64 Unity Editor under FEX-Emu by setting
```
UNITY_EXPERIMENTAL_FEX_EMU=1
```
  . It takes effect only when FEX-Emu and an x86_64 RootFS are installed, and
```
unity doctor
```
  reports whether they are.
- A registry plugin's published version can now state the minimum version of a runtime it needs.
```
unity plugin install
```
  and
```
unity plugin upgrade
```
  check it after resolving the runtime, and hold the tool back with a clear message naming the runtime and the version required, plus
```
unity plugin upgrade <runtime>
```
  to fix it, rather than installing or upgrading a tool next to a runtime it can't actually use.
- ```
unity commands --grep <pattern>
```
  searches the CLI's commands and its plugin catalog by keyword, so you can find the command for a task without paging through
```
--help
```
  . It matches command names, descriptions, and options, and plugins whether or not they're installed; each result says whether it's a command or a plugin, and a plugin you haven't installed names the command that installs it.
- ```
unity plugin list
```
  now shows a short description of what each plugin does, in every format (human,
```
--format json
```
  , and
```
--format tsv
```
  ), whether or not it's installed. It's the easiest way for a script or an agent to learn what plugins exist and what they're for.
- ```
unity plugin install
```
  ,
```
unity plugin upgrade
```
  ,
```
unity plugin list
```
  and
```
unity doctor
```
  now say where each runtime a plugin uses came from:
```
machine
```
  for a copy that was already on your computer,
```
package-manager
```
  for one installed through Homebrew, winget, apt or dnf, and
```
managed
```
  for the Unity CLI's own download. JSON and NDJSON rows carry it as a new
```
source
```
  field (
```
null
```
  for a tool), and TSV output adds it as a last column, so existing columns keep their positions.
- A command from a catalog plugin that you have not installed now fails with the same clear message under
```
--format json
```
  and
```
--format ndjson
```
  as it already did in human output, wrapped in the usual error envelope under a stable code. A failed
```
unity plugin install
```
  /
```
upgrade
```
  download also now logs the actual reason, so
```
unity logs
```
  shows what the on-screen message already tells you to look for.
- ```
unity skill disable <skill>
```
  and
```
unity skill enable <skill>
```
  turn an installed skill off and back on without uninstalling it, and
```
unity skill list
```
  shows every tracked install with its state. Every installed skill's description is loaded into every session of the client that found it, whether or not the skill is ever used, so the cost is paid per skill installed rather than per skill useful on this project — and until now the only way to stop paying it was to delete the files by hand and edit the CLI's own install record, which the next
```
unity skill refresh
```
  undid anyway.
- ```
unity pipeline cloud-build
```
  and
```
unity pipeline automation
```
  add twenty-four more read-only inventory commands across fourteen groups, extending the ten they shipped with.
```
cloud-build
```
  gains
```
project get|stats
```
  for the project already in scope, a
```
tooling
```
  group with six lookups for what you can build with (
```
unity
```
  ,
```
xcode
```
  ,
```
visual-studio
```
  ,
```
os
```
  ,
```
platforms
```
  ,
```
machine-types
```
  — every one has
```
list
```
  , and
```
unity
```
  and
```
os
```
  also have
```
get
```
  ), and
```
targets groups
```
  .
- ```
unity projects create
```
  ,
```
unity projects link cloud
```
  ,
```
unity projects link vcs
```
  , and
```
unity vcs setup
```
  accept
```
--coppa <status>
```
  to set the COPPA status of a Unity Cloud project they create:
```
not_compliant
```
  (the default, unchanged),
```
compliant
```
  , or
```
unspecified
```
  . When a command creates a cloud project, its output now names the COPPA status it sent, and JSON and NDJSON results include
```
coppa
```
  .
- ```
UNITY_CLI_FTUE=1
```
  turns on the agent first-session ("paved") mode. Every
```
--format json
```
  envelope and ndjson result frame then carries
```
"paved": true
```
  .
- A passthrough tool (
```
unity uvcs
```
  ,
```
unity cm
```
  ,
```
unity ugs
```
  , and any future curated tool) now gets
```
UNITY_CLI_INVOKED_AS
```
  and
```
UNITY_CLI_CORE_VERSION
```
  in its environment.
```
UNITY_CLI_INVOKED_AS
```
  is the command you actually typed, for example
```
unity uvcs
```
  , so a tool with more than one alias can show help and errors that match what you ran.
- ```
--format json
```
  and
```
--format ndjson
```
  output can now carry a
```
notifications
```
  array telling you when a newer
```
unity
```
  CLI is available, so scripts and AI agents find out without running a check of their own. Each entry has a
```
code
```
  , a readable
```
message
```
  , and a
```
remediation
```
  naming the command that updates you.
- The CLI log now records every command you run, with its arguments, exit code, and duration, so
```
unity logs
```
  and
```
unity bug
```
  reports show what ran. Tokens, passwords, and credentialed URLs in arguments are redacted.
- ```
unity projects report
```
  groups every registered project by the editor version its
```
ProjectVersion.txt
```
  asks for, and flags a version that isn't installed and a version whose stream isn't LTS. It never installs, removes, or changes anything.
- ```
unity status
```
  and
```
unity pipeline list
```
  now show Multiplayer Play Mode virtual players, named by player (for example "Player 2") under the project they belong to. In JSON and NDJSON output, both commands add
```
role
```
  ,
```
instanceName
```
  , and
```
vpId
```
  , and
```
unity pipeline list
```
  also adds
```
ownerProjectPath
```
  .
- ```
unity changelog --target <version>
```
  shows the release notes for a specific version, for example before you update with
```
unity self-update --target
```
  .
- ```
unity templates list --format json
```
  now accepts
```
--brief
```
  , which trims the output to the same name, display name, type, version, and status columns the table view already shows. Use it when all you need is a template id: the full JSON output can run into the hundreds of KB.
- ```
unity status --until-ready
```
  waits until a matching Editor reports
```
ready
```
  and then prints the usual status, so you don't have to poll it after
```
unity open
```
  or while an Editor enters Play mode. It also waits for an Editor that hasn't started yet, and
```
--timeout <seconds>
```
  (default 300) sets how long it waits before it exits
```
6
```
  with the last state it saw.
- ```
unity setup claude
```
  installs Unity's Claude Code plugin, with its Unity skills, in one step: it adds the plugin's marketplace and installs the plugin through the
```
claude
```
  CLI, and reports the plugin's version, whether it loads in this session or the next, and where its skills can be read right away. It's safe to re-run, since an existing install is reported rather than reinstalled.
- ```
unity projects info
```
  now shows whether Developer Data diagnostics is on: the project's build-default setting and the file it came from, any build profile overrides, and the cloud link.
```
unity projects create
```
  includes the same
```
diagnostics
```
  block in its JSON and NDJSON result.
- ```
unity build
```
  's JSON and NDJSON result now includes
```
outputPath
```
  , the absolute path of the build output. It's
```
null
```
  only when you build with
```
--execute-method
```
  and no
```
--output-path
```
  , since your own build method decides where the output goes.
- ```
unity vcs providers
```
  now lists
```
cm
```
  , the Unity Version Control client, with the same path, version, and state
```
unity plugin list --versions
```
  reports. Inside a Unity Version Control workspace with no
```
cm
```
  installed, it suggests
```
unity plugin install uvcs
```
  .
- The installers (
```
install.sh
```
  and
```
install.ps1
```
  ) now end with a line for AI agents that names the command to start with:
```
UNITY_CLI_FTUE=1 unity auth status --json
```
  , or
```
$env:UNITY_CLI_FTUE=1; unity auth status --json
```
  in PowerShell.
```
install.sh
```
  also prints plain text, without color codes, when its output isn't a terminal or
```
NO_COLOR
```
  is set.
- ```
unity bug
```
  now asks which part of Unity the issue is in: the CLI itself, the Pipeline package (
```
com.unity.pipeline
```
  ) in the Editor, the Editor, or not sure. Until now a report said nothing about where the failure was, so an Editor or Pipeline package failure that happened to show up in CLI output was routed as a CLI bug.
- ```
unity docs
```
  now reaches Unity’s documentation platform as well as the Editor documentation:
```
--cli
```
  for the Unity CLI,
```
--hub
```
  for the Unity Hub, and
```
--cloud
```
  for Unity Cloud. Those pages aren’t versioned by editor, so they take no
```
--editor-version
```
  , and the four documentation selectors — including
```
--manual
```
  — are mutually exclusive.
- ```
unity command --tags
```
  asks for that same tag listing explicitly, and composes with the other listing filters:
```
unity command --tags --tag runtime
```
  shows the tags within one subtree,
```
unity command --tags --query prefab
```
  shows which tags have prefab-ish commands in them. It renders in every output format — a
```
tag
```
  /
```
count
```
  table under
```
--format tsv
```
  , one object per tag under
```
--format ndjson
```
  , and a
```
tags
```
  array under
```
--format json
```
  .
- ```
unity command --help
```
  now ends with runnable examples — how to list the tags, how to list one tag's commands, how to run a command, and how to run one with arguments.
```
unity command
```
  is the entry point to the Editor's whole command surface, and the help had no worked example of invoking anything through it.
- ```
unity bug --help
```
  now points at
```
unity bug mcp
```
  , a new way to add Unity’s Issue Tracker to an AI assistant so it can check for known issues before you file a report. It’s exactly
```
unity mcp configure --server issue-tracker
```
  , so it takes the same client argument and the same
```
--list
```
  ,
```
--local
```
  ,
```
--yes
```
  , and
```
--dry-run
```
  flags.
- ```
unity projects create --template
```
  now accepts a local template as well as a registry name: a path to a
```
.tgz
```
  archive, or to a directory holding a
```
package.json
```
  with a
```
name
```
  field. The archive or directory is validated (the archive is checked as a readable
```
tar
```
  stream, and a directory's
```
package.json
```
  must parse and declare a
```
name
```
  ) before it's handed to the Editor, with a clear error naming what's wrong.
- ```
unity pipeline upgrade
```
  now shows what's changing: alongside the resolved version, it prints that version's release summary, and when the upgrade spans more than one published version, it shows every version in between too, oldest first, so a change in a version you're skipping past is never silently missed.
```
unity pipeline install --force
```
  shows the same summaries when it moves an already-installed project to a newer version.
Changed
- ```
unity status
```
  no longer tells you to install the Pipeline package when you just did. If you install it while the project's Editor is already open, the Editor doesn't load it until its window regains focus.
- ```
unity releases
```
  ,
```
unity projects list
```
  ,
```
unity context list
```
  ,
```
unity auth list
```
  ,
```
unity modules list
```
  ,
```
unity list
```
  and
```
unity doctor
```
  now end their
```
--format ndjson
```
  output with a
```
{"type":"result"}
```
  line, as
```
unity editors
```
  already does, so a script can tell a complete listing from a cut-off one. The rows before it are unchanged, and the last line's
```
data.count
```
  is the number of rows.
- ```
unity assets export
```
  now signs the
```
.unitypackage
```
  it writes when the project uses Unity 6.6 or later, the same way the Editor's own Export Package window does. It signs for your organization: pass
```
--cloud-org <id-or-name>
```
  , set
```
UNITY_CLOUD_ORG
```
  , or rely on the default set with
```
unity cloud org set-default
```
  .
- On Windows, a runtime that a plugin needs (for example the Python a tool uses) now installs under
```
%LOCALAPPDATA%
```
  instead of your roaming profile, so a domain roaming profile no longer copies it at every sign-in and sign-out. A runtime installed by an earlier version moves across the next time you install, upgrade, remove or run that plugin, and it keeps working until then.
- ```
unity command
```
  with no command name now lists the Editor's command TAGS instead of every command it has. A connected Editor answers with around fifty tags and the number of commands under each, which fits on one screen;
```
unity command --tag <tag>
```
  then lists that tag's commands, and the count on a tag's row is exactly how many that will be.
- A partial
```
--editor-version
```
  that matches several installed patches now runs the newest one instead of refusing.
```
unity run --editor-version 6.6
```
  with both
```
6000.6.0f1
```
  and
```
6000.6.1f1
```
  installed used to be an error; naming a line is a reasonable way to ask for an editor, and the two candidates differed only by a patch you had already said you did not care about.
- ```
unity open
```
  and
```
unity projects open
```
  now print a success document under
```
--format json
```
  and
```
--format ndjson
```
  , with the project path, the resolved Editor version and location, and the launched process id, instead of writing nothing on a healthy launch. If a script or agent relied on empty stdout to mean success, check
```
success
```
  (or the exit code) instead.
- ```
unity editors
```
  ,
```
unity editors upgrade --check
```
  and
```
unity templates list
```
  now end their
```
--format ndjson
```
  output with a
```
{"type":"result"}
```
  line, like every other ndjson command, so a script can tell a complete listing from a cut-off one. The rows before it are unchanged, and the last line's
```
data.count
```
  is the number of rows.
- The CI workflows
```
unity ci init
```
  writes now install the CLI with the plain
```
install.sh
```
  command, without setting
```
UNITY_CLI_CHANNEL=beta
```
  . Until a stable release ships, the installer gets the latest beta on its own.
- ```
unity changelog
```
  now downloads the running version's release notes instead of reading a copy built into the CLI, so corrected notes appear without an update. It needs a network connection.
- Version options that look up a release now accept
```
latest
```
  and a leading
```
v
```
  , as in
```
v1.0.0
```
  :
```
unity self-update --target
```
  ,
```
unity changelog --target
```
  ,
```
unity plugin changelog --version
```
  ,
```
unity hub install --hub-version
```
  , and
```
unity pipeline install --package-version
```
  .
- ```
unity command <name>
```
  now waits while the Editor is briefly unavailable, such as right after
```
editor_play
```
  or during a script reload, and runs the command once the Editor is ready, within the command's
```
--timeout
```
  . It only resends a command the Editor rejected without running it.
- ```
unity --help
```
  now describes what the CLI can do: install an Editor, create a project without the GUI, drive a running Editor, play and capture the game, and build it. It used to just say “CLI for Unity”.
- ```
unity projects new --help
```
  now says it never links to Unity Cloud, matching what it actually does.
```
unity projects create
```
  still asks, and links by default.
- ```
unity mcp configure claude-code
```
  now checks whether a Claude Code plugin you have enabled already provides an MCP server that runs
```
unity mcp
```
  for the same project. If one does, it warns and skips its own
```
claude mcp add
```
  registration unless you confirm or pass
```
--yes
```
  , so you don't end up with two copies of the same server.
- ```
unity bug --area
```
  now accepts
```
licensing
```
  , for issues about licensing or signing in. On a terminal, "Licensing or signing in" now appears as a choice when the reporter answers the area question.
- ```
unity plugin install ugs
```
  and
```
unity plugin upgrade
```
  now install version 2.0.0 of the Unity Gaming Services CLI, which
```
unity ugs
```
  runs.
- The CLI now uses Unity Licensing Client 1.19.0-rc.3. A client it downloaded under an earlier version is replaced the next time a
```
unity license
```
  command or an Editor launch needs it.
- The first-run analytics consent prompt now uses its reviewed wording. It asks about sharing usage analytics, offers “Yes, share” and “No, don’t share”, and explains the anonymous usage count once, in a note above the choices.
Fixed
- On macOS, the CLI no longer removes Unity Hub’s keychain access to your shared sign-in when it saves a refreshed token. It now updates the saved sign-in instead of re-creating it.
- A path, version, or other value that contains a terminal control code such as
```
ESC[?25l
```
  or
```
ESC[12~
```
  no longer leaves that code's text, such as
```
[?25l
```
  or
```
[12~
```
  , in the CLI's output; the whole code is removed.
- Using the CLI no longer removes the Hub’s saved sign-in. Before, the first
```
unity
```
  command after you signed in through the Hub could leave the Hub signed out at its next launch, or, on macOS, asking for keychain access again.
- ```
unity doctor --format json
```
  no longer crashes on a Linux machine with a provisioned auth broker. The report's
```
authBroker.storeOwnerUid
```
  field now shows the broker store's owning user id as a number, and stays
```
null
```
  when it can't be read.
- ```
unity doctor --format tsv
```
  no longer passes control characters from the values it reports straight to your terminal. In a path, an account name, an editor entry, a log line or a proxy setting, a tab, newline or carriage return now becomes a space and other control characters and terminal control sequences are removed, as the rest of the CLI's tables already do, so a value can't split a row into extra columns or add a row of its own.
- On macOS and Linux, the Editor sign-in helper that
```
unity open
```
  starts, the auth broker, and the Unity Licensing Client no longer keep you from ejecting or unmounting the drive you ran
```
unity
```
  from. They now run from the root directory instead of the folder you were in.
- On Linux, a browser that
```
unity
```
  opens, for example for
```
unity auth login
```
  ,
```
unity docs
```
  or a WebGL
```
unity build run
```
  , no longer keeps you from unmounting or ejecting the drive you ran
```
unity
```
  from while it stays open. The browser opener now runs from the root directory instead of the folder you were in.
- When
```
unity command <name>
```
  fails, its error is printed once. It used to appear twice: once under
```
❌ Command '<name>' failed:
```
  and again as a plain
```
Error:
```
  line just before the
```
For more details:
```
  hints.
- A path, version, or other value that contains a truecolor color code written with colons (for example
```
ESC[38:2::255:0:0m
```
  ) no longer leaves that code's text, such as
```
[38:2::255:0:0m
```
  , in the CLI's output; the whole code is removed, as the semicolon form already was.
- ```
unity projects require --format json
```
  now writes exactly one JSON document to stdout when it installs the editor, as
```
unity install --format json
```
  does. It used to print install progress lines ahead of the result, so a script that parsed stdout as JSON failed.
- ```
unity projects upgrade
```
  ,
```
unity vcs git worktree add --install-editor
```
  , and
```
unity build
```
  ,
```
unity run
```
  and
```
unity test
```
  with
```
--allow-install
```
  no longer print install progress lines ahead of their
```
--format json
```
  result when they install an editor first. Any install warnings now appear in the result's
```
warnings
```
  , and
```
--format ndjson
```
  keeps its progress lines.
- A failed
```
unity plugin install
```
  or
```
unity plugin upgrade
```
  no longer deletes the plugin you already had. If the new version can't be put in place, the previous one is restored and keeps working, and a read-only checksum file left by an earlier install no longer makes an upgraded plugin look out of date.
- On Windows,
```
unity self-update
```
  now reports when another program is holding the CLI's executable open, instead of saying the update was staged and then leaving the old version in place. It names the programs using the file when Windows can tell, and asks you to close them or restart your computer before running
```
unity self-update
```
  again.
- ```
unity command
```
  now removes the Editor's truecolor styling from a task name in its progress bar and in the
```
--format ndjson
```
  progress messages, including the colon-separated form some tools write. That form used to pass through, which could cut the bar's label short or color the rest of the line, and left escape bytes in the ndjson
```
msg
```
  .
- ```
unity command
```
  now reports an Editor's argument error at once when the error's text happens to start with "Cannot connect to Unity Editor Pipeline server at". It used to read that answer as the Editor being unreachable and keep resending the command until
```
--timeout
```
  ran out.
- ```
unity recompile
```
  and
```
unity mcp
```
  now treat that same kind of Editor argument error as an answer, not a lost connection.
```
unity recompile
```
  exits with 6 (command failed) instead of 7 (network unreachable), and
```
unity mcp
```
  returns the error at once instead of dropping its connection, waiting out a status poll, or sending a desktop screenshot in place of a failed capture.
- ```
unity install
```
  and
```
unity install-modules
```
  now wait while the Unity Hub or another
```
unity
```
  command is installing on the same machine, instead of failing. The CLI prints “Waiting for another install to finish before continuing…” once, then continues on its own when the other install finishes, so two installers never write into one editor at the same time.
- A project command that changes your project list no longer replaces it when the list can't be read. The Unity CLI and Unity Hub share the project list, and a failed read (for example, a permission error, or Unity Hub holding the file) used to leave the CLI with an empty list, so adding, removing or pinning a project saved only that one change over every project you had.
- A setting change no longer wipes your other settings when the shared settings file can't be read. The Unity CLI and Unity Hub share one settings file, and a failed read (for example, a permission error or another program holding the file) used to replace every setting in it, Unity Hub's included, with the one you were changing.
- A file the Unity CLI shares with Unity Hub is no longer wiped when it can't be read or lists the same name twice, including your settings, located Editors, hidden Editor folders, paused downloads, proxy settings, project defaults, and template settings. The change is refused with an error that says why, or skipped with a warning when the rest of the command already finished, and the file stays as it was.
- ```
unity plugin list
```
  fits its table to the terminal. A long path used to push every row past the terminal edge, so rows wrapped and blank lines appeared between them.
- ```
unity plugin upgrade
```
  and
```
unity plugin changelog
```
  no longer show internal notes in the one-line summary for the Unity Licensing Client, Unity Gaming Services CLI, Unity Version Control, and Pipeline package entries. The summaries now describe each version in plain language.
- ```
unity templates create --name
```
  now accepts a name written only in a non-Latin script, such as Japanese or Cyrillic, instead of rejecting it for having no usable characters. The template is stored under a generated ASCII id, and
```
--display-name
```
  stays what the template shows.
- On macOS,
```
unity modules list
```
  ,
```
unity editor module list
```
  ,
```
unity install-modules
```
  , and
```
unity install --dry-run
```
  now show download and install sizes in the same units as the Hub and Finder, where 1 GB is 1,000,000,000 bytes. They used to divide by 1024, so Android Build Support read 2.36 GB in the CLI and 2.53 GB in the Hub.
- The
```
notifications
```
  array now reaches the
```
--format json
```
  output of every command, matching
```
--format ndjson
```
  . Many commands, including the
```
vcs
```
  ,
```
plugin
```
  ,
```
assets
```
  , and most
```
projects
```
  commands, left it out of their JSON.
- A sign-in that actually succeeded is no longer reported as
```
KEYRING_WRITE_FAILED
```
  . After writing your credential, the CLI reads it straight back to confirm it was really stored — a check that exists because some keyrings report a successful write and keep nothing.
- ```
unity doctor
```
  now always reports the auth broker, on every platform. The section used to appear only on Linux, or on a machine that already had a sealed credential store — so on Windows and macOS a healthy broker, a broker that was refusing this program, and a broken build all produced the same report: no section at all.
- ```
unity projects link cloud
```
  no longer fails with
```
ALREADY_LINKED
```
  on a project whose Unity Cloud link was removed from
```
ProjectSettings/ProjectSettings.asset
```
  but is still recorded in the Unity Hub project list, for example after unlinking the project in the Editor. The project now links, and both places get the new link.
- A download that gets cut off partway through now resumes instead of restarting from scratch. Before this fix, a connection dropping mid-download deleted the partial file and failed the whole operation, even though the file could have been resumed.
- ```
unity releases
```
  no longer waits forever when the Unity release service accepts the connection and then stops responding. Each request now times out after 10 seconds, so the command succeeds or fails within about half a minute.
- ```
unity projects create --cloud
```
  ,
```
unity projects link cloud
```
  and
```
unity projects link vcs --vcs uvcs
```
  no longer report a Unity Cloud link that wasn’t saved. When the project’s
```
ProjectSettings/ProjectSettings.asset
```
  can’t be updated (for example because it doesn’t exist yet, or has no Unity Cloud fields to update), the Editor and
```
unity projects info
```
  see no link, yet the command used to say it linked.
- ```
unity projects add
```
  on a case-sensitive volume no longer records a project whose path differs from an already registered project only by letter case as if it were that project. It used to copy the registered project’s path into the new registry row, so the next
```
projects
```
  command that loaded the registry folded the two rows together and deleted one.
- On Windows,
```
unity self-update
```
  ,
```
unity self-update --rollback
```
  , and
```
unity self-install
```
  now complete while other
```
unity
```
  processes are running, such as an MCP server started by an AI client or a
```
unity shell
```
  session. Before, the update reported itself as staged and then silently kept the old version until every other
```
unity
```
  process had exited.
- A mistyped command no longer reports success when you add
```
--help
```
  .
```
unity project --help
```
  printed the top-level help and exited 0 — output byte-identical to a bare
```
unity --help
```
  , so the token you typed left no trace at all — while
```
unity project
```
  on its own already printed
```
unknown command 'project' (Did you mean 'projects'?)
```
  and exited 2.
- If you interrupt
```
unity auth login
```
  while it waits for you to sign in in the browser, it now always exits
```
130
```
  for Ctrl-C and
```
143
```
  for SIGTERM. If the signal arrived while the CLI was checking whether you'd finished signing in, it used to print
```
Sign-in failed: canceled
```
  and exit
```
3
```
  .
- ```
unity run
```
  ,
```
unity build run
```
  ,
```
unity test
```
  and
```
unity assets import
```
  now exit
```
130
```
  when you stop them with Ctrl-C and
```
143
```
  on SIGTERM. A plain
```
unity run
```
  (without
```
--command
```
  ),
```
unity test
```
  and
```
unity assets import
```
  also stop the Editor they started, so a CI timeout that kills only the CLI no longer leaves that Editor running and holding the project, and an interrupted
```
unity test --retries
```
  run starts no further attempt.
- The "multiple editors found" error now names the ambiguity it actually hit. Passing a partial
```
--editor-version
```
  —
```
6.6
```
  with both
```
6000.6.0f1
```
  and
```
6000.6.1f1
```
  installed — matched two editors and told you to
```
Pass --architecture to disambiguate
```
  , which cannot work: those two candidates share an architecture, so the suggested flag had nothing to choose between and the only way forward was guessing that the full version would help.
- ```
logs/cli-log.json
```
  now records what each run did, instead of repeating the same block of startup lines on every run. Those lines are now written only to
```
debug-log.json
```
  , and the ones describing things the CLI never checked or did, such as a first-time-user check that always reported
```
firstTimeUser: true
```
  , are removed.
- On Linux,
```
unity uninstall
```
  and
```
unity editors prune --remove
```
  no longer hide an editor version from your desktop's application menu when another install of that version remains, such as the other architecture. The menu entry now points at the remaining install.
- ```
unity logs
```
  now shows the time each record was written, instead of the time you ran the command.
- If a command that runs in the Unity Editor fails with an error that mentions a refused connection, for example a web request inside the command, the CLI now shows the Editor's error. It used to report that it couldn't connect to the Editor and drop the Editor's message.
- ```
unity recompile
```
  and
```
unity mcp
```
  now also show the Editor's error when it mentions a reset or timed-out connection, or a server the command couldn't connect to, instead of treating the Editor as unreachable.
- ```
unity mcp
```
  's
```
capture_game_view
```
  and
```
capture_scene_view
```
  now fall back to a desktop screenshot when the Editor doesn't answer in time, as they already did when a dialog blocked the Editor.
```
unity recompile
```
  now exits with code 7 instead of 6 when the Editor drops its recompile request or doesn't answer it in time, so a CI step can retry it.
- ```
unity command
```
  no longer reports multiple candidate Editors for a project running Multiplayer Play Mode virtual players. It picks the main Editor; pass a clone's folder to
```
--project-path
```
  to target the clone.
- On a machine where the auth broker protects your sign-in with a local key file, because no TPM, DPAPI, keyring, or Keychain is available, two first-time sign-ins running at once on a busy machine no longer fail to save your session. A first sign-in interrupted by a full disk also no longer leaves behind an empty key file that stops every later sign-in from being saved.
- On macOS, and on Linux machines with no machine ID, the auth broker no longer loses your first saved sign-in when two
```
unity
```
  commands run at once. Before, the next command could ask you to sign in again.
- On Windows, when a program runs
```
unity
```
  and captures its output, the capture no longer waits for the auth broker to exit. The broker could inherit a copy of the output pipe from that program and hold it open until it went idle, two minutes after the last command.
- On Windows, the background identity server that
```
unity open
```
  starts now keeps accepting connections while it checks a new one, so requests to it no longer time out and get dropped.
```
unity close
```
  now reliably lets it exit early once no Editor is using it, and a second
```
unity open --cloudEnvironment
```
  reliably switches it to the new environment.
- On Windows, the background identity server that
```
unity open
```
  starts now refuses a connection made through the network redirector (a
```
\\localhost\pipe\...
```
  connection, as opposed to a direct local one), and grants access to its pipe only to the account that started it. Before, that network path reached the identity server exactly the way a genuinely local Editor does, and any other account on the machine could open the pipe directly.
- On Windows, the auth broker now keeps accepting connections while it checks a new one. Before, a command that reached it during that check could conclude that no broker was running, so
```
unity self-update
```
  , and the Hub when it installs the CLI, could fail to replace the binary the broker runs from with "Access to the path is denied".
- On Windows,
```
unity self-update
```
  , and the Hub when it installs the CLI, now also reach an auth broker that has only just started. Before, a broker still starting up could look as if none was running, so replacing the binary it runs from could fail with "Access to the path is denied".
- On Windows, capturing the output of
```
unity open
```
  no longer waits until five minutes after the Editor closes, and capturing
```
unity build run
```
  no longer waits for the player to close. A
```
unity license
```
  command that starts the Unity Licensing Client no longer waits for the client to exit.
- On macOS and Linux, a
```
unity
```
  command whose output is captured or piped no longer keeps its reader waiting after it finishes when the caller handed it an extra open descriptor, such as a shell’s
```
3>&1
```
  . The Editor, the Unity Licensing Client, and the background processes the CLI starts no longer receive that descriptor.
- On Windows, saving a setting, for example with
```
unity config set
```
  , no longer fails with "Access to the path is denied" when another program, such as the Hub, has the settings file open at the same moment.
- A failed command's entry in
```
cli-log.json
```
  is now short and readable: it names the command, the error code, and the error message once, instead of repeating the message five times. When there's more to the failure than the message, such as the connection error behind "Unable to reach the Unity release service", the entry adds it as the cause.
- ```
cli-log.json
```
  now records a failure as a warning when it's your mistake or a setup problem, and as an error only when it could be a problem in the CLI itself. A mistyped
```
unity command
```
  name, a missing parameter, an Editor version that isn't installed, and a signed-out session are now warnings wherever they happen.
- ```
unity install lts
```
  no longer picks a release Unity marked Supported just because its version number looks like an LTS one. It installs the newest release Unity marks LTS.
- ```
unity auth login --secret-from-stdin
```
  no longer waits forever. If stdin is a terminal, it now stops right away and asks you to pipe the secret in.
- On Windows, the CLI stores your sign-in as a single Credential Manager entry shared with Unity Hub, which prevents occasional sign-outs when both refresh your session at the same time. An older multi-entry record converts on your next session refresh.
- In
```
cmd.exe
```
  and other windows run by the classic Windows console, the CLI no longer prints raw escape codes such as
```
←[36m
```
  instead of colors. This affected the release notes and the update prompt in
```
unity self-update
```
  , and could affect any colored output.
- On macOS and Linux, pressing Ctrl-C during a
```
unity license
```
  command no longer also stops the Unity Licensing Client that command started. The client keeps running for the Editor and for later commands, as it does when the command finishes on its own.
- On Windows,
```
unity self-update
```
  and
```
unity self-install
```
  can now replace the CLI while its background auth broker, or the identity server
```
unity open
```
  starts, is still running. They move the running copy aside and put the new one in its place without waiting for those processes to exit, and
```
unity self-update
```
  reports success only after the new version is in place.
- Installing an Editor or module no longer fails a size check on an installer that downloaded correctly. The release catalog lists each download’s size rounded down to a whole kilobyte, so a file whose real size wasn’t a multiple of 1,024 bytes was rejected.

1.0.0-beta.11

Release date: September 22, 2026

Security
- ```
unity bug
```
  now redacts the log files it collects before uploading them, masking home-directory paths, user names, tokens, and email addresses. Files you add with
```
--attachments
```
  are uploaded as-is.
- On Linux, extracting a
```
.pkg
```
  module no longer writes through an existing symlink, so an archive can't place files outside the install folder.
- On Linux, the hardened auth-broker tier now refuses to start when its token store or polkit policy is misconfigured, instead of serving tokens without the isolation it depends on.
Added
- ```
unity recompile
```
  checks that your scripts compile in a running Editor, without a full build. It lists each compiler error with its file and line, and exits 0 on success, 6 on compile errors, or 7 when no Editor responds.
- ```
unity docs <topic>
```
  opens the Unity documentation for a class or topic, matched to your project's Unity version. Use
```
--manual
```
  for the Manual instead of the Scripting API,
```
--search
```
  for search results,
```
--url
```
  to print the address, or
```
--editor-version
```
  to choose a version.
- ```
unity assets import <file.unitypackage>
```
  imports a
```
.unitypackage
```
  into a project. It checks the package and the project before starting the Editor, and prints the Editor's error summary when the import fails.
- ```
unity assets export <asset-path...> --output <file.unitypackage>
```
  exports assets and folders to a
```
.unitypackage
```
  . Dependencies are included unless you pass
```
--no-dependencies
```
  .
- ```
unity cloud org create <name>
```
  creates a Unity Cloud organization. Pass
```
--industry
```
  or pick one when prompted, and add
```
--set-default
```
  to switch to the new organization.
- ```
unity pipeline cloud-build
```
  and
```
unity pipeline automation
```
  list and inspect Unity Build Automation targets and builds, and Unity Pipeline Automation apps, pipelines, and jobs. These commands are read-only and mask secret values in their output.
- ```
unity mcp configure --server issue-tracker
```
  adds the Unity Issue Tracker MCP server to your AI client. Clients that can't use a remote server are skipped with a warning.
- ```
unity run --log-file <path>
```
  writes the Editor log to a file, including with
```
--command
```
  , and streams it to the console like
```
unity build
```
  . Add
```
--no-tail
```
  to write the file only.
- ```
unity editors prune
```
  now reports registered editors whose install folder is gone, and
```
--remove-missing
```
  removes them from your editor list.
- ```
install.sh
```
  and
```
install.ps1
```
  now install the latest beta when you don't choose a release channel, until the CLI has a stable release.
Changed
- Opt-in analytics and the anonymous usage count now record your project's Unity version, and opt-in analytics also record the editor version a command used. The anonymous usage count also notes whether the CLI ran from a terminal, an automated agent, or CI, and still carries no account, machine identifier, or file path.
Fixed
- When the Editor offers a matching status command for a job, such as
```
build_status
```
  for
```
build
```
  ,
```
unity job wait
```
  now says the job's command was dispatched and names that status command. It no longer reports success while the real work is still running.
- ```
unity build run
```
  now serves compressed WebGL builds with the correct headers, so they load in the browser. For browsers that don't accept the compression over plain HTTP, such as Firefox, it decompresses files as it serves them.
- Usage errors, such as an unknown option or a missing value, now follow
```
--format json
```
  and
```
--format ndjson
```
  and return the standard result envelope with the
```
INVALID_COMMAND_ARGS
```
  code. The exit code is still 2.
- ```
unity open
```
  no longer leaves Unity Connect half-configured in a project linked to Unity Cloud. This caused "Unity Connect configuration is invalid" errors, an Asset Store "Open in Browser" button that did nothing, and high Editor CPU use.
- On Windows, when
```
unity uninstall
```
  can't delete the editor folder, it now names the folder and tells you to close the Editor and check your permissions, instead of reporting an invalid uninstaller. JSON output uses the new
```
UNINSTALL_REMOVAL_FAILED
```
  error code, and read-only files no longer block removal.
- On Windows,
```
unity self-update
```
  no longer fails with "Unable to schedule the update helper (exit status 3)" when the folder you ran it from is deleted, renamed, or unmounted before the update completes.
- Running
```
install.ps1
```
  through
```
irm <url> | iex
```
  no longer closes your PowerShell window when the install fails.
- ```
install.sh
```
  now works on machines without
```
jq
```
  , including stock macOS. It also reports a clear error when the release manifest is damaged, such as when a captive portal or proxy replaces it.
- On Linux, module installs no longer fail with a checksum mismatch caused by incorrect checksums in Unity's release data. Until that data is fixed, Linux module downloads skip checksum verification, as Unity Hub does.
- Network requests, including those through a proxy, no longer fail with "address incompatible with the selected protocol" when a host has several addresses or a local proxy listens only on IPv6 (
```
[::1]
```
  ).
- On Windows, when a proxy auto-config (PAC) result lists a proxy per scheme, such as
```
http=proxy1:8080;https=proxy2:8443
```
  , each request now uses the proxy for its own scheme.
- ```
unity pipeline install
```
  and
```
unity pipeline upgrade
```
  no longer crash when
```
Packages/manifest.json
```
  lists
```
com.unity.pipeline
```
  more than once.
- ```
unity projects
```
  commands that change your project list now use the same database engine as Unity Hub. This fixes a rare write conflict on Linux, and a spurious lock error when the CLI and the Hub create the list at the same time.
- ```
cli-log.json
```
  no longer gets corrupted lines when two
```
unity
```
  commands write to it at the same time.
- ```
unity templates list
```
  now lists custom templates in the same order as Unity Hub.
- ```
unity status
```
  and the Pipeline connection error now recognize an OpenAI Codex sandbox on Windows, as they already did on macOS.

1.0.0-beta.10

Release date: September 14, 2026

Security and privacy

```
unity mcp configure
```
no longer follows a symlinked path component when it writes a client's config file. A
```
--local
```
write, as well as writes for VS Code and VS Code Insiders, whose configs are always project-local, now refuses a symlink at any path component instead of silently following it. Every client config write, both local and global, is now atomic.
On macOS, the CLI no longer re-signs a downloaded plugin or component whose code signature fails to verify, except for Unity Version Control's
```
cm
```
client, which the CLI now logs when it falls back. Any other component that fails verification now fails its download instead of running under an anonymous signature.
On Linux,
```
.deb
```
and
```
.rpm
```
installs of the hardened auth-broker tier now enforce it. Every token grant against the hardened tier requires real polkit consent before the isolated credential store is accessed, and the CLI now connects to the hardened tier's socket automatically after provisioning.
```
unity mcp configure <client> --dry-run
```
no longer prints your entire MCP config file, including other servers' credentials. It now previews only the entry it adds or changes.
```
unity mcp configure codex
```
no longer risks corrupting
```
config.toml
```
when it updates the Unity MCP server entry. It now refuses the update and asks you to edit the file manually when it can't verify that the match is safe. It also recognizes a quoted table name instead of duplicating it.
```
unity mcp configure codex
```
no longer risks corrupting the sandbox and network-proxy settings it relaxes for Codex. It refuses the entire update and asks you to edit the file manually when it can't verify that the match is safe.
The resident auth broker now signs every refresh-token request with a DPoP proof bound to an in-memory key. It correctly handles the server's nonce challenge and retry. Sign-in, token requests, and existing sessions are unaffected.
The auth broker's DPoP signing key is now hardware-backed when the machine supports it: the TPM on Windows, the Secure Enclave on macOS, and TPM2 through
```
tpm2-tools
```
on Linux. When no hardware-backed key is available, it falls back to the same in-memory key as before.
```
unity projects link vcs
```
no longer lets a project directory choose which program answers its credential lookup. The project's recorded Git identity is now read as inert data and reapplied through a lookup that always runs from a neutral directory. A repo-local
```
credential.helper
```
can no longer substitute its own credential.
The auth broker's token store is now sealed to the machine's hardware on every real sign-in: a non-exportable TPM key on Windows, TPM2 through
```
systemd-creds
```
on Linux, followed by DPAPI, the Secret Service, the Keychain, and a local key file as fallbacks. Earlier releases prepared this sealing, but the live broker still wrote to the plain OS keyring. Copying the store to another machine no longer yields a usable credential, and
```
unity doctor
```
reports the active tier.
The auth broker now protects itself against memory dumps as soon as it starts. It refuses
```
ptrace
```
and disables core dumps on Linux, disables core dumps on macOS, and suppresses the crash dialog on Windows. It also holds credential material in locked, zeroize-on-release memory instead of an ordinary string.
```
unity auth consumers
```
now reflects actual broker activity. Every token grant and refusal that reaches the broker's token-vending path is recorded in the audit trail that this command reads.
```
unity auth revoke
```
still only affects the revocation list; it does not yet stop that application from receiving a new token.
Every command's OAuth token read now goes through the resident auth broker instead of directly through the OS credential store. A command that needs a token starts the broker on demand if it isn't already running. The broker can remain idle in the background for up to two minutes before it exits. Set
```
UNITY_NO_AUTH_BROKER
```
to restore the previous direct-keyring behavior.
The resident daemon that handles Editor sign-in requests and the auth broker now verify a connecting peer's code signature by default on macOS and Windows. They refuse an unsigned or non-Unity-signed local process. The previous logging-only behavior is no longer documented because it weakened the peer code-signature check. Linux continues to log only by default.
When Unity Hub and the CLI are both signed in to the same account, their credentials now converge automatically without an additional sign-in prompt.

Installs and updates

```
unity self-update
```
now downloads through the CLI's regular download engine instead of a one-shot fetch. An interrupted download resumes from where it left off the next time you run
```
unity self-update
```
instead of starting over.
```
unity self-update
```
now prefers a Brotli-compressed download when the release provides one. The CLI verifies the compressed bytes against their own checksum, then verifies the decompressed binary again as before. A platform without a compressed artifact yet, falls back to the raw download.

AI and Editor integration

A mistyped command or flag now points you to
```
unity skill show
```
for a task-oriented CLI guide when no "Did you mean" suggestion appears. This applies to top-level commands and mistyped subcommands.
```
unity skill install
```
now also installs agent skills shipped with an installed plugin, alongside the CLI's own skill.
```
unity skill refresh
```
re-renders them from the plugin's current copy.
```
unity plugin install
```
and
```
unity plugin upgrade
```
point you to
```
unity skill install
```
when the installed copy ships with a skill.
```
unity command <name>
```
and
```
unity run --command <name>
```
no longer refuse a bare, argument-free invocation against an Editor whose Unity Pipeline package predates command-line binding. An invocation with arguments still refuses with the same message as before.
```
unity command <name> --result-only
```
prints only the Editor's own result value, without the CLI's
```
command
```
,
```
parameters
```
,
```
target
```
,
```
success
```
,
```
errors
```
, and
```
warnings
```
envelope fields. The option implies JSON output on its own and cannot be combined with
```
--detach
```
.
The
```
capture_game_view
```
and
```
capture_scene_view
```
tools in
```
unity mcp
```
now fall back to an OS-level screenshot of the entire desktop when the Editor's main thread does not respond in time, such as during a blocking dialog. The fallback captures the entire screen rather than the specific view and states this in an accompanying note.

Automation and CI

```
unity commands --format json
```
emits a machine-readable manifest of every command, subcommand, argument, and option. This lets agents and tooling discover the CLI surface without parsing
```
--help
```
.
```
unity commands
```
alone prints a compact grouped listing.
```
unity watch test
```
re-runs
```
unity test --affected
```
every time a project file changes. A debounce combines a burst of changes into a single run.
```
Library/
```
,
```
Temp/
```
,
```
Logs/
```
,
```
Build/
```
, and
```
obj/
```
are ignored by default. Use
```
--ignore <pattern>
```
to add more patterns. The command refuses to start under
```
--non-interactive
```
or in a detected CI environment.
A committed
```
ProjectSettings/UnityCliConfig.json
```
now declares
```
unity build
```
and
```
unity test
```
defaults for a project, including the target, output path, profile, timeout, test mode, report format, coverage, and more. This avoids repeating them in every invocation and CI workflow.
```
unity config resolve <key> [project]
```
prints the resolved value and the layer that supplied it: flag, environment variable, this file, global config, or the CLI default.

Build automation

```
unity build --create-profile <target>
```
creates a Unity 6+ Build Profile asset for a target platform and exits without building. This requires Unity 6000.0 or later, the same as
```
--profile
```
.
Unity Accelerator support is now available.
```
unity config accelerator <host:port>
```
persists an endpoint. A bare host defaults to port
```
10080
```
.
```
unity run
```
,
```
unity test
```
, and
```
unity build
```
inject the cache-server flags automatically.
```
--accelerator <host:port>
```
and
```
--no-accelerator
```
override or suppress the setting for an individual invocation.
```
UNITY_ACCELERATOR
```
takes precedence over the persisted setting but is overridden by the command-line flags.
```
unity diagnose accelerator
```
reports the resolved endpoint and whether it responds.
```
unity doctor
```
and
```
unity doctor --ci
```
now include a non-blocking Accelerator check.
```
unity build --list-targets
```
lists every valid
```
--target
```
value and exits. It identifies each target as zero-code or as requiring
```
--execute-method
```
or a Build Profile through
```
--profile
```
. It supports
```
--format human
```
,
```
--format tsv
```
,
```
--format json
```
, and
```
--format ndjson
```
.
```
unity build --list-profiles
```
lists a project's Build Profile assets and exits. Use it to discover platforms such as Meta Quest that build only through
```
--profile
```
.
```
BUILD_INVALID_TARGET
```
now directs you to
```
--profile
```
when you specify a target outside the classic catalog.
```
unity build run
```
launches the project's most recent recorded build without rebuilding. A successful
```
unity build
```
with a known output path now records the path, target, architecture, and Editor version. An
```
--execute-method
```
build without
```
--output-path
```
records nothing and keeps the previous record, so launch it with
```
--path <path>
```
instead. A desktop player launches natively. A WebGL build is served from a local, loopback-only HTTP server and opens in your default browser.

CLI behavior

```
unity command
```
and
```
unity cmd
```
now render
```
recompile
```
,
```
recompile_status
```
,
```
test_status
```
, and
```
run_tests
```
results as short, readable text in the default Result column instead of a compact JSON blob. Other Result cells and
```
--format json
```
,
```
--format ndjson
```
, and
```
--format human
```
output remain unchanged.
```
unity command --project-path <path>
```
now starts faster by skipping work it does not need for that invocation, such as display-language detection.

Project management

```
unity context
```
saves and applies named bundles of your account, default organization, default cloud project, default Editor, and install path.
```
unity context save <name>
```
records the current set,
```
unity context use <name>
```
applies one, and
```
unity context list
```
and
```
unity context current
```
show what exists and what is active. Applying a context is all-or-nothing. Switching to a context clears any of the five settings it does not pin, except the account.
```
unity open --wait
```
, as well as
```
unity projects open --wait
```
and
```
unity projects upgrade --wait
```
, blocks until the launched Editor exits and reports its actual outcome. It exits with
```
6
```
on failure or
```
0
```
on a clean exit. This option is currently available only on macOS and Linux. Windows refuses it with exit code
```
2
```
instead of silently falling back to the previous bounded watch.
```
unity open
```
,
```
unity projects open
```
, and
```
unity projects upgrade
```
now report when the launched Editor was killed by a signal instead of reporting success, both during the ordinary bounded watch and with
```
--wait
```
.
```
unity assets inspect <file.unitypackage>
```
lists the contents of a
```
.unitypackage
```
, including the asset path, GUID, size, and whether a preview image is bundled. It does not import the package and does not require an installed Editor or an open project. It streams the archive, so it uses constant memory even for multi-gigabyte packages.

Source control

```
unity vcs blame <scene|prefab>
```
reports who last changed each GameObject and component in a Unity asset, along with the commit, author, and date. Use
```
--object <name>
```
to narrow the result to one object,
```
--field <name>
```
to narrow it to one serialized field,
```
--at <ref>
```
to blame as of another revision, and
```
--max-revisions <n>
```
to limit how far back the command searches.

Licensing

```
unity license status
```
now reports
```
floatingServer
```
, the licensing server configured for the machine, and
```
machineId
```
, the identity that the licensing client reports to it. Use these values to match a lease record when a floating seat appears stuck. Both values appear in
```
--format json
```
and
```
--format ndjson
```
output, and in human-readable and
```
tsv
```
output only when a floating server is configured.

Issues fixed

On Windows on Arm,
```
unity
```
no longer misreports a working Git installation as missing or broken.
```
unity doctor
```
and
```
unity vcs providers
```
are fixed by the same change.
A signed-in user is no longer reported as signed out solely because the resident auth broker rejects the connection under peer-authentication enforcement. The CLI now falls back to the locally stored session instead of treating the rejection as a sign-out.
The CLI no longer reports that no Unity Editor is reachable when it runs inside WSL and the Editor runs on the Windows host.
```
unity projects close
```
now confirms the exit over the same channel instead of signaling a process ID that could belong to another process.
```
unity status
```
now identifies the WSL networking setting to change when the port does not respond.
A running Editor whose project layout hides the Unity Pipeline package, such as a Multiplayer Play Mode virtual player's partial clone or a
```
Packages
```
folder reached through a symlink or permissions issue, is no longer reported as unreachable or missing by
```
unity status
```
or
```
unity pipeline list
```
.
Concurrent writes to the shared
```
user-settings.json
```
no longer drop each other's changes. Settings writes now take a short cross-process lock on the file.
The CLI no longer mistakes an unrelated process for a running Unity Editor or Player when a stale connection descriptor names a recycled process ID. Discovery now also compares the process start time with the descriptor's timestamp.
Commands that communicate with a running Unity Editor, including
```
unity command
```
,
```
unity job
```
, and
```
unity list
```
, now identify an AI coding agent's sandbox as a possible cause of a connection refusal, alongside the original "make sure Unity Editor is running" message.
Sign-in failures where the OS keyring accepts a write but does not retain it are now logged and diagnosable, with a message that distinguishes them from an outright write failure.
The CLI's Editor identity daemon no longer deletes a Hub socket file when it stops on macOS and Linux.
Commands that communicate with a running Editor over loopback, including
```
unity command
```
,
```
unity status
```
, and
```
unity job
```
, no longer resolve the OS proxy configuration up front. They resolve it only when a command first needs it.
```
unity status
```
no longer reports "no instances" when a Pipeline discovery file exists but the current process cannot read it, such as when a sandboxed AI agent tool runs the CLI as a separate account. It now identifies the actual cause and specifically identifies a sandboxed agent when detected.
```
unity templates pack
```
and
```
unity templates create
```
on Windows now also check for a Windows byte-range lock on a project's
```
Library
```
cache before copying it, alongside the existing Linux protection.
```
unity self-update
```
and
```
unity self-install
```
on Windows now ask a resident Editor identity server daemon to release the binary before replacing it, just as they already ask the resident auth broker.
```
unity close
```
and
```
unity projects close
```
now also check with the daemon immediately after closing an Editor instead of waiting through its full idle window.
```
unity mcp
```
no longer leaves an agent session with zero Unity tools for its entire lifetime when the client connects before an Editor starts. The server now declares support for tool-list change notifications and notifies the client when the catalog changes.
```
unity doctor
```
's credential-store check now exercises the Windows Credential Manager chunking path that real sign-in tokens use instead of testing only a small value.
A chunked credential write that the OS credential store accepts but does not persist no longer leaves stale entries or destroys the previous sign-in. The CLI now verifies the write by reading it back, rolls it back on failure, and automatically cleans up entries left by an earlier version.
```
unity install
```
no longer fails with an
```
INSTALL_FAILED
```
database error when the shared install-state database was created by an older Unity Hub or CLI. The CLI now applies the same schema update as Unity Hub.
A declined or blocked Windows elevation prompt no longer generates a crash report. The same applies to an incorrect installer or uninstaller format, an unsafe install path, or an install location that you cannot write to. These and similar states also no longer suggest
```
unity bug
```
.
```
unity status
```
no longer reports a Unity Editor as
```
ready
```
while it is still starting. It now probes the Editor's main thread directly and reports
```
starting
```
instead in human-readable,
```
--format json
```
,
```
--format ndjson
```
, and
```
--format tsv
```
output, with a matching exit code.
```
unity test
```
no longer reports a confusing "results ... could not be converted to JUnit" message when the Editor exits cleanly without writing a new results file. It now distinguishes a narrowed run that matched nothing, using
```
--filter
```
,
```
--shard
```
,
```
--rerun-failed
```
, or
```
--affected
```
, from a genuine problem and always fails the run instead of risking a false pass.
```
unity bug --share-project
```
no longer bundles an entire Unity project into the report. The shared copy is now limited to 1,000 files and warns when the limit truncates the copy.
Crash reports no longer contain invisible marker characters that the CLI uses to style command hints in the terminal.
```
unity vcs uvcs review list
```
,
```
comments
```
,
```
reply
```
, and
```
resolve
```
now work when you are signed in. Previously, all four commands failed with a sign-in error even immediately after sign-in because they did not exchange your credential for the short-lived token required by the review service.
Commands that access Unity Cloud no longer fail spuriously the first time you run one after your sign-in has been idle. A renewed credential is now used within the same run. This affected
```
unity cloud project list
```
,
```
unity projects create
```
,
```
unity projects link vcs
```
, and other commands.
```
unity install
```
,
```
unity install-modules
```
, and
```
unity editor module add
```
no longer try to install a bundled Visual Studio module when a compatible version is already installed. The CLI now checks the actual installation state on Windows and macOS and reports Visual Studio as not installed on Linux.
```
unity command --caller plugin
```
no longer misreports Unity's own third-party-agent plugin as
```
other
```
.
Concurrent installs can no longer bypass the single-install lock while an earlier install is still finishing. The CLI now reclaims a lock only when its holder's heartbeat is stale and its process has exited. The check and claim now occur in a single transaction.
```
unity mcp configure codex
```
now also relaxes Codex's sandbox network policy, not only the MCP server entry. This allows
```
unity mcp
```
and direct
```
unity command
```
calls from Codex's shell tool to reach the Editor through localhost.
```
unity status
```
,
```
unity editors running
```
, and
```
unity command
```
no longer report a healthy Unity Editor as unreachable immediately after recompilation. Each command now retries once with a refreshed token before it reports the Editor as unreachable.
On Windows,
```
unity self-install
```
and
```
unity self-update
```
no longer fail or silently defer to a background swap that cannot complete when a resident background helper holds the installed binary open. Both commands now ask the helper to release the binary first.
Several internal helper processes, such as the Windows installer helpers and the WSL path translator, no longer hang when the spawned tool writes heavily to both stdout and stderr at the same time.
```
unity install <version> -a x86_64
```
no longer reports "No editor version matched" on an Apple Silicon Mac that supports Rosetta 2. The install catalog now offers
```
x86_64
```
on Apple Silicon through macOS 27.
```
unity plugin install
```
,
```
unity plugin upgrade
```
, and
```
unity plugin remove
```
no longer race with each other, Unity Hub's background module updates, or the native Hub licensing-client install into deleting a build that another process just finished installing. A lock left by a crashed process is now reclaimed automatically.
```
unity projects link vcs
```
and
```
unity projects create --vcs …
```
now record a per-project Git identity that remains effective even when an organization-wide credential pin exists, by also saving a URL-scoped form that Git ranks ahead of the organization-wide credential.
```
unity status
```
no longer sends a crash report or suggests running
```
unity bug
```
when every discovered Unity Editor instance is unreachable.
```
unity license activate
```
now points you to
```
unity doctor
```
when a sign-in or session failure occurs on a macOS machine that has already signed in. The message identifies a possibly locked keychain instead of only telling you to sign in again.
Commands that automatically discover an Editor without
```
--project-path
```
, including
```
unity command
```
and
```
unity run --command
```
, no longer report "No Unity Editor instances found" when a healthy Editor has a Unity Pipeline package that is too old to parse the command line. They now report the specific error that
```
--project-path
```
already reports.
On Windows, the CLI no longer crashes with
```
Decoder ran into invalid data
```
when an HTTP response is corrupt or its embedded translation bundle cannot be decoded. Both cases now use the CLI's normal error handling.
```
unity open
```
,
```
unity projects open
```
, and
```
unity projects upgrade
```
no longer launch the Editor inheriting the CLI's working directory, which could crash the Editor if that directory became unreadable. The Editor now always launches from the OS temporary directory and falls back to the previous behavior if that directory is unusable.
```
unity install --resume
```
can now recover an interrupted module download, such as an SDK component, in addition to an interrupted Editor installer.
```
unity self-install
```
on Windows can now target a directory other than
```
%LOCALAPPDATA%\Unity
```
by setting
```
UNITY_CLI_HOME
```
, matching macOS and Linux.
```
install.ps1
```
honors the same variable.
The long-lived Editor identity daemon started by
```
unity open
```
no longer stops reporting a signed-in Editor after its auth broker restarts or exits after remaining idle. It now detects a stale broker connection and reconnects automatically.
A signed-in user is no longer told to sign in again when the auth broker has a temporary problem reading the access token, such as during a broker restart. Only an authoritative refusal now reports a sign-in or session-expired message. Other issues ask you to try again while leaving your session unchanged.
A signed-in Mac user is no longer told to sign in again when the macOS Keychain refuses to read an existing credential, such as after Unity Hub signed in first. The session now reports as unresolved and points you to
```
unity doctor
```
instead of the generic sign-in prompt.
On macOS, a future CLI update can no longer trigger an unexpected Keychain prompt or a forced re-sign-in because the identifier the CLI uses for Keychain access control is now fixed.
```
unity projects list
```
and other project-registry reads no longer fall back to a stale or empty backup copy of the registry just because another process closed the shared project database last.
The Linux
```
.deb
```
and
```
.rpm
```
packages now install the hardened auth-broker tier's assets: the
```
unity-auth-broker
```
systemd units, the
```
unity-broker
```
system account, and the polkit consent policy. These assets existed in the package for months but were not referenced.
```
unity command <name> --format json
```
no longer prints two separate
```
success
```
fields. The envelope now contains exactly one
```
success
```
field, derived from the same check the CLI uses to determine whether the command fails.
```
unity vcs setup
```
now shows the equivalent invocation for a Windows path operand instead of reporting that no shell quoting reproduces the run, for almost every real Windows run.
Git-owned files that the CLI rewrites directly, including
```
.git/config
```
,
```
.git/packed-refs
```
, and
```
.git/HEAD
```
during
```
unity projects link vcs
```
and
```
unlink vcs
```
, no longer race with a concurrent
```
git fetch
```
,
```
git gc
```
, or another CLI invocation that accesses the same file. Each write now takes the file's own lock and commits through an atomic rename.
```
unity install
```
now retries a failed Editor or module download instead of failing the entire install after the first transient network error. It uses the same bounded retry policy as
```
unity install-modules
```
, controlled by
```
UNITY_INSTALL_RETRIES
```
.
```
unity mcp configure continue
```
no longer writes an entry to
```
~/.continue/config.json
```
, which Continue no longer reads. It now prints setup instructions for
```
~/.continue/config.yaml
```
instead.

1.0.0-beta.9

Release date: September 08, 2026

Installs and updates
- ```
unity install
```
  and
```
unity install-modules
```
  now use
```
--child-modules
```
  /
```
--no-child-modules
```
  , which matches
```
unity editor module add
```
  . The previous camelCase options (
```
--childModules
```
  /
```
--no-childModules
```
  ) and the
```
--cm
```
  /
```
--no-cm
```
  shorthand continue to work.
- ```
unity install --list-components
```
  is now
```
unity install --list-modules
```
  , which matches the
```
-m
```
  /
```
--module
```
  terminology. The previous name remains available as a hidden alias.
- ```
unity modules list
```
  and
```
unity install --list-modules
```
  now label their last column
```
Aliases
```
  instead of the downloader name. The
```
--format json
```
  field also changes from
```
downloaderName
```
  to
```
aliases
```
  .
- The CLI now warns you when both a self-installed
```
unity
```
  and a Homebrew-managed version appear on your
```
PATH
```
  . In this state,
```
which unity
```
  continues to resolve to the self-installed copy, while
```
brew upgrade
```
  updates the Homebrew copy, so the versions can diverge. The background update check now directs you to
```
unity self-uninstall -y
```
  to remove the self-installed copy and let Homebrew manage updates.
AI and Editor integration
- ```
unity skill show
```
  now prints the CLI's agent skill to standard output without installing anything, so you can read the skill without changing the filesystem. Use
```
--path <file>
```
  to print a reference file,
```
--list
```
  to list all files in the skill, or
```
--format json
```
  to return each file's content with its index.
- ```
unity --help
```
  now mentions the agent skill on its last line and directs you to
```
unity skill show
```
  and
```
unity skill install <client>
```
  .
Automation and CI
- ```
unity plugin upgrade
```
  now compares the installed version directly with the plugin registry instead of estimating staleness from a checksum. If your installed version is newer than any version the registry currently admits, the CLI reports that state separately instead of reporting an indeterminate result. If the installed version has since been yanked,
```
upgrade
```
  downgrades to the newest non-yanked version and explains why.
- ```
unity plugin changelog <id>
```
  now displays a managed tool's release notes, rendered from Markdown and paged like
```
unity changelog
```
  . Use
```
--version <version>
```
  to display notes for a specific version, or
```
plugin upgrade --changelog
```
  to display the full notes before the upgrade.
- A global
```
--color <auto|always|never>
```
  flag now controls colored output directly. Use
```
--no-color
```
  as shorthand for
```
--color never
```
  . The flag affects only human-readable output and no longer relies only on the
```
NO_COLOR
```
  and
```
FORCE_COLOR
```
  environment variables.
- ```
unity version
```
  is a new command that displays the CLI version, release channel, commit, platform, architecture, and runtime in any output format.
```
--version
```
  also honors
```
--format
```
  . A bare
```
unity --version
```
  continues to print only the version string.
- ```
unity doctor
```
  now lists the CLI's bundled third-party components with their versions and SPDX license identifiers, along with the .NET runtime.
- A generic
```
unity config get|set|list|unset <key>
```
  interface now provides access to the CLI's existing settings:
```
proxy
```
  ,
```
proxy.bypass
```
  ,
```
accelerator
```
  , and
```
update-check
```
  . You can read and write these settings by key as well as through their existing subcommands. When you read back a proxy URL with embedded credentials, the CLI redacts the credentials.
Security and privacy
- The auth broker now seals its token store to the machine it was written on. On Windows, it uses the TPM and falls back to DPAPI. On Linux, it uses TPM2 through
```
systemd-creds
```
  and falls back to the Secret Service keyring. On macOS, it uses the Keychain. A local key file provides the fallback on all platforms.
```
unity doctor
```
  now reports which protection is active.
- ```
unity auth consumers
```
  now lists the applications that have used your Unity sign-in on the current machine. Use
```
unity auth revoke <application>
```
  to prevent an application from using it. Use
```
--restore
```
  to undo a revoke.
- The CLI now sends one
```
cli telemetry
```
  event per run so Unity can count total usage, including runs that never display a consent prompt, such as CI and agent runs. The event contains no user, machine, or session identifier and no consent state. It contains only the tool, CLI version, and whether the run appears to be a CI run. Set
```
UNITY_NO_CLI_INVOKED_TELEMETRY=1
```
  to disable it.
Build automation
- ```
unity test --affected --since <ref>
```
  now runs only the tests that a change can affect, based on the impact graph from
```
unity vcs affected
```
  . Selection is opt-in, and results go to
```
test-results.affected.xml
```
  so the command does not overwrite a full-suite report. The command also identifies changes that it cannot prove are unaffected. For example, a change to a non-code file still runs the full suite. Use
```
--affected-compare
```
  to run every test and report which tests the selection would skip and how many of those tests would fail. You can use this result to measure the false-negative rate for your project before you rely on affected-test selection.
Issues fixed
- Sign-in now persists on Linux machines without a Secret Service daemon, such as headless WSL2 environments, containers, and bare CI runners. Previously, the CLI reported a successful sign-in but appeared signed out on the next command. The same issue also caused
```
unity license activate --serial
```
  and
```
unity projects new
```
  to fail their licensing handshake on these machines.
- The CLI no longer sends failures caused by your machine or network to anonymous crash reporting. These failures include unreachable hosts, DNS failures, dropped TLS connections, truncated downloads, locked files, and read-only file systems. The CLI still sends genuine defects.
- ```
unity cache key
```
  no longer crashes on Windows when the project path points to a file instead of a directory.
- On Windows,
```
unity pipeline list
```
  and
```
unity status
```
  no longer report that no Editor is running when one is running. Previously, certain characters in an unrelated background process's command line could corrupt the process query for every process on the machine. Both commands now warn you when the process check fails instead of reporting an empty result.
- On Windows,
```
unity skill install
```
  now updates an earlier installation when the recorded and computed installation paths differ only in slash direction or letter casing.
- ```
unity doctor
```
  no longer hangs or displays an unexpected keychain dialog when it checks or reads your credential store on macOS and the Keychain requires a response that no user can provide.
- ```
unity templates create
```
  and
```
unity templates pack
```
  now tell you when a project is open in an Editor instead of returning an opaque error. On Linux, the CLI previously allowed you to pack an open project and could capture its asset cache during a write. The CLI now refuses these packs.
- ```
unity install 6000.5
```
  and other partial versions, including a bare major version, now work after the release line reaches end of life. A partial version now resolves to the newest release in that line, whether the release exists in the current catalog or the archive.
- ```
unity open
```
  ,
```
unity projects open
```
  , and
```
unity projects upgrade
```
  now report a failure when the Editor they start exits with an error instead of always reporting success.
- ```
unity build
```
  now tells you when a project is already open in an Editor instead of reporting what appears to be a licensing error.
- Release notes that
```
unity changelog
```
  and
```
unity self-update --changelog
```
  render now retain bold and italic styling when the same line contains a link.
- On Windows,
```
unity open <name>
```
  and
```
unity projects open <name>
```
  no longer print paths that mix forward and backslashes when the registered folder is not a valid project.
- A module now fails once with a clear explanation when its published release data does not match the file that the download server provides. The CLI no longer retries the same download three times.
- Releasing a lock that the CLI holds around its shared state files can no longer delete another process's lock when the lock directory cannot be renamed on the machine.
- ```
unity projects verify
```
  and the
```
unity vcs hooks
```
  pre-commit gate no longer report a missing
```
.meta
```
  file for files inside native plug-in folders (
```
.bundle
```
  ,
```
.framework
```
  ,
```
.androidlib
```
  ,
```
.plugin
```
  ). These folders do not have their own
```
.meta
```
  files.
```
unity vcs status
```
  no longer reports these files either.

1.0.0-beta.8

Release date: September 02, 2026

This release supersedes 1.0.0-beta.7, which reached the beta channel and was withdrawn the same day. The changes from beta.7 are included in this section. If you upgraded directly from 1.0.0-beta.6, you receive the complete set of changes.

Breaking changes
- ```
UNITY_NO_PARAM_VALIDATION
```
  is retired and has no effect. Argument name checking no longer uses a catalog that the CLI fetches, so there is nothing to disable. Remove it from your scripts and CI jobs.
- ```
unity command
```
  and
```
unity run --command
```
  now pass the arguments you type to the Editor without parsing them, and the Pipeline package binds them. If a script relies on the CLI to rewrite or reject those arguments, you might need to update the script.
- New projects created with
```
unity projects create
```
  are cloud-enabled by default. Pass
```
--no-cloud
```
  , or set
```
UNITY_NO_CLOUD
```
  , to opt out.
- An Editor that exits with code
```
198
```
  is now reported as a licensing failure instead of a bare exit code.
- A
```
unity-close
```
  executable on your
```
PATH
```
  no longer runs as
```
unity close
```
  . Because
```
close
```
  is now a first-party command, it takes precedence and a binary on
```
PATH
```
  can no longer shadow it. If you have such a plugin, rename it. Otherwise, the CLI no longer finds it with no error.
Source control
- Added
```
unity vcs
```
  , a command group for working with a Unity project under version control.
```
unity vcs setup
```
  takes a project from nothing to a pushed first commit without any flags.
```
unity vcs status
```
  and
```
unity vcs sync
```
  support day-to-day workflows:
```
unity vcs status
```
  groups changes by their meaning in Unity and identifies
```
.meta
```
  file problems, while
```
unity vcs sync
```
  refuses to pull while an Editor has the project open and reports the expected reimport.
- ```
unity vcs doctor
```
  audits repository settings required for Unity to work under version control, including UPM package reproducibility. Use
```
--fix
```
  to repair everything the command can repair in one pass.
- ```
unity vcs merge-setup
```
  makes Unity scene and prefab merges work in a repository in one command and continues to work after an Editor upgrade.
- ```
unity vcs conflicts
```
  ,
```
unity vcs explain
```
  , and
```
unity vcs resolve
```
  turn a Unity merge conflict from a list of numeric IDs into actionable information.
- ```
unity vcs diff <path>
```
  reads a scene or prefab change by GameObject and component name instead of
```
fileID
```
  .
```
unity vcs summarize --since <ref>
```
  turns an entire branch into a readable summary.
- ```
unity vcs affected
```
  reports the impact of a change in Unity terms instead of Git terms. For example, it reports which prefabs reference a changed texture and which scenes reference those prefabs.
- ```
unity vcs switch <branch>
```
  changes branches without causing unnecessary reimports and tells you the expected cost before it switches branches.
- ```
unity vcs hooks install
```
  adds Unity integrity checks to your commits. Use
```
uninstall
```
  to remove them.
- ```
unity vcs git worktree add <branch> [path]
```
  makes a Git worktree usable with a Unity project.
```
unity vcs git worktree remove <path>
```
  removes it.
- ```
unity vcs git migrate-lfs
```
  finds binaries already committed to Git history and provides the exact
```
git lfs migrate import
```
  command to move them into LFS.
- ```
unity vcs uvcs locks
```
  tells you who holds a Unity Version Control lock and marks locks that cover files you have already changed.
```
unity vcs uvcs changesets
```
  lists changesets.
- ```
unity vcs providers
```
  reports which Git providers this machine can reach. It reports whether
```
git
```
  ,
```
git-lfs
```
  ,
```
gh
```
  ,
```
glab
```
  ,
```
tea
```
  ,
```
bkt
```
  , and
```
az
```
  are installed and their versions, as well as which hosts each tool has a session for and which account the session uses.
- Repository creation now works with Bitbucket and Azure DevOps, in addition to GitHub, GitLab, and Gitea.
```
unity projects create --vcs <host>
```
  and
```
unity projects link vcs
```
  create the remote through Bitbucket's
```
bkt
```
  or Microsoft's
```
az
```
  , including Bitbucket Cloud and Data Center. Azure DevOps repositories belong to an organization and project, so
```
--vcs-namespace
```
  accepts
```
organization/project
```
  . Azure DevOps does not support per-repository visibility, so the CLI rejects
```
--visibility
```
  and descriptions instead of silently ignoring them.
- You can now sign in to GitHub or GitLab with your browser instead of creating a personal access token manually. If you use a token, the prompt lists the exact scopes you need and links to the provider page that creates a token with those scopes selected.
- ```
unity projects link vcs
```
  and
```
unity projects unlink vcs
```
  no longer require the project path. If a link fails partway through, run the command again to resume it instead of receiving an
```
ALREADY_LINKED
```
  error or creating a second repository. Use
```
--rollback
```
  to undo a partially completed link. If a repository already has a remote, the CLI adopts it instead of refusing the link.
- If
```
git-lfs
```
  is missing, the CLI no longer tells you to install it manually. The CLI offers to install it through your platform's package manager and installs it if you confirm. The CLI does not install anything without your confirmation. If the command cannot prompt you, it prints the exact command instead.
- ```
unity vcs uvcs review
```
  reads code review comments from the Unity Version Control GUI and lets you respond to them. Previously, these comments were available only in the GUI, so you had to restate a reviewer's notes about specific files and lines before a command-line workflow could act on them.
```
review list
```
  finds a review and lets you narrow the results with
```
--changeset
```
  ,
```
--branch
```
  , or
```
--status
```
  .
```
review comments
```
  reads the review and reports each comment's file, line, text, author, timestamp, type, threading parent, and resolution status.
```
review reply
```
  replies to a comment, and
```
review resolve
```
  records which changeset addressed it.
Project management
- ```
unity cloud project
```
  now has the same default-project commands as the organization commands:
```
set-default
```
  ,
```
current
```
  , and
```
clear-default
```
  . Commands that require a Unity Cloud project use the default project when you do not specify one.
- ```
--cloud-project
```
  and
```
unity cloud project set-default
```
  now also accept a project's Genesis ID.
```
unity cloud project list
```
  displays this value in its ID column alongside the project UUID and name.
- ```
unity close <path-or-name>
```
  closes the Unity Editor that has a project open and is now available in released builds. The capability previously existed as
```
unity projects close
```
  but was registered only when
```
HUB_ENV=development
```
  was set, so it was unavailable outside Unity.
```
close
```
  is now a top-level command as well as
```
unity projects close
```
  , matching the existing
```
open
```
  command. Neither command saves your work. By default, the command asks the Editor to exit, which it does immediately without prompting. Use
```
--force
```
  to signal the process instead. The CLI uses
```
--force
```
  only when you specify it. Closing a project that no Editor has open succeeds without an error. If an Editor has the project open but the project does not include
```
com.unity.pipeline
```
  , the error names the package and the
```
unity pipeline install
```
  command that adds it.
```
unity projects logs
```
  remains development-only.
Installs and updates
- ```
unity install
```
  and
```
unity install-modules
```
  now request administrator permission at the start of the command instead of partway through. This prevents an unattended install from waiting for a dialog after a long download. If you decline, the command fails immediately with
```
ELEVATION_CANCELLED
```
  or
```
ELEVATION_FAILED
```
  , and nothing is downloaded or written.
- ```
unity upgrade
```
  shows download progress instead of a spinner, identifies the upgrade when you provide an argument, and explains what to do when a SHA-256 check fails.
- ```
unity install <version> --changeset <changeset>
```
  can now install an Editor that has been promoted but not yet published. It also reports an unresolvable changeset immediately instead of waiting for a minute and a half.
- ```
unity install --format json
```
  now prints a result envelope on success. Previously, it printed nothing and exited with
```
0
```
  , so a script could not distinguish a completed install from a crashed process. The envelope matches the result that
```
--format ndjson
```
  already reports.
- ```
unity install --resume
```
  now honors
```
--force
```
  , so a forced resume reuses an already downloaded payload instead of downloading it again. If the Editor is already installed and you do not pass
```
--force
```
  , the resume reports why it stopped in every output format.
- The command that updates the CLI is now
```
unity self-update
```
  .
```
unity upgrade
```
  continues to work as an alias, so nothing you have scripted or documented breaks. The old name was the only CLI command called
```
upgrade
```
  that did not upgrade a project or an Editor, unlike
```
unity editors upgrade
```
  ,
```
unity projects upgrade
```
  , and
```
unity plugin upgrade
```
  . The machine-readable output also changes:
```
--format json
```
  and
```
ndjson
```
  now report
```
"command": "self-update"
```
  instead of
```
"command": "upgrade"
```
  .
AI and Editor integration
- ```
unity skill install
```
  for VS Code, Cursor, Windsurf, and Cline now installs a real Agent Skills directory. Each client also has a user-global target for the first time.
- ```
unity skill install <client> --local
```
  now also installs the agent skill included with your project's
```
com.unity.pipeline
```
  package. A resolved package lives under
```
Library/PackageCache
```
  , which AI clients do not search for skills. A project-local install therefore copies the skill next to the
```
unity-cli
```
  skill. A project without the package behaves as before.
- ```
unity mcp
```
  no longer reports every numeric, array, and structured tool parameter as a string.
Automation and CI
- Long human-readable listings now use a pager in a terminal, similar to
```
git log
```
  , instead of filling your scrollback. Set
```
UNITY_PAGER
```
  or
```
PAGER
```
  to choose a pager, or pass
```
--no-pager
```
  to disable it.
- Added
```
unity plugin install
```
  ,
```
unity plugin remove
```
  , and
```
unity plugin upgrade
```
  to manage tools that Unity downloads for you.
```
unity plugin list
```
  reports the installed tools.
```
unity doctor
```
  also shows these components in its own section.
- ```
unity doctor
```
  now checks whether the machine's credential store can store a sign-in and reports which backend it selected.
- ```
unity uvcs
```
  ,
```
unity cm
```
  , and
```
unity ugs
```
  now pass everything after the alias directly to the tool's binary, so the tool receives its own flags unchanged. For example,
```
unity uvcs status --format json
```
  passes
```
--format json
```
  to the Unity Version Control client instead of letting the CLI consume it as a global
```
--format
```
  option.
```
uvcs
```
  and
```
cm
```
  both run the Unity Version Control client, while
```
ugs
```
  runs the Unity Gaming Services CLI. Only the first token counts, so
```
unity --format json uvcs
```
  is parsed as a standard CLI invocation and reports the correct usage.
Security and privacy
- Commands that look for a running Editor now identify it by the executable that the operating system reports instead of the process name.
- On a machine without Unity Hub, the Unity Version Control client that the CLI downloads now uses the version pinned by the CLI instead of remaining on the first version it fetched.
- If you opt in to CLI analytics, the CLI now associates your usage with your Unity account while you are signed in. Usage events also record which project they ran in. The project is identified by an opaque ID, never by a file path. The CLI records nothing unless you opt in. Both values are absent when a command runs outside a Unity project.
- The first-run analytics question now uses an arrow-key list instead of a typed
```
y
```
  /
```
n
```
  , matching the other questions in the CLI.
Issues fixed
- On Windows,
```
unity install
```
  no longer reports a successful install as failed when you are not an administrator. Installing to a location that requires elevation, left the version folder writable only by administrators. The CLI then tried to register the Editor without elevation, reported the install as failed, and exited with
```
INSTALL_FAILED
```
  even though the Editor had installed correctly. This issue caused the withdrawal of 1.0.0-beta.7.
- ```
unity editor module refresh <version>
```
  now repairs an Editor that an earlier install left unregistered. Use this command if you encountered the issue above before this release.
- Installing a module into an Editor in a protected folder now works. Language packs and archive-based modules, such as the Android NDK and platform support modules, previously unpacked without elevation and failed.
- On Windows, installs no longer fail with
```
Access to the path is denied
```
  on machines where the lock directory's parent does not allow new names. A failed Editor install also no longer leaves the new version's folder behind.
- ```
unity auth login
```
  no longer reports success on a headless Linux machine when no session exists afterward. It also no longer fails on macOS when the keychain slot it writes was created by a different code identity. Under WSL, it opens the sign-in page in your Windows browser again.
- Backticks in a path, project name, Editor version, or any other value you type are no longer deleted from the CLI's messages.
- ```
unity test
```
  now runs on a Linux machine without a display server. It also refuses to run on a project that is already open in an Editor instead of starting a batch Editor that cannot acquire the project lock.
- Opening a project with
```
unity open
```
  on Linux no longer prevents you from attaching a debugger. The CLI previously launched the Editor through a version-named link, which renamed the process and prevented Rider and the VS Code debugger from finding it.
- ```
unity projects clean
```
  no longer deletes a project's
```
Library
```
  ,
```
Temp
```
  , and
```
obj
```
  folders when it cannot determine whether an Editor has the project open.
- On Linux,
```
unity install-modules
```
  now puts the iOS, WebGL, Linux-IL2CPP, and Linux-Server playback engines where the Editor expects them.
- Templates created from a Unity 6000.6.0a4 or newer project no longer produce hundreds of spurious warnings in every project created from them.
```
unity templates pack
```
  also no longer copies content from outside the project into the template.
- The CLI now reports analytics again for users who have opted in. A crash no longer generates one report per language
- Sixteen command surfaces previously printed English regardless of your display language, even though all the strings they printed were already translated. Relative timestamps in
```
unity projects list
```
  and the Kind column in
```
unity plugin list
```
  now use your display language.
- ```
unity bug --share-project
```
  no longer uploads a Unity 6000.6+ project's
```
Library/DataStore
```
  folder.
- ```
unity projects remove
```
  and other commands that find a project in the Hub registry by path no longer miss a project when its path uses different capitalization.
- ```
--no-pager
```
  is accepted again on every command and in either position.
```
unity editors prune --remove --format github
```
  also no longer asks for confirmation in a terminal.
- ```
unity install <arg>
```
  now rejects an argument that is not a Unity version with an
```
INVALID_VERSION
```
  error before sending it to the release catalog.
- Crash reporting no longer creates a report for failures that the CLI did not cause.
- Commands no longer stall after they finish. When a profile was signed in and opted in to analytics, every command resolved the user ID from the OS keyring on the main thread after printing its result. One measured non-interactive run took 40 seconds, and the operation could take an unlimited amount of time. As a result, a headless, CI, or SSH machine could wait indefinitely. The CLI now performs this read at most once per process and on a background thread, and only when it has data to send. If the read does not return in time, the CLI abandons it and sends the batch anonymously, as it does for a signed-out run.
- When a connected Editor has a
```
com.unity.pipeline
```
  package that is too old to run a command or detached job, the error now names the package version that provides the required behavior instead of only telling you to run
```
unity pipeline upgrade
```
  .
```
unity pipeline upgrade
```
  resolves the latest version available in the registry. If that version is still older than the version required by the CLI, the upgrade previously reported success and the command failed without explaining why. This issue caused the withdrawal of 1.0.0-beta.7.
- Failures caused by the state of your machine no longer ask you to file a bug against the CLI. Previously, 23 conditions that were neither CLI defects nor errors in what you typed, such as a missing
```
tar
```
  executable, an Editor that was no longer at its registered path, or another
```
unity
```
  executable already owning your
```
PATH
```
  , ended their error block with a request to run
```
unity bug
```
  . The rest of the error block remains unchanged: the error, its code, the log location, and instructions for rerunning with
```
--verbose
```
  .
- ```
unity install-path
```
  no longer reports the default install path when it cannot read your configured path. The path is stored in
```
secondaryInstallPath.json
```
  , which the Hub and CLI share behind one advisory lock. Previously, a failed read was treated as if no custom path existed, so the CLI printed the platform default with exit code
```
0
```
  even though your Editors lived elsewhere. An install that started during that window could then use the wrong root. The CLI now distinguishes these two states and retries a read once if it loses the lock.
- A lock that the operating system refuses to create is now reported as a plain, actionable failure that names the lock file and asks you to check your write permission for the folder. Previously, the CLI reported a raw
```
CreateDirectory failed
```
  error without a cause and filed a crash report for a machine-state issue. A full disk or read-only volume continues to report the operating system's more specific message. Releasing a lock on such a machine no longer stalls.
- Interrupting a download with Ctrl+C no longer leaves the Windows taskbar showing progress indefinitely.
```
unity install
```
  previously had no Ctrl+C handling, so Windows killed the process immediately and skipped cleanup. This could orphan the elevated helper that ran the Editor installer and leave the install lock behind, causing a retry within ten seconds to fail as if another install were still running. Ctrl+C is now handled cooperatively, and the command exits with code
```
130
```
  . A second Ctrl+C still force-quits the process.
- ```
unity run --command
```
  now honors
```
--timeout
```
  while waiting for the Editor it just started instead of exceeding the timeout by up to five and a half seconds. For example,
```
--timeout 10
```
  now reports the timeout after 10 seconds instead of 15.5 seconds.
- Spanish and Chinese no longer duplicate a word when the CLI reports that it updated itself. A completed update previously printed “Actualizado a a 1.2.3.” and duplicated a particle in Chinese. The issue affected update, downgrade, and channel-switch messages in all three output forms. The other seven languages were already correct.

Unity command-line interface (CLI)

Unity Pipeline

Unity Hub