How does Atlas show me my uncommitted Godot changes?

Atlas's VCS layer reads your `git` working tree and surfaces the raw diff, allowing you to `read` all uncommitted modifications across your `.gd` scripts, `.tscn` scenes, and `project.godot` settings directly within its TUI.

Can Atlas help me find debugging code in my Godot project?

Yes, Atlas can `grep` your Godot project for common debugging leftovers like `print()` statements, `push_error()`, commented-out code blocks, or `GUT (Godot Unit Test)` `skip()` calls in your `.gd` scripts and test files.

How do I run Godot unit tests with Atlas before committing?

You can ask Atlas to run your `GUT (Godot Unit Test)` tests headless using `bash` with the command `godot --headless -s addons/gut/gut_cmdln.gd`, then review the output for any failures.

Does Atlas integrate with Godot's code formatter?

Yes, Atlas can run `gdformat (gdtoolkit)` over your touched `.gd` scripts using `bash` with `gdformat `. It will then present the formatting changes as a unified diff for your approval before writing them.

What if I make a mistake and need to undo changes in Godot with Atlas?

Atlas provides a session revert feature, backed by `git` snapshots, that allows you to safely roll back unwanted changes to your Godot project. It ensures the session is not busy before reverting.

How does Atlas ensure it doesn't make unwanted changes to my Godot project?

Atlas employs permission-gated tool calls (allow, ask, deny) and always computes a unified diff for every file edit, surfacing it for your explicit approval before writing any changes to your Godot `.gd` scripts or scene files.

Can Atlas understand Godot's node paths and scene structure?

Yes, Atlas indexes code by AST declarations using tree-sitter and can read your `.gd` scripts, the node paths they reach with `$NodePath` or `get_node()`, and the autoload singletons defined in `project.godot` settings.

Self-review your working diff before committing in Godot with Atlas in 2026

Atlas helps Godot developers in 2026 catch their own mistakes in uncommitted diffs by surfacing the working tree, running `GUT (Godot Unit Test)` for tests, and applying `gdformat (gdtoolkit)` for consistent code style before committing.

How to view your Godot diff with Atlas

Atlas provides a clear view of your uncommitted Godot changes, allowing you to inspect the working diff before committing. In 2026, Atlas reads `git` branches, status, and diffs directly, presenting a unified diff for every file edit. This ensures you see all modifications across your `.gd` scripts and scene files.

Atlas leverages its VCS layer to surface the raw working diff for your Godot project. Instead of manually running `git diff` in your terminal, Atlas integrates this functionality, allowing you to `read` the entire diff end-to-end within its terminal-native user interface. This is crucial for Godot development, where changes can span not just `.gd` scripts but also `.tscn` or `.tres` files, affecting node paths and signal connections. Atlas ensures that every modification, from a new `_ready()` function in a GDScript to a rewired signal in a scene, is presented for your review. This comprehensive view helps prevent overlooking subtle changes that might introduce bugs or break existing functionality, ensuring a thorough self-review process for your Godot codebase.

Reviewing Godot scene and script changes in context

Reviewing Godot changes in 2026 requires understanding how `.gd` scripts interact with the node tree and signals. Atlas helps you read each changed file in full, checking modifications against their surroundings. This prevents issues where a diff might hide the broader impact of a change on your scene structure or autoload singletons.

A standard diff only shows what changed, not the surrounding context, which is particularly problematic in Godot where scene structure is half the program. Atlas addresses this by allowing you to `read` each modified file in its entirety. For a `.gd` script, this means seeing the full class, its methods, and how it interacts with other nodes via `$NodePath` or `get_node()`. Atlas's ability to index code by AST declarations using tree-sitter, rather than blind line windows, means it understands the structure of your GDScript. It can also read the node paths your scripts reach and the autoload singletons defined in `project.godot` settings. This deep contextual awareness helps you verify that a change to a script, such as replacing a fragile `get_node` path with an `@onready var` and an exported `NodePath`, aligns correctly with the scene it's attached to, preventing runtime errors and ensuring your Godot project remains robust.

Catching debugging leftovers in Godot projects

Before committing your Godot code in 2026, it is vital to remove any debugging leftovers like temporary logging or skipped tests. Atlas helps you `grep` for these common mistakes across your `.gd` scripts and scene files. This ensures that `print()` statements, commented-out blocks, or `GUT (Godot Unit Test)` skipped tests do not accidentally make it into your codebase.

