How does Atlas know if my Unity command is waiting for input?

Atlas's `bash` tool monitors the command's execution. If a command times out and Atlas detects patterns indicative of waiting for standard input, it explicitly states this in the `shell_metadata` block. This is a common scenario for tools like `Unity Package Manager (UPM)` or `dotnet format` if not run with non-interactive flags.

Can Atlas help diagnose a slow Unity build process?

Yes, Atlas can help diagnose slow Unity build processes. If your build command, run through `atlas bash`, exceeds its timeout, Atlas will report this. You can then increase the timeout value, for example, `atlas bash --timeout 300000 "unity build-player"`, to allow the build to complete, confirming it's genuinely slow rather than blocked.

What if `dotnet format` hangs in my Unity project?

If `dotnet format` hangs when run via Atlas, the `shell_metadata` will tell you why. If it's waiting for input, re-run it with `--no-input` or similar flags. If it's genuinely slow due to a large C# codebase, increase the timeout for the `atlas bash "dotnet format"` command.

Does Atlas modify Unity `.meta` files or scene YAML directly?

No, Atlas never modifies Unity `.meta` files or scene YAML without explicit user approval. All proposed changes are presented as a unified diff, and Atlas will specifically highlight any potential interactions with these sensitive files, ensuring you maintain full control and prevent project corruption.

How do I set up Atlas in my Unity project?

To set up Atlas, simply run it within your Unity project directory, ensuring it contains an `Assets/` folder and `Packages/manifest.json`. Atlas will automatically read your `MonoBehaviour` scripts, `ScriptableObjects`, and `Unity Package Manager (UPM)` resolved packages to build its code index.

Can Atlas help with `Unity Test Framework (NUnit)` test runs?

Absolutely. If your `Unity Test Framework (NUnit)` test run hangs, Atlas can diagnose it. Run your test command through `atlas bash`. If it's blocked on input, Atlas will tell you. If it's a long-running suite, Atlas will suggest increasing the timeout, allowing you to distinguish between a stuck process and a genuinely extensive test execution.

What if I accidentally abort a command in Atlas?

If you manually abort a command running in Atlas, the `shell_metadata` block will clearly state "User aborted the command." This distinct message helps you differentiate your intentional interruptions from commands that timed out or were blocked by Atlas, providing clarity in your debugging workflow.

How does Atlas ensure my code stays private when diagnosing issues?

Atlas prioritizes privacy by building its code index with local Ollama embeddings, keeping your Unity C# code off third-party servers. All tool calls are permission-gated, and file edits require your explicit approval after reviewing a unified diff, ensuring your codebase remains secure and private.

Diagnose a hanging or long-running command in Unity with Atlas in 2026

Atlas helps Unity developers in 2026 quickly diagnose whether a `dotnet format` operation, `Unity Test Framework (NUnit)` run, or any other script is genuinely slow or silently blocked on interactive input, providing clear steps to get it unstuck. By running commands through Atlas's `bash` tool, you receive explicit `shell_metadata` when a timeout occurs, detailing if the command was waiting for input or simply exceeded its allotted time, enabling precise resolution.

How Atlas Diagnoses Hanging Unity Commands

Atlas helps Unity developers in 2026 pinpoint why a command, such as a `dotnet format` run or a `Unity Test Framework (NUnit)` execution, is hanging. It does this by racing every command against a timeout, providing specific `shell_metadata` that indicates if the process is genuinely slow or silently blocked on interactive input.

When you execute a command within your Unity project using Atlas's `bash` tool, Atlas monitors its execution time. If the command exceeds a predefined timeout, Atlas doesn't just kill it; it provides a detailed `shell_metadata` block in the output. This metadata is crucial for Unity developers, as it explicitly distinguishes between a command that is genuinely taking a long time to complete, perhaps due to a large codebase or complex `ScriptableObjects` processing, and one that is silently waiting for user input. For instance, if a `Unity Package Manager (UPM)` operation were to prompt for confirmation without a non-interactive flag, Atlas would identify this as a blocked-on-stdin scenario. This clear diagnosis prevents wasted time spent waiting for a command that will never resolve itself, allowing you to quickly apply the correct fix, whether it's adding a `--no-input` flag or increasing the timeout for a heavy build process.

Concrete Unity Commands and Files Involved

Atlas integrates directly with your Unity project's toolchain, allowing you to diagnose commands like `dotnet format` for C# scripts or `Unity Test Framework (NUnit)` runs. It understands the context of files such as `Assets/` and `Packages/manifest.json`, ensuring relevant diagnostics for your 2026 Unity development workflow.

