# Onboard to an Unfamiliar Fortran Codebase in 2026 with Atlas > Atlas empowers Fortran developers to quickly understand new codebases by semantically searching modules and leveraging `fpm` project structures. Atlas helps Fortran developers in 2026 rapidly build a working mental model of unfamiliar codebases by starting from meaning, not just filenames. It integrates directly with your Fortran Package Manager (`fpm`) projects, allowing you to explore modules, interfaces, and `test-drive` unit tests with precision, all while respecting your existing `fprettify` formatting and ensuring every action is permission-gated. ## Key takeaways - Atlas indexes Fortran AST declarations for precise understanding of `MODULE`s, `INTERFACE`s, and `INTENT` declarations. - Explore `fpm` projects efficiently with semantic search (`codebase_search`) and directory mapping (`glob`). - Atlas permission-gates all actions, including `fpm test` and `fprettify`, requiring explicit approval for Fortran code changes. - Refactor legacy Fortran constructs like `COMMON` blocks into modern `MODULE`s with Atlas's assistance. - Use `todowrite` to persist learning and open questions about your Fortran codebase across Atlas sessions. - Atlas can build its code index with local Ollama embeddings, keeping your Fortran code off third-party servers. ## How does Atlas understand Fortran code structure and dependencies? Atlas builds a deep understanding of Fortran code structure by indexing AST declarations, not blind line windows. This allows it to precisely map modules, explicit interfaces, and coarrays within your `fpm.toml` project, providing a 2026 developer with an accurate mental model from the first query, even for complex dependencies. Atlas uses advanced AST (Abstract Syntax Tree) declarations, powered by tree-sitter, to index your Fortran codebase. This means it understands the actual structure of your `MODULE`s, `INTERFACE` blocks, and `INTENT` declarations on dummy arguments, rather than just scanning lines of text. When you ask `codebase_search` a question like 'how requests are authenticated', Atlas queries this semantic index, returning highly relevant Fortran snippets and file paths. It can identify where a `USE` statement originates and where a `MODULE` is defined, providing a precise map of your Fortran project's internal dependencies, whether it's a modern `fpm` project or a legacy system. ## How do I explore an unfamiliar Fortran repository with Atlas? Exploring an unfamiliar Fortran repository with Atlas begins by querying its semantic index, then mapping the directory shape. You can ask 'how requests are authenticated' and Atlas will return ranked snippets, often pointing to key `module` files, allowing you to focus on the 2 or 3 most relevant files first, saving significant time in 2026. The onboarding workflow with Atlas is designed for efficiency. First, use `codebase_search` with a plain-language question to find relevant Fortran code snippets. For instance, `atlas codebase_search "how are database connections managed?"` might point you to a `database_module.f90` file. Next, run `glob` on the top-level directories to quickly grasp the `fpm` package layout and naming conventions, such as the common `src/` and `test/` directories. Then, `read` the two or three Fortran files `codebase_search` ranked highest. From there, use the `lsp` tool's `goToDefinition` operation to follow `USE` statements and explore related `MODULE`s or `INTERFACE`s. For wider sweeps, delegate to the `explore` subagent via the `task` tool; it's permissioned read-only, ensuring it cannot alter your Fortran codebase while it looks around. ## How does Atlas ensure safe Fortran code exploration and changes? Atlas prioritizes safety and control when working with Fortran code, ensuring every action is permission-gated. Before any tool call, like running `fpm test` or applying `fprettify`, Atlas asks for your explicit approval, providing a unified diff for review in 2026, giving you complete oversight of proposed changes. Safety is built into Atlas's core. Every Atlas tool call, whether it's `read`, `bash`, or `lsp`, is permission-gated against allow, ask, and deny rules. This means Atlas will always prompt you before executing commands like `fpm test` to run your `test-drive` unit tests or `fprettify` to format your Fortran sources. Atlas drafts a plan in a read-only plan agent first, asking for your approval before switching to a build agent that can make changes. For every file edit, Atlas computes a unified diff and surfaces it for your approval before writing. Furthermore, Atlas snapshots file changes as git patches, so any edits it proposes to your Fortran files can be easily diffed and rolled back, providing a robust safety net for your codebase. ## Can Atlas help me add Fortran unit tests or refactor common blocks? Yes, Atlas can assist with specific Fortran development tasks, such as adding `test-drive` unit tests under the `test/` directory or refactoring `COMMON` blocks into modern `MODULE`s. It can even run `fpm test` behind a permission prompt and iterate on `gfortran` diagnostics, streamlining your workflow in 2026. Atlas is not just for exploration; it's a powerful assistant for Fortran development. You can ask Atlas to move a legacy `COMMON` block into a modern `MODULE` or to add `test-drive` unit tests for a specific subroutine under the `test/` directory. Atlas can then run `fpm test` to execute these tests, prompting you for permission first, and help you iterate on any `gfortran` diagnostics that arise. Once changes are made, you can have Atlas run `fprettify` over the changed Fortran sources. It will then present a unified diff of the formatted code for your approval, ensuring your codebase remains consistent with your team's formatting standards before you approve the final commit. ## Steps 1. Start Atlas in your Fortran project, ensuring an `fpm.toml` file is present for package management. 2. Use `atlas codebase_search "how are requests authenticated?"` to semantically query your Fortran codebase and identify relevant `MODULE`s or subroutines. 3. Run `atlas glob` on the top-level directories to quickly understand the `fpm` package layout and common Fortran file naming conventions. 4. Execute `atlas read ` on the 2-3 highest-ranked Fortran source files, then use `atlas lsp goToDefinition` to follow `USE` statements and explore related `MODULE`s. 5. Delegate wider exploration to the read-only `explore` subagent with `atlas task "explore the test/ directory for fpm test examples and common block usage"`. 6. Record open questions, findings, and future tasks as a `todowrite` list, for example: `atlas todowrite "Investigate module_x's dependency on external_library.f90"`. 7. Ask Atlas to add `test-drive` unit tests for a specific Fortran `SUBROUTINE` under the `test/` directory, then approve `fpm test` execution. 8. Have Atlas run `fprettify` over any changed Fortran sources and review the unified diff before approving the write operation. ## FAQ ### How does Atlas handle Fortran `MODULE` dependencies and `USE` statements? Atlas uses AST indexing to understand `MODULE` declarations and `USE` statements, allowing it to accurately map dependencies and navigate your Fortran codebase. It can trace where a module is defined and where it is used, providing a clear picture of your project's structure. ### Can Atlas run `fpm test` for my Fortran `test-drive` unit tests? Yes, Atlas can run `fpm test` for your `test-drive` unit tests, but only after you approve the permission prompt. It can also help you iterate on `gfortran` diagnostics, streamlining the testing and debugging process for your Fortran code. ### Does Atlas support `fprettify` for Fortran code formatting? Absolutely. Atlas can run `fprettify` over changed Fortran sources. It will present a unified diff of the formatted code for your approval before writing any changes, ensuring your Fortran codebase adheres to your preferred style. ### How does Atlas ensure my Fortran code isn't sent to third-party servers? Atlas can build its code index with local Ollama embeddings, ensuring your Fortran source code remains entirely on your machine. This keeps your proprietary Fortran code off third-party servers, maintaining data privacy and security. ### What if I want to roll back changes Atlas made to my Fortran files? Atlas snapshots file changes as git patches. This means any edits it proposes to your Fortran files can be easily diffed, reviewed, and rolled back if needed, providing a robust mechanism for managing and undoing changes. ### Can Atlas help me understand legacy FIXED-form Fortran code? Yes, Atlas is designed to work with modern Fortran, from legacy FIXED-form numerics to modules, interfaces, and coarrays under the Fortran Package Manager. It can provide context and assist in understanding various Fortran styles, including older codebases. ### How does Atlas handle `gfortran` compiler diagnostics for Fortran code? Atlas can run `fpm test` and process `gfortran` diagnostics. It can help you understand and iterate on compiler errors or warnings, guiding you through the process of resolving issues in your Fortran source code. --- Canonical HTML: https://runatlas.sh/resources/stacks/onboard-to-an-unfamiliar-codebase-in-fortran Source of truth: aeo_pages row `/resources/stacks/onboard-to-an-unfamiliar-codebase-in-fortran` (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.