How does Atlas run Unreal Engine tests?

Atlas uses its `bash` tool to execute `UnrealEditor-Cmd` with the `Unreal Automation Framework`, applying specific filters to run only the desired tests, just as you would from the command line.

Can Atlas understand Unreal Engine C++ macros like UCLASS?

Yes, Atlas indexes code by AST declarations using tree-sitter, allowing it to understand and navigate Unreal Engine C++ constructs like `UCLASS`, `UPROPERTY`, and `UFUNCTION` macros.

How does Atlas handle Unreal Engine module dependencies?

Atlas is designed to first add module dependencies in the `Build.cs` file using `edit` before adding corresponding `#include` statements in C++ source files, ensuring correct compilation with `Unreal Build Tool`.

Is it safe to let Atlas modify my Unreal Engine project?

Yes, Atlas is permission-gated, meaning every tool call requires approval. It drafts plans in a read-only agent and presents unified diffs for all proposed changes before writing to your `.uproject` or `Source/` files.

Can Atlas apply Unreal Engine's clang-format style?

Yes, after making code changes, Atlas can apply the engine's `.clang-format` style guide to ensure your C++ code matches Epic's standards, presenting the diff for your approval.

What if a fix requires changes across many files in Unreal Engine?

For fixes spanning multiple files or non-contiguous hunks, Atlas uses `apply_patch` to generate and apply a unified diff, ensuring that complex changes are handled atomically and reliably.

Does Atlas support local code indexing for Unreal Engine projects?

Yes, Atlas can build its code index with local Ollama embeddings, keeping your Unreal Engine C++ code off third-party servers and ensuring privacy for your project.

Debug a single failing test in Unreal Engine with Atlas in 2026

Atlas helps Unreal Engine developers in 2026 debug a single failing test by running it in isolation using the `bash` tool to invoke the `Unreal Automation Framework` with specific filters, then navigating the C++ codebase with `lsp` to identify the root cause, and finally applying fixes with `edit` or `apply_patch`.

How to run a single Unreal Engine test with Atlas

To debug a single failing test in Unreal Engine with Atlas in 2026, you will use Atlas's `bash` tool to execute the `Unreal Automation Framework` with a specific filter. This approach ensures that only the 1 relevant test runs, minimizing output and focusing your debugging efforts immediately on the problem.

Atlas leverages its `bash` tool to directly interact with the Unreal Engine toolchain, allowing you to run specific tests just as you would from your terminal. When a test fails, Atlas can execute the `Unreal Automation Framework` via `UnrealEditor-Cmd` with a filter flag, such as `-AutomationTest=MyProject.MyModule.MyFailingTest`. This command isolates the problematic test, providing a concise output that highlights the assertion failure without the noise of a full test suite run. Atlas reads this output, allowing it to quickly identify the exact assertion that failed and the context around it. This direct interaction with the `Unreal Automation Framework` ensures that Atlas operates within the familiar and expected environment of an Unreal Engine project, respecting its `.uproject` and `Source/` module folder structure.

Navigating Unreal Engine C++ code with Atlas LSP

After identifying a failing test in Unreal Engine, Atlas uses its `lsp` tool to work through the C++ codebase, allowing you to trace the call graph from the test assertion back to the production code. This is crucial for understanding the flow of execution and pinpointing the exact line of code responsible for the failure, often within 1 or 2 minutes of starting the investigation.

Atlas's `lsp` tool provides powerful code navigation capabilities essential for Unreal Engine C++ development. Once a test failure is identified, Atlas can use `goToDefinition` to jump from the failing assertion directly to the relevant production code. It understands Unreal Engine's specific C++ idioms, such as `UCLASS`, `UPROPERTY`, and `UFUNCTION` macros, and can accurately parse the Abstract Syntax Tree (AST) using tree-sitter. This allows Atlas to perform `findReferences` operations to see where a function or variable is used across your `Source/` module folders. By walking the call graph, Atlas builds a comprehensive understanding of the code exercised by the failing test, including dependencies declared in `Build.cs` files, which is vital for forming an accurate hypothesis about the bug's origin.

Forming and checking hypotheses in Unreal Engine with Atlas

To form and check a hypothesis about a failing Unreal Engine test, Atlas can add temporary logging or re-run tests with verbose flags using its `edit` and `bash` tools. This iterative process allows for rapid validation of assumptions, often requiring fewer than 5 cycles to pinpoint the exact cause of a bug in complex C++ systems.