Atlas is designed to work direct within a Unity project structure, recognizing key directories like `Assets/` and configuration files such as `Packages/manifest.json`. This context allows Atlas to provide highly relevant diagnostics for Unity-specific commands. For example, if you're running `dotnet format` to standardize your C# gameplay code, and it hangs, Atlas will report if it's waiting for input or simply processing a large number of `MonoBehaviour` scripts. Similarly, when executing tests with `Unity Test Framework (NUnit)`, Atlas can help identify if a test run is stuck due to an unexpected prompt or if the test suite genuinely requires a longer execution time, perhaps due to complex PlayMode tests. Atlas's ability to read your `git` branches and status also means it understands the current state of your project, providing a comprehensive view when diagnosing issues with commands that interact with your version control or project setup.

Resolving Blocked or Slow Unity Commands

Once Atlas diagnoses a hanging Unity command, it provides clear instructions for resolution. If a `Unity Package Manager (UPM)` command is blocked on input, you'll rerun it with non-interactive flags like `-y` or `--no-input`. For genuinely slow operations, such as a large build, Atlas instructs you to retry with a larger timeout value, often in the range of 60000 milliseconds or more.

The power of Atlas lies not just in diagnosis but in providing actionable steps. If the `shell_metadata` indicates a command is blocked on interactive input, such as a `dotnet format` operation attempting to confirm changes, Atlas will guide you to re-execute it with the appropriate non-interactive flags. For many Unity-related command-line tools, this might involve `--no-input`, `-y` for 'yes', or enabling a CI mode. This ensures the command can complete without human intervention. Conversely, if Atlas determines the command is genuinely slow, perhaps a complex `Unity Test Framework (NUnit)` suite running many PlayMode tests, it will suggest retrying with an increased timeout. Atlas's `bash` tool allows you to specify timeouts in milliseconds, giving you granular control to accommodate long-running processes without prematurely aborting them. This distinction is vital for maintaining an efficient Unity development workflow, preventing unnecessary manual intervention or misdiagnosis.

Review and Safety with Atlas in Unity Projects

Atlas prioritizes safety and transparency when making changes in your Unity project, especially concerning sensitive files like scene YAML or `.meta` files. Every Atlas tool call is permission-gated, and all proposed file edits are presented as a unified diff for your approval, ensuring you maintain full control over your 2026 codebase.

Working with Atlas in a Unity project provides robust safety mechanisms. Before Atlas executes any tool call that could modify your project, it adheres to permission-gated rules (allow, ask, deny). This means you are always in control. When Atlas proposes changes, such as hoisting a `GetComponent` call out of `Update` into `Awake` in a `MonoBehaviour` script, it first drafts a plan in a read-only agent. Once a plan is approved, any actual file edits are presented as a unified diff. This diff is surfaced for your explicit approval before Atlas writes anything to disk. Crucially for Unity developers, Atlas never touches `.meta` files or scene YAML without showing you first, preventing accidental corruption of asset serialization or scene data. This meticulous review process, combined with Atlas's ability to snapshot file changes as `git` patches for easy rollback, ensures that diagnosing and fixing issues with hanging commands or optimizing code is always a safe and reversible operation within your Unity environment.

Step by step

01Run the Unity command through Atlas's `bash` tool: Execute your potentially hanging Unity command, such as `dotnet format` or a `Unity Test Framework (NUnit)` run, using `atlas bash "your_command_here"`. Atlas will race the command against a default timeout.
02Examine the `shell_metadata` for diagnosis: If the command times out, Atlas will output a `shell_metadata` block. Read this block carefully to determine if Atlas explicitly calls out that the command was "waiting for interactive input" or if it simply "exceeded the timeout."
03If blocked, re-run with non-interactive flags: If Atlas indicates the command was waiting for input (e.g., a `Unity Package Manager (UPM)` prompt), re-execute it with the appropriate non-interactive flags like `--no-input`, `-y`, or a CI mode flag specific to the tool. For example: `atlas bash "upm install --no-input"`.
04If genuinely slow, retry with a larger timeout: If the `shell_metadata` states the command exceeded the timeout without mentioning interactive input, it's genuinely slow. Re-run the command with an increased timeout value in milliseconds. For example: `atlas bash --timeout 120000 "dotnet format"`.
05Distinguish user aborts from timeouts: If you manually interrupted the command, the `shell_metadata` will clearly state "User aborted the command," helping you differentiate your intentional stops from Atlas's timeouts.

Frequently asked questions