Debugging often leaves behind temporary code that should not be committed. Atlas provides a `grep` tool to systematically search for these artifacts across your Godot project. You can configure Atlas to look for common GDScript debugging patterns, such as `print("debug")`, `push_error()`, or `breakpoint()`. For `GUT (Godot Unit Test)` users, it is equally important to `grep` for `skip()` calls within your test files under the `test/` directory, ensuring all tests are active. Similarly, commented-out blocks of code, which might indicate indecision or temporary workarounds, can be identified. By running these `grep` checks, Atlas helps maintain a clean and production-ready Godot codebase, preventing unnecessary noise or potential security risks from reaching your version control system.

Reverting unwanted Godot changes with Atlas

If you identify a change in your Godot project that should not have been made, Atlas offers a robust session revert mechanism. This feature, available in 2026, restores your files from a snapshot, ensuring unwanted modifications to `.gd` scripts or scene files are undone safely. Atlas asserts the session is not busy first, preventing data loss.

During self-review, you might discover a modification that needs to be completely undone. Atlas's session revert flow is backed by snapshots, allowing you to roll back unwanted changes rather than hand-reverting them. This is particularly useful in Godot where a single change might affect multiple interconnected files (e.g., a script, a scene, and a resource). Atlas snapshots file changes as `git` patches, so edits can be diffed and rolled back with precision. The revert process refuses to run on a busy session, which prevents a half-written turn from being rolled back mid-flight, ensuring data integrity. This safety mechanism provides confidence when making significant changes, knowing that a clean rollback is always an option for your Godot project, safeguarding your development workflow.

Automating Godot code quality with GUT and gdformat

Before committing your Godot changes, running automated checks with `GUT (Godot Unit Test)` and `gdformat (gdtoolkit)` is essential. Atlas can orchestrate these tools in 2026, ensuring your `.gd` scripts pass all tests and adhere to consistent formatting standards. This significantly reduces the chance of introducing regressions or style violations.

A critical part of self-review is verifying code functionality and style. Atlas integrates with Godot's native toolchain to automate these checks. You can instruct Atlas to run your `GUT (Godot Unit Test)` tests headless using the command `godot --headless -s addons/gut/gut_cmdln.gd`. This ensures that any new features or bug fixes in your `.gd` scripts have not broken existing functionality. After passing tests, Atlas can then run `gdformat (gdtoolkit)` over your touched scripts. The command `gdformat <file.gd>` ensures your GDScript adheres to a consistent style, preventing debates over formatting during code review. Atlas will present the unified diff of `gdformat`'s changes for your approval before writing them, giving you full control. This two-step automated process, managed by Atlas, elevates the quality of your Godot codebase before it even reaches a human reviewer or CI pipeline.

Atlas's safety and control for Godot developers

Atlas provides robust safety and control mechanisms for Godot developers in 2026, ensuring every action is transparent and approved. Every Atlas tool call is permission-gated, and a unified diff is surfaced for approval before any file edit is written. This prevents unintended modifications to your `.gd` scripts or scene files.

Atlas is designed with developer control at its core. Before any tool, including `bash`, `read`, `grep`, or `edit`, is executed, Atlas applies permission-gated rules (allow, ask, deny). This means you are always aware of and approve the actions Atlas takes within your Godot project. Furthermore, Atlas drafts a plan in a read-only plan agent and asks for your confirmation before switching to a build agent to execute changes. Crucially, for every file edit Atlas proposes, it computes a unified diff and surfaces it for your explicit approval before writing. This granular control ensures that changes to your `.gd` scripts, `project.godot` settings, or scene files are never applied without your consent, providing a secure and predictable development experience for Godot users, and preventing any unexpected alterations to your codebase.

Step by step

01Ask Atlas to `read` the current `git` working diff for your Godot project, inspecting all changes across `.gd` scripts, `.tscn` scenes, and `project.godot` settings end-to-end.
02Use Atlas to `read` each modified `.gd` script or scene file in full, verifying changes against its surroundings, including node paths (`$NodePath`) and signal connections, to ensure structural integrity.
03Instruct Atlas to `grep` your `.gd` scripts and `test/` directory for common debugging artifacts like `print()` statements, commented-out code blocks, or `GUT (Godot Unit Test)` `skip()` calls.
04If any modification should not have been made, use Atlas's session revert feature to restore your Godot project from a snapshot, ensuring the session is not busy first.
05Ask Atlas to execute your `GUT (Godot Unit Test)` tests headless using `bash` with the command `godot --headless -s addons/gut/gut_cmdln.gd` to verify functionality.
06After tests pass, instruct Atlas to run `gdformat (gdtoolkit)` over your touched `.gd` scripts using `bash` with `gdformat <file.gd>`, then review and approve the formatting diff.
07Once satisfied with the self-review, use Atlas to stage and create your `git` commit, incorporating all approved changes.