Once Atlas has navigated the Unreal Engine C++ codebase and formed a hypothesis about why a test is failing, it can use its `edit` tool to insert temporary logging statements. For example, it might add `UE_LOG` macros to a specific function within a `Source/` module to print variable values or execution paths. After adding the logging, Atlas re-runs the single failing test using the `bash` tool and the `Unreal Automation Framework` filter. Alternatively, Atlas can re-run the test with verbose flags through `bash` if the `UnrealEditor-Cmd` or the test itself supports them. This immediate feedback loop allows Atlas to confirm or refute its hypothesis efficiently. All temporary changes are tracked, making it easy to remove them once the bug is fixed.

Fixing Unreal Engine C++ code and managing dependencies with Atlas

Atlas fixes production code in Unreal Engine using its `edit` tool for small, focused changes or `apply_patch` for more extensive modifications spanning multiple hunks. A critical capability is Atlas's ability to add module dependencies in `Build.cs` files before adding includes, a step often missed by other C++ agents, ensuring correct compilation for 100% of changes.

When the root cause of a failing Unreal Engine test is identified, Atlas proceeds to fix the production code. For minor adjustments, the `edit` tool is used to modify specific lines or blocks of C++ code within your `Source/` directories. If the fix involves changes across several non-contiguous sections of a file or multiple files, Atlas can generate and apply a unified diff using `apply_patch`, ensuring atomic and reliable updates. Crucially, if the fix requires a new module dependency, Atlas will first use `edit` to update the relevant `Build.cs` file, adding the necessary `PublicDependencyModuleNames.AddRange` entry, before adding the corresponding `#include` statement in the C++ source file. This ensures that the Unreal Build Tool correctly compiles the project, adhering to the framework's module system.

Reviewing and committing Unreal Engine changes with Atlas

Atlas provides robust review and safety mechanisms for all changes made to your Unreal Engine project, ensuring that every modification is explicitly approved. Before writing any changes, Atlas computes a unified diff for every file edit and surfaces it for your approval, allowing you to review 100% of the proposed code modifications.

Atlas integrates deeply with your Git workflow, providing comprehensive review and safety features. Before any code is written to your Unreal Engine project, Atlas computes a unified diff for every proposed file edit. This diff is presented to you for explicit approval, giving you full control over the changes. Atlas also snapshots file changes as Git patches, so edits can be easily diffed, rolled back, or applied. Furthermore, Atlas operates with permission-gated tool calls, meaning every action, such as writing to a `Build.cs` file or modifying a `UCLASS` macro, requires your explicit consent based on allow, ask, or deny rules. This ensures that Atlas acts as a trusted assistant, never making unapproved changes to your `.uproject` or `Source/` module files.

Atlas safety and permissions for Unreal Engine development

Atlas prioritizes safety and control for Unreal Engine developers, implementing a multi-layered permission system and a read-only planning agent. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, ensuring that no changes are made to your C++ codebase or `Build.cs` files without explicit consent, providing 100% transparency.

Atlas is designed with developer control at its core, especially critical when working with complex Unreal Engine projects. Before executing any action that modifies your codebase, such as using `edit` to change a `UFUNCTION` or `apply_patch` to update multiple `Source/` files, Atlas consults its permission-gated rules. These rules can be configured to `allow`, `ask`, or `deny` specific tool calls, providing granular control over Atlas's capabilities. Furthermore, Atlas drafts a plan in a read-only plan agent and asks for your approval before switching to a build agent that can make changes. This two-stage process, combined with surfacing a unified diff for every proposed edit, ensures that you maintain complete oversight and can approve or reject any modification to your Unreal Engine C++ code or configuration files like `Build.cs`.

Step by step