How does Atlas know if my Unity command is waiting for input?: Atlas's `bash` tool monitors the command's execution. If a command times out and Atlas detects patterns indicative of waiting for standard input, it explicitly states this in the `shell_metadata` block. This is a common scenario for tools like `Unity Package Manager (UPM)` or `dotnet format` if not run with non-interactive flags.
Can Atlas help diagnose a slow Unity build process?: Yes, Atlas can help diagnose slow Unity build processes. If your build command, run through `atlas bash`, exceeds its timeout, Atlas will report this. You can then increase the timeout value, for example, `atlas bash --timeout 300000 "unity build-player"`, to allow the build to complete, confirming it's genuinely slow rather than blocked.
What if `dotnet format` hangs in my Unity project?: If `dotnet format` hangs when run via Atlas, the `shell_metadata` will tell you why. If it's waiting for input, re-run it with `--no-input` or similar flags. If it's genuinely slow due to a large C# codebase, increase the timeout for the `atlas bash "dotnet format"` command.
Does Atlas modify Unity `.meta` files or scene YAML directly?: No, Atlas never modifies Unity `.meta` files or scene YAML without explicit user approval. All proposed changes are presented as a unified diff, and Atlas will specifically highlight any potential interactions with these sensitive files, ensuring you maintain full control and prevent project corruption.
How do I set up Atlas in my Unity project?: To set up Atlas, simply run it within your Unity project directory, ensuring it contains an `Assets/` folder and `Packages/manifest.json`. Atlas will automatically read your `MonoBehaviour` scripts, `ScriptableObjects`, and `Unity Package Manager (UPM)` resolved packages to build its code index.
Can Atlas help with `Unity Test Framework (NUnit)` test runs?: Absolutely. If your `Unity Test Framework (NUnit)` test run hangs, Atlas can diagnose it. Run your test command through `atlas bash`. If it's blocked on input, Atlas will tell you. If it's a long-running suite, Atlas will suggest increasing the timeout, allowing you to distinguish between a stuck process and a genuinely extensive test execution.
What if I accidentally abort a command in Atlas?: If you manually abort a command running in Atlas, the `shell_metadata` block will clearly state "User aborted the command." This distinct message helps you differentiate your intentional interruptions from commands that timed out or were blocked by Atlas, providing clarity in your debugging workflow.
How does Atlas ensure my code stays private when diagnosing issues?: Atlas prioritizes privacy by building its code index with local Ollama embeddings, keeping your Unity C# code off third-party servers. All tool calls are permission-gated, and file edits require your explicit approval after reviewing a unified diff, ensuring your codebase remains secure and private.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Diagnose a Hanging or Long-Running Command with Atlas in 2026

How to diagnose a hanging command with Atlas in 2026: the bash tool races every command against a timeout and tells you whether it is slow or blocked on input.

Write unit tests for untested code in Unity with Atlas in 2026

Add real unit tests to untested Unity C# gameplay code in 2026 using Atlas. Leverage Unity Test Framework (NUnit) and existing repo conventions for robust testing.

Debug a single failing test in Unity with Atlas in 2026

Debug Unity C# gameplay tests with Atlas in 2026. Pinpoint failing tests using Unity Test Framework (NUnit) and Atlas's terminal-native AI agent for efficient code fixes.

Run the Unity Test Suite and Triage Failures with Atlas in 2026

In 2026, Unity developers use Atlas to efficiently run their Unity Test Framework (NUnit) suites and triage failures. Turn a wall of red output into a prioritized list of distinct root causes for C# gameplay code.

Research a Third-Party API for Unity Integration in 2026 with Atlas

Streamline Unity API integration in 2026. Atlas helps Unity developers research external APIs, fetch documentation, and verify code against `dotnet format` and `Unity Test Framework (NUnit)` standards before committing.

Run Atlas Headless in CI for Unity Projects in 2026

Automate C# code changes in Unity CI pipelines with Atlas. Run Atlas headless to refactor MonoBehaviour scripts, add Unity Test Framework tests, and format code with dotnet format, getting machine-readable output.

Document a Module with a README in Unity with Atlas in 2026

Generate accurate README documentation for your Unity C# modules in 2026 using Atlas. Ensure docs reflect current code behavior, not outdated plans, leveraging Unity's toolchain.

Upgrade a Unity Dependency and Fix Breakage with Atlas in 2026

In 2026, Unity developers use Atlas to upgrade major dependencies, automatically fixing compile and test failures. Leverage Atlas to manage Unity Package Manager updates and repair C# code.

Browse this resource hub