How does Atlas handle Unity-specific files like .meta or scene YAML?

Atlas never touches `.meta` files or scene YAML without first showing you the proposed changes as a unified diff for review in your editor, ensuring critical Unity asset integrity and preventing unintended modifications.

Can Atlas detect per-frame allocations in Unity C# Update methods?

Yes, Atlas can identify and suggest hoisting `GetComponent` calls out of `Update` into `Awake` to prevent per-frame allocations, optimizing Unity gameplay performance and maintaining framerate.

What Unity test frameworks does Atlas support for PR reviews?

Atlas integrates with the `Unity Test Framework (NUnit)` to run both EditMode and PlayMode tests via `bash`, validating C# gameplay logic and ensuring the stability of your Unity project.

How does Atlas ensure code quality for Unity C# scripts?

Atlas can execute `dotnet format --check --verify-no-changes` via `bash` to enforce consistent C# code style across your Unity project, including `MonoBehaviour` and `ScriptableObject` scripts within the `Assets/` folder.

Does Atlas use local embeddings for Unity code indexing?

Yes, Atlas can build its code index for Unity C# scripts using local Ollama embeddings, keeping your proprietary gameplay code off third-party servers and ensuring data privacy.

How does Atlas provide context beyond the diff for Unity C# changes?

Atlas uses `read` to pull full Unity C# files, not just diff hunks, and `lsp findReferences` to check for broken callers of changed C# signatures, providing comprehensive context for review.

What safety features does Atlas offer when reviewing Unity pull requests?

Atlas employs permission-gated tool calls, drafts plans in a read-only agent, and surfaces a unified diff for every file edit for approval, including changes to Unity C# scripts, ensuring a safe review process.

Review a Pull Request in Unity with Atlas in 2026

In 2026, Unity developers use Atlas to review pull requests by fetching the branch, reading full changed files, checking C# signature references with LSP, and running Unity Test Framework (NUnit) tests to catch subtle MonoBehaviour lifecycle and per-frame allocation bugs.

How Atlas Reviews Unity Pull Requests for Performance and Stability

In 2026, Atlas streamlines Unity pull request reviews by analyzing C# gameplay code for performance and stability issues. It goes beyond a line-by-line diff, leveraging full file context and Unity Test Framework (NUnit) results to catch subtle MonoBehaviour lifecycle bugs and per-frame allocations.

Atlas approaches a Unity pull request review with the same diligence as a human expert, but with terminal-native AI speed. It begins by obtaining the raw diff, then immediately moves beyond it to understand the broader context. For Unity C# gameplay code, where MonoBehaviour lifecycle order and per-frame allocations are critical for maintaining framerate, Atlas reads the full changed files, not just the hunks. This comprehensive view allows Atlas to identify potential issues that a limited diff might obscure. It then uses its lsp tool to perform `findReferences` for every changed C# function signature, ensuring that no caller outside the immediate diff has been inadvertently broken. This is particularly vital in Unity projects where changes to a single MonoBehaviour method can have cascading effects across multiple game objects or scenes. Atlas also actively searches for common pitfalls like old constant names or stale feature flags that should have been updated, and finally, it runs the project's Unity Test Framework (NUnit) tests to validate the changes.

Fetching Unity Changes and Analyzing C# Code with Atlas

Atlas fetches Unity changes and analyzes C# code by first producing a raw diff with `bash`, then reading full files with `read` to provide complete context. For instance, a changed C# signature in a `MonoBehaviour` script at line 10 will trigger `lsp findReferences` to check all 100+ callers.

To begin a Unity pull request review, Atlas leverages its VCS layer to fetch the relevant branch and produce a raw diff using `atlas bash "git diff <base_branch> <feature_branch>"`. Once the changes are identified, Atlas uses its `read` tool to pull the full content of every changed Unity C# file, such as `Assets/Scripts/PlayerController.cs` or `ScriptableObjects/GameSettings.cs`. This ensures that Atlas has the complete surrounding context, which is crucial for understanding how a change might impact MonoBehaviour lifecycle methods like `Awake`, `Start`, or `Update`, or how it might affect per-frame allocations. For every modified C# function signature, Atlas employs its `lsp` tool to execute `findReferences`. This operation is indispensable for Unity development, as it identifies all call sites across the entire codebase, including those in other MonoBehaviour scripts or editor tools, that might be affected by a signature change, even if those call sites are not part of the current diff. Atlas builds its code index using AST declarations via tree-sitter, allowing precise C# analysis, and can use local Ollama embeddings to keep your proprietary Unity code off third-party servers.

Validating Unity Gameplay Logic with Unity Test Framework (NUnit)

Validating Unity gameplay logic is critical, and Atlas achieves this by executing `Unity Test Framework (NUnit)` tests via `bash`. In 2026, Atlas reports all test findings as a severity-ordered `todowrite` list, ensuring no critical bug in your `Assets/Tests` folder goes unnoticed.

