Atlas empowers Godot developers in 2026 to generate precise README documentation for modules by directly analyzing the current codebase, ensuring the documentation reflects the actual behavior of GDScript, node trees, and signals. It leverages tools like `lsp` for API enumeration, `read` for implementation details, and `codebase_search` for practical usage, all while respecting your existing `gdformat (gdtoolkit)` and `GUT (Godot Unit Test)` setup.
How to enumerate Godot module APIs for documentation with Atlas?
Atlas precisely enumerates a Godot module's public API surface in 2026 using the `lsp` tool's `documentSymbol` operation, ensuring no exported function or property is missed or invented. This process guarantees that the generated documentation accurately reflects the module's current interface, including GDScript methods and exported variables.
To produce documentation that describes what the code actually does today, Atlas begins by enumerating the module's public API. It utilizes the `lsp` tool's `documentSymbol` operation, which provides a structured view of all exported declarations within your Godot project's `.gd` scripts. This method ensures that every public function, variable, and signal is identified directly from the source, preventing any omissions or fabrications. By indexing code through AST declarations using tree-sitter, Atlas gains a deep understanding of the Godot codebase, including how GDScript interacts with the node tree and signals, ensuring the API surface is fully captured and traceable to the actual code.
How Atlas understands Godot GDScript implementation and usage?
To document what Godot code actually does today, Atlas reads the implementation of each enumerated export using its `read` tool and then employs `codebase_search` to find how callers actually use it in practice. This dual approach provides a comprehensive understanding of module behavior, moving beyond theoretical design to real-world application in 2026.
After enumerating the public API, Atlas delves into the actual implementation and usage patterns within your Godot project. It uses the `read` tool to examine the source code of each export, understanding its internal logic. Crucially, Atlas then employs `codebase_search` to find real-world examples of how these exports are called and utilized across your codebase. This includes analyzing GDScript files, identifying node paths accessed via `$` or `get_node()`, and understanding the role of autoload singletons defined in `project.godot`. This ensures that the documentation reflects the module's practical behavior and common usage scenarios, rather than just its intended design from a year ago.
How Atlas writes a README for a Godot module and matches existing style?
Atlas generates the README for a Godot module using its `write` tool, first `grep`ping the repository for an existing `README.md` to match its heading structure and tone rather than inventing a new format. This ensures consistency with your project's documentation standards, providing a familiar experience for developers in 2026.
When it's time to write the README, Atlas prioritizes consistency and adherence to your project's existing documentation style. Before generating new content, Atlas uses the `grep` tool to search your repository for an existing `README.md` file. This allows it to analyze and adopt the established heading structure, tone, and overall format. Once the style is understood, Atlas employs its `write` tool to construct the new README, quoting real GDScript signatures, actual file paths, and concrete examples derived from its analysis of your Godot codebase. This approach ensures the documentation is not only accurate but also direct integrates with your project's existing aesthetic.
How Atlas verifies code samples in Godot documentation?
Every code sample included in the generated Godot documentation is rigorously verified by Atlas using the `bash` tool, ensuring that each snippet is executable and accurate in 2026. A sample that was never executed is considered a liability, so Atlas runs them to confirm their functionality within your Godot project context.
Accuracy in documentation extends beyond descriptions to runnable code. Atlas takes a critical step to verify every code sample it includes in the generated Godot documentation. Using the `bash` tool, Atlas executes these snippets to confirm their functionality and correctness within your project's environment. This verification process is vital because a code sample that has not been executed is a potential source of error and frustration for developers. By running the samples, Atlas ensures that the documentation provides reliable, working examples that Godot developers can trust and integrate into their own `.gd` scripts.
What are Atlas's review and safety features for Godot documentation?
Atlas incorporates multiple safety and review mechanisms for Godot documentation, including a read-only plan agent that drafts a plan before switching to a build agent, and computing a unified diff for every file edit. This ensures that all proposed changes, like adding a new `README.md` or modifying `.gd` scripts, are transparent and require explicit approval in 2026.
Atlas is designed with robust safety and review features to give Godot developers full control over documentation changes. Before any modifications are made, Atlas drafts a plan in a read-only plan agent, which you must approve before it switches to a build agent. Every Atlas tool call, including `lsp`, `read`, `codebase_search`, `grep`, `write`, and `bash`, is permission-gated against allow, ask, and deny rules. For every file edit, such as creating a new `README.md` or modifying existing `.gd` scripts, Atlas computes a unified diff and surfaces it for your approval. Atlas also reads git branches, status, and diffs, and can stage and create commits on your behalf, providing snapshots of file changes as git patches so edits can be diffed and rolled back, ensuring complete transparency and control over your Godot project.
Step by step
- 01Run Atlas in your Godot project by navigating to the root directory containing `project.godot` and executing `atlas`.
- 02Let Atlas index your Godot codebase: Atlas automatically reads your `.gd` scripts, identifies node paths accessed with `$` or `get_node()`, and understands autoload singletons from `project.godot` settings.
- 03Ask Atlas to enumerate the module's public API: Atlas uses the `lsp` tool's `documentSymbol` operation to list all exported functions, variables, and signals.
- 04Instruct Atlas to read implementation and usage: Atlas employs the `read` tool for code details and `codebase_search` to find practical calls within your Godot project.
- 05Have Atlas `grep` for existing README style: Atlas searches for `README.md` files to match the established heading structure and tone.
- 06Ask Atlas to `write` the new README: Atlas generates the `README.md` content, incorporating real GDScript signatures and file paths.
- 07Review and approve Atlas's proposed changes: Examine the unified diff for the new `README.md` and any touched `.gd` scripts, then grant approval.
- 08Let Atlas verify code samples: Atlas uses the `bash` tool to execute and confirm the accuracy of all code snippets in the documentation.
- 09Optionally, let Atlas run `gdformat`: After documentation, Atlas can run `gdformat (gdtoolkit)` over any touched GDScript files for consistent formatting.
- 10Commit the changes: Atlas can stage the new `README.md` and any modified `.gd` scripts, then create a commit on your behalf.
Frequently asked questions
- How does Atlas ensure Godot documentation is up-to-date?
- Atlas generates documentation directly from your Godot project's source code, using tools like `lsp` and `read` to analyze current GDScript, node paths, and signals, ensuring it reflects what the code actually does today.
- Can Atlas document Godot modules that use `$NodePath` or `get_node()`?
- Yes, Atlas is designed to work with Godot's node tree, reading `.gd` scripts, the node paths they reach with `$` or `get_node()`, and autoload singletons defined in `project.godot` settings.
- How does Atlas handle code formatting in Godot documentation?
- Atlas can `grep` your repository for existing `README.md` files to match heading structure and tone. After generating documentation, Atlas can also run `gdformat (gdtoolkit)` over any touched GDScript files for consistent formatting.
- Does Atlas run Godot tests to verify documentation?
- While Atlas verifies code samples in documentation using `bash`, it can also integrate with `GUT (Godot Unit Test)`. Atlas can add `GUT` tests under `test/` and run them headless with `godot --headless -s addons/gut/gut_cmdln.gd` as part of a broader workflow.
- Is my Godot code sent to third-party servers when using Atlas?
- No, Atlas can build its code index with local Ollama embeddings, keeping your Godot project's code off third-party servers, ensuring privacy and security.
- How does Atlas prevent unwanted changes to my Godot project?
- Atlas employs a read-only plan agent, permission-gated tool calls, and computes a unified diff for every file edit, such as changes to `.gd` scripts or `README.md`, requiring your explicit approval before writing.
- Can Atlas help with Godot project setup for documentation?
- Yes, Atlas can operate within any Godot project containing a `project.godot` file at its root. It can read your `.gd` scripts, understand node paths, and even suggest replacing fragile `get_node` paths with `@onready var` and exported `NodePath`s.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Document a Module with a README Using Atlas (2026 Workflow)
How to document a module with a README using Atlas in 2026: the lsp tool's documentSymbol enumerates the real exports, read supplies the behavior, write emits the README.
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.
Run Atlas Headless in CI for Godot Projects in 2026
Automate Atlas sessions in your Godot CI/CD pipelines. Get machine-readable output for GDScript, node trees, and signals, integrating with GUT and gdformat.
Research a third-party API before integrating it in Godot with Atlas in 2026
Streamline third-party API integration in Godot with Atlas in 2026. Use Atlas to research API documentation, fetch details, and generate Godot-native code, ensuring compatibility with your `project.godot` and `gdformat`
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.
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.
Write unit tests for untested code in Godot with Atlas in 2026
Add real unit tests to your Godot projects with Atlas in 2026. Learn how Atlas uses GUT (Godot Unit Test) and gdformat (gdtoolkit) to match existing conventions and ensure code quality.