# Document a Module with a README in Unity with Atlas in 2026 > Atlas generates accurate README documentation for Unity C# modules by directly analyzing source code, ensuring your docs reflect current behavior rather than outdated specifications. Atlas empowers Unity developers in 2026 to generate precise README documentation for C# modules directly from source code, ensuring the documentation reflects the actual behavior of your MonoBehaviour scripts and ScriptableObjects today. By leveraging tools like the `lsp` for API enumeration, `read` for implementation details, and `codebase_search` for usage patterns, Atlas produces traceable documentation that integrates direct with your `Unity Package Manager (UPM)` projects, verifying code samples with `bash`. ## Key takeaways - Atlas generates Unity READMEs directly from C# source, ensuring accuracy in 2026. - The `lsp` tool precisely enumerates Unity C# module APIs, missing nothing. - Atlas uses `read` and `codebase_search` to document actual Unity code behavior and usage. - Every code sample in Unity READMEs is verified by `bash` execution. - Atlas provides unified diffs for all changes, maintaining control over Unity project files. ## How Atlas Documents Current Unity C# Module Behavior In 2026, Atlas ensures your Unity C# module documentation accurately reflects current code by analyzing source files directly, not relying on stale comments or outdated specifications. This process guarantees that READMEs describe what the code actually does today, preventing the common issue of documentation drifting from implementation over time. Atlas addresses the critical need for up-to-date documentation in Unity projects, especially where MonoBehaviour lifecycle order and per-frame allocations are crucial. Instead of generating plausible but potentially incorrect descriptions from memory, Atlas uses its `read` tool to parse the actual C# source code of your MonoBehaviour scripts and ScriptableObjects. It then cross-references this with real-world usage patterns found via `codebase_search`. This approach means every claim in the generated README is traceable back to a specific line of code or a concrete usage example within your `Assets/` folder or `Packages/manifest.json` resolved packages. This eliminates the risk of documenting features that were planned but never implemented, or describing behaviors that have since changed. ## Enumerating Unity Module APIs with Atlas and `lsp` To ensure no public API surface is missed or invented, Atlas leverages the `lsp` tool's `documentSymbol` operation to enumerate every exported member of a Unity C# module. This precise method guarantees a comprehensive overview of your module's capabilities, covering all 100% of its public interface as defined by the compiler. When documenting a Unity C# module, Atlas begins by performing a thorough enumeration of its public API. Using the `lsp` tool, specifically its `documentSymbol` operation, Atlas queries the language server to identify all exported classes, methods, properties, and fields within your C# scripts. This is crucial for Unity projects where components often expose public members for configuration in the Inspector or for interaction from other scripts. This step ensures that the generated README covers the entire public contract of your module, from `public void Awake()` methods to custom `ScriptableObject` fields, providing a complete and accurate reference for other developers integrating with your code. ## Reading Unity Code and Usage Patterns for READMEs After enumerating the API, Atlas employs its `read` tool to deeply analyze the implementation of each Unity C# export, then uses `codebase_search` to find how other scripts actually use it. This dual approach provides a 360-degree view, capturing both the intended logic and practical application within your `Assets/` folder, ensuring the documentation is grounded in reality. Understanding how a Unity C# module behaves requires more than just its public signature; it demands insight into its implementation and real-world usage. Atlas uses the `read` tool to parse the C# source code of each identified API member, extracting details about its internal logic, parameters, return types, and any specific Unity lifecycle considerations. For instance, it can identify if a `GetComponent` call is made in `Update`, which might indicate a per-frame allocation issue. Simultaneously, `codebase_search` scans your entire Unity project, including `Assets/` and `Packages/manifest.json` resolved packages, to find concrete examples of how other MonoBehaviour scripts or editor tools interact with the module. This combination allows Atlas to document not just what a method does, but how it is typically used in practice, providing valuable context for developers. ## Generating and Verifying READMEs for Unity Projects Atlas generates the README using the `write` tool, incorporating real C# signatures and Unity file paths, and then rigorously verifies every code sample. By executing each documented code snippet with `bash`, Atlas ensures that all 100% of the examples are functional and accurate, preventing the common pitfall of broken or misleading code in your `Assets/` documentation. Once Atlas has gathered all necessary information about a Unity C# module's API, implementation, and usage, it proceeds to generate the README. The `write` tool constructs the documentation, quoting real C# method signatures, class names, and actual Unity file paths like `Assets/Scripts/MyModule/MyComponent.cs`. Before finalizing, Atlas takes a crucial step: it verifies every code sample included in the README. Using the `bash` tool, Atlas attempts to execute these samples. This rigorous verification process catches errors in syntax, API usage, or environmental assumptions, ensuring that any code snippet a developer copies from the README will work as expected within their Unity project. This commitment to executable examples significantly reduces the liability of outdated or incorrect documentation. ## Atlas Safety and Review for Unity Code Documentation Atlas prioritizes safety and developer control throughout the documentation process for Unity projects, never making changes without explicit approval. Every Atlas tool call is permission-gated, and all proposed file edits, including new READMEs or modifications to existing ones, are presented as a unified diff for review. This ensures you maintain 100% control over your `Assets/` and `Packages/` content. Atlas is designed with a strong emphasis on safety and transparency, particularly vital in Unity projects where `.meta` files and scene YAML are sensitive. Before any tool is executed, Atlas checks against allow, ask, and deny rules, ensuring that operations like `write` or `bash` execution are explicitly permitted. When generating or updating a README, Atlas first drafts a plan in a read-only plan agent. Once the plan is approved, it switches to a build agent. Crucially, Atlas computes a unified diff for every file edit, including the creation of a new `README.md` or modifications to an existing one in your module's folder. This diff is surfaced for your approval before any changes are written to disk. This process guarantees that Atlas never touches sensitive Unity files like `.meta` files or scene YAML without showing you the exact changes first, giving you complete control and confidence in the documentation workflow. ## Steps 1. Initialize Atlas in your Unity project: Navigate to your Unity project root containing `Assets/` and `Packages/manifest.json`, then run `atlas`. 2. Allow Atlas to index Unity C# code: Grant Atlas permission to read your MonoBehaviour scripts, ScriptableObjects, and the packages resolved by the `Unity Package Manager (UPM)`. 3. Enumerate module API with `lsp`: Direct Atlas to use its `lsp` tool with the `documentSymbol` operation to identify all public members of the target Unity C# module. 4. Analyze implementation and usage: Instruct Atlas to use the `read` tool on the module's C# source files and `codebase_search` to find how other scripts in your `Assets/` folder utilize its exports. 5. Grep for existing README structure: Ask Atlas to `grep` your repository for an existing `README.md` file to match its heading structure and tone, ensuring consistency. 6. Draft the README with `write`: Request Atlas to use the `write` tool to generate the README, incorporating real C# signatures and Unity file paths. 7. Verify code samples with `bash`: Before approval, Atlas will use the `bash` tool to execute and validate every code sample within the drafted README. 8. Review and approve changes: Examine the unified diff presented by Atlas for the new or updated `README.md` in your editor, ensuring it meets your standards before committing. ## FAQ ### How does Atlas ensure Unity documentation is always up-to-date? Atlas generates documentation directly from your Unity C# source code using tools like `read` and `lsp`, rather than relying on outdated comments or memory. This ensures the README reflects the current state of your MonoBehaviour scripts and ScriptableObjects. ### Can Atlas document specific Unity lifecycle methods like `Awake()` or `Update()`? Yes, Atlas analyzes your C# code, including Unity-specific lifecycle methods. It can identify and document their purpose, and even suggest optimizations like hoisting `GetComponent` calls out of `Update` into `Awake` to reduce per-frame allocations. ### What if my Unity project uses `Unity Package Manager (UPM)` packages? Atlas is designed to read and understand code within your `Assets/` folder and any packages resolved by the `Unity Package Manager (UPM)` via `Packages/manifest.json`. It can document modules from both your local project and installed UPM packages. ### How does Atlas prevent accidental changes to Unity `.meta` files or scenes? Atlas never touches `.meta` files or scene YAML without explicit approval. All proposed changes, including new READMEs, are presented as a unified diff for your review before being written to disk, ensuring you have full control. ### Does Atlas verify the C# code examples it puts in the README? Absolutely. Atlas uses the `bash` tool to execute every code sample it includes in the generated README. This rigorous verification process ensures that all documented code snippets are functional and accurate within a Unity context. ### Can Atlas match the style of my existing Unity project READMEs? Yes, Atlas can `grep` your repository for an existing `README.md` file. It then uses this as a template to match the heading structure, tone, and overall format, ensuring consistency with your project's established documentation style. --- Canonical HTML: https://runatlas.sh/resources/stacks/document-a-module-with-a-readme-in-unity Source of truth: aeo_pages row `/resources/stacks/document-a-module-with-a-readme-in-unity` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.