Frequently asked questions

How does Atlas show me my uncommitted Godot changes?: Atlas's VCS layer reads your `git` working tree and surfaces the raw diff, allowing you to `read` all uncommitted modifications across your `.gd` scripts, `.tscn` scenes, and `project.godot` settings directly within its TUI.
Can Atlas help me find debugging code in my Godot project?: Yes, Atlas can `grep` your Godot project for common debugging leftovers like `print()` statements, `push_error()`, commented-out code blocks, or `GUT (Godot Unit Test)` `skip()` calls in your `.gd` scripts and test files.
How do I run Godot unit tests with Atlas before committing?: You can ask Atlas to run your `GUT (Godot Unit Test)` tests headless using `bash` with the command `godot --headless -s addons/gut/gut_cmdln.gd`, then review the output for any failures.
Does Atlas integrate with Godot's code formatter?: Yes, Atlas can run `gdformat (gdtoolkit)` over your touched `.gd` scripts using `bash` with `gdformat <file.gd>`. It will then present the formatting changes as a unified diff for your approval before writing them.
What if I make a mistake and need to undo changes in Godot with Atlas?: Atlas provides a session revert feature, backed by `git` snapshots, that allows you to safely roll back unwanted changes to your Godot project. It ensures the session is not busy before reverting.
How does Atlas ensure it doesn't make unwanted changes to my Godot project?: Atlas employs permission-gated tool calls (allow, ask, deny) and always computes a unified diff for every file edit, surfacing it for your explicit approval before writing any changes to your Godot `.gd` scripts or scene files.
Can Atlas understand Godot's node paths and scene structure?: Yes, Atlas indexes code by AST declarations using tree-sitter and can read your `.gd` scripts, the node paths they reach with `$NodePath` or `get_node()`, and the autoload singletons defined in `project.godot` settings.

Try Atlas in your terminal

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

Install Atlas

Related guides

Self-Review Your Working Diff Before Committing with Atlas (2026 Workflow)

How to self-review your working diff before committing with Atlas in 2026: bash produces the diff, read checks each file, grep finds leftovers, session revert undoes bad edits.

Atlas for Godot: Terminal-Native AI Coding for GDScript and the Node Tree in 2026

Atlas is a terminal-native AI coding agent for Godot in 2026, working across GDScript, the node tree, and signals, where scene structure is half the program.

Rename a symbol across the repo in Godot with Atlas in 2026

Rename functions, classes, and constants across your Godot project with Atlas in 2026. Use `lsp`, `grep`, and `edit` for precise, safe refactoring, catching all references, even those `grep` alone misses.

Extract a Shared Helper from Duplicated Godot Code with Atlas in 2026

Refactor duplicated GDScript logic in Godot projects with Atlas. Find semantic copies, create shared helpers, and replace code with atomic, test-verified patches using GUT and gdformat.

Upgrade a Dependency and Fix Breakage in Godot with Atlas in 2026

In 2026, Godot developers use Atlas to efficiently upgrade dependencies via Godot Asset Library (gd-plug) and resolve compile and test failures with precise, AI-driven fixes.

Document a module with a README in Godot with Atlas in 2026

In 2026, Atlas helps Godot developers create accurate READMEs for modules by analyzing live GDScript code, node paths, and signals. Ensure your documentation reflects what your Godot project actually does today.

Trace a runtime bug from a stack trace in Godot with Atlas in 2026

Pinpoint Godot runtime bugs from production stack traces using Atlas in 2026. Leverage Atlas's AI to read frames, grep for errors, and fix issues in GDScript without a debugger.

Add a Regression Test for a Godot Bug Fix with Atlas in 2026

Lock in Godot bug fixes with Atlas in 2026. Learn to write failing GUT tests, apply fixes, and confirm passes using Atlas's terminal-native AI agent for GDScript projects.

Browse this resource hub