A core component of reviewing Unity pull requests with Atlas is the automated execution of tests. Atlas uses its `bash` tool to run the project's `Unity Test Framework (NUnit)` tests. This includes both EditMode tests, typically found under `Assets/Tests/EditMode`, which validate C# logic without needing a running game, and PlayMode tests, located in `Assets/Tests/PlayMode`, which verify gameplay behavior within a simulated Unity environment. The actual command executed might resemble `atlas bash "Unity.exe -batchmode -runTests -testPlatform EditMode -projectPath . -logFile stdout"` to ensure comprehensive coverage. After test execution, Atlas collects all findings and reports them using its `todowrite` tool. This generates a severity-ordered list of issues, making it easy for the Unity developer to prioritize and address any regressions or new bugs introduced by the pull request, especially those related to MonoBehaviour lifecycle or performance-critical sections of the code.

Ensuring Code Quality and Safety in Unity Projects with Atlas

Atlas ensures code quality and safety in Unity projects by integrating `dotnet format` and providing robust review mechanisms. Every proposed change, even a minor C# script edit, is presented as a unified diff for approval, preventing unintended modifications to your 2026 codebase.

Maintaining consistent code quality in Unity C# projects is vital, and Atlas facilitates this by integrating with standard tooling. Atlas can execute `dotnet format --check --verify-no-changes` via `bash` to ensure that all C# scripts, including `MonoBehaviour` and `ScriptableObject` files, adhere to the project's formatting standards. Beyond formatting, Atlas uses its `grep` tool to search for specific patterns that should have been updated but were missed, such as old constant names, stale copies of code, or feature flags that are no longer relevant within the `Assets/` folder or `Packages/manifest.json`. Safety is paramount in Atlas's design. Every tool call is permission-gated, requiring explicit allow, ask, or deny rules before execution. Atlas drafts its initial plan in a read-only plan agent, asking for approval before switching to a build agent that can make changes. For every file edit, Atlas computes a unified diff and surfaces it for approval, ensuring that no `.meta` files or scene YAML are touched without the developer's explicit consent. Furthermore, Atlas snapshots file changes as git patches, allowing edits to be easily diffed and rolled back if necessary, providing a robust safety net for your Unity project.

Step by step

011: Fetch the pull request branch and generate the diff for Unity C# files using `bash`.
022: Read the full changed Unity C# files, such as `Assets/Scripts/MyGameplayScript.cs`, for complete context using `read`.
033: Check for broken C# references in `MonoBehaviour` or `ScriptableObject` methods using `lsp findReferences`.
044: Search for outdated patterns, old constant names, or feature flags within the Unity project's `Assets/` folder using `grep`.
055: Run `dotnet format --check --verify-no-changes` via `bash` to ensure C# code style consistency across Unity scripts.
066: Execute `Unity Test Framework (NUnit)` EditMode and PlayMode tests via `bash` using `Unity.exe -batchmode -runTests -testPlatform EditMode -projectPath . -logFile stdout` to validate gameplay logic.
077: Report all findings, ordered by severity, as a `todowrite` list for the Unity developer.

Frequently asked questions

How does Atlas handle Unity-specific files like .meta or scene YAML?: Atlas never touches `.meta` files or scene YAML without first showing you the proposed changes as a unified diff for review in your editor, ensuring critical Unity asset integrity and preventing unintended modifications.
Can Atlas detect per-frame allocations in Unity C# Update methods?: Yes, Atlas can identify and suggest hoisting `GetComponent` calls out of `Update` into `Awake` to prevent per-frame allocations, optimizing Unity gameplay performance and maintaining framerate.
What Unity test frameworks does Atlas support for PR reviews?: Atlas integrates with the `Unity Test Framework (NUnit)` to run both EditMode and PlayMode tests via `bash`, validating C# gameplay logic and ensuring the stability of your Unity project.
How does Atlas ensure code quality for Unity C# scripts?: Atlas can execute `dotnet format --check --verify-no-changes` via `bash` to enforce consistent C# code style across your Unity project, including `MonoBehaviour` and `ScriptableObject` scripts within the `Assets/` folder.
Does Atlas use local embeddings for Unity code indexing?: Yes, Atlas can build its code index for Unity C# scripts using local Ollama embeddings, keeping your proprietary gameplay code off third-party servers and ensuring data privacy.
How does Atlas provide context beyond the diff for Unity C# changes?: Atlas uses `read` to pull full Unity C# files, not just diff hunks, and `lsp findReferences` to check for broken callers of changed C# signatures, providing comprehensive context for review.
What safety features does Atlas offer when reviewing Unity pull requests?: Atlas employs permission-gated tool calls, drafts plans in a read-only agent, and surfaces a unified diff for every file edit for approval, including changes to Unity C# scripts, ensuring a safe review process.

Try Atlas in your terminal

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

Install Atlas

Related guides

Review a Pull Request with Atlas (2026 Workflow)

How to review a pull request with Atlas in 2026: bash produces the raw patch, read pulls whole files, the lsp tool's findReferences checks callers the diff never shows.

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.

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.

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.

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.

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 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.

Browse this resource hub