01Run just the failing Unreal Engine test with Atlas's `bash` tool, using the `Unreal Automation Framework` filter flag (e.g., `-AutomationTest=MyProject.MyModule.MyFailingTest`) to minimize output.
02Read the test and the Unreal Engine C++ module it exercises, then use Atlas's `lsp` tool's `goToDefinition` and `findReferences` operations to walk the call path through `UCLASS` and `UFUNCTION` macros.
03Form a hypothesis and check it: add temporary `UE_LOG` logging with Atlas's `edit` tool to `Source/` files, or re-run the test with a verbose flag through `bash`.
04Fix the production C++ code with Atlas's `edit` tool; if the change spans several hunks or requires a `Build.cs` update for a new module dependency, use `apply_patch` instead.
05Re-run the single Unreal Engine test via `bash`, then the full suite using the `Unreal Automation Framework`, and remove any temporary logging you added with `edit`.
06Approve the unified diff presented by Atlas for all changes, including `Build.cs` modifications and `clang-format` applications, before writing to disk and committing via Git.

Frequently asked questions

How does Atlas run Unreal Engine tests?: Atlas uses its `bash` tool to execute `UnrealEditor-Cmd` with the `Unreal Automation Framework`, applying specific filters to run only the desired tests, just as you would from the command line.
Can Atlas understand Unreal Engine C++ macros like UCLASS?: Yes, Atlas indexes code by AST declarations using tree-sitter, allowing it to understand and navigate Unreal Engine C++ constructs like `UCLASS`, `UPROPERTY`, and `UFUNCTION` macros.
How does Atlas handle Unreal Engine module dependencies?: Atlas is designed to first add module dependencies in the `Build.cs` file using `edit` before adding corresponding `#include` statements in C++ source files, ensuring correct compilation with `Unreal Build Tool`.
Is it safe to let Atlas modify my Unreal Engine project?: Yes, Atlas is permission-gated, meaning every tool call requires approval. It drafts plans in a read-only agent and presents unified diffs for all proposed changes before writing to your `.uproject` or `Source/` files.
Can Atlas apply Unreal Engine's clang-format style?: Yes, after making code changes, Atlas can apply the engine's `.clang-format` style guide to ensure your C++ code matches Epic's standards, presenting the diff for your approval.
What if a fix requires changes across many files in Unreal Engine?: For fixes spanning multiple files or non-contiguous hunks, Atlas uses `apply_patch` to generate and apply a unified diff, ensuring that complex changes are handled atomically and reliably.
Does Atlas support local code indexing for Unreal Engine projects?: Yes, Atlas can build its code index with local Ollama embeddings, keeping your Unreal Engine C++ code off third-party servers and ensuring privacy for your project.

Try Atlas in your terminal

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

Install Atlas

Related guides

Debug a Single Failing Test with Atlas in 2026

How to debug one failing test with Atlas in 2026: run it in isolation with bash, walk the call graph with the lsp tool, and fix the code, not the assertion.

Atlas for Unreal Engine: Terminal-Native AI Coding for UCLASS and Build.cs in 2026

Atlas is a terminal-native AI coding agent for Unreal Engine C++ in 2026, where UCLASS macros, the reflection system, and Build.cs module rules are the real API.

Automate GitHub issue and pull request triage in Unreal Engine with Atlas in 2026

Automate GitHub issue and pull request triage for Unreal Engine projects with Atlas in 2026. Safely respond to events, manage dependencies with Unreal Build Tool (Build.cs), and format code with clang-format, ensuring

Run the test suite and triage the failures in Unreal Engine with Atlas in 2026

Run and triage Unreal Engine test suite failures with Atlas in 2026. Transform red output from Unreal Automation Framework into prioritized root causes, streamlining C++ development.

Review a pull request in Unreal Engine with Atlas in 2026

Streamline Unreal Engine pull request reviews in 2026 with Atlas. Leverage its AI to analyze C++ code, UCLASS macros, and Build.cs dependencies, ensuring comprehensive context and catching subtle bugs.

Onboard to an Unfamiliar Unreal Engine Codebase with Atlas in 2026

Quickly build a working mental model of any Unreal Engine C++ repository in 2026 using Atlas. Leverage semantic search, project structure analysis, and LSP integration for rapid onboarding.

Refactor a Legacy Unreal Engine Module in 2026 with Atlas

Learn how Atlas helps Unreal Engine developers refactor legacy C++ modules in 2026. Safely restructure code, manage dependencies with Build.cs, and verify behavior with Unreal Automation Framework.

Trace a Runtime Bug from a Stack Trace in Unreal Engine with Atlas in 2026

Pinpoint the exact line of code responsible for a production runtime bug in Unreal Engine C++ using Atlas. Go from stack trace to fix without a debugger attached.

Browse this resource hub