How does Atlas handle large Fortran test outputs from `fpm test`?

Atlas's `bash` tool truncates terminal output at 2000 lines or 50 KB but always writes the complete `fpm test` log, including all `gfortran` diagnostics, to a retained file. You can then use `atlas read` to view the entire log for comprehensive analysis.

Can Atlas help me understand `gfortran` error messages during Fortran development?

Yes, Atlas captures all `gfortran` diagnostics in the full test log. By using `atlas grep` on this log, you can quickly find and group specific `gfortran` error patterns, helping you pinpoint the root causes of compilation or runtime issues in your Fortran code.

How does Atlas ensure I don't accidentally break my Fortran codebase when making changes?

Atlas employs several safety features: all tool calls are permission-gated, requiring your approval. It drafts plans in a read-only agent, and before writing any changes to your Fortran files or `fpm.toml`, it presents a unified diff for your explicit approval.

What Fortran project structure does Atlas expect for `fpm test` integration?

Atlas works direct with projects managed by `fpm`, expecting a standard `fpm.toml` configuration. It can read your Fortran modules, explicit interfaces, and `INTENT` declarations, and it supports `test-drive` unit tests located under the `test/` directory.

Can Atlas format my Fortran code automatically with `fprettify`?

Yes, Atlas can run `fprettify` over your changed Fortran sources. It will prompt for permission and then present a unified diff of the formatting changes for your review and approval before writing them to disk, ensuring your code adheres to style guidelines.

How does Atlas prioritize Fortran test failures for debugging?

Atlas encourages grouping failures by distinct root causes using `grep` on the full log, rather than by individual test names. These distinct causes are then recorded as `todowrite` entries with a "pending" status, creating a prioritized, actionable list for Fortran developers.

Can Atlas work with legacy FIXED-form Fortran code, or only modern Fortran?

Atlas is designed to work with both modern Fortran features like modules, interfaces, and coarrays, as well as legacy FIXED-form numerics. Its code indexing and search capabilities are effective across the full spectrum of Fortran codebases.

Run the Fortran Test Suite and Triage Failures with Atlas in 2026

Atlas empowers Fortran developers in 2026 to efficiently turn a wall of red `fpm test` output into a prioritized list of distinct root causes, leveraging its `bash`, `grep`, `todowrite`, and `edit` tools to streamline the debugging workflow for modern and legacy Fortran projects.

How to Run Fortran Tests with Atlas's bash Tool

In 2026, running a comprehensive Fortran test suite with `fpm test` can produce extensive output, often exceeding 2000 lines. Atlas's `bash` tool executes `fpm test` with a generous timeout, capturing the complete log even when it's massive.

When you instruct Atlas to run your Fortran test suite, it uses its `bash` tool to execute the `fpm test` command. For instance, `atlas bash "fpm test --compiler gfortran --flag -O3 --test-data test/data --timeout 300000"`. This command ensures that even slow-running Fortran tests, potentially involving complex numerical computations or I/O, are not prematurely terminated. Atlas is designed to handle the verbose output common in Fortran testing; if the output exceeds 2000 lines or 50 KB, Atlas automatically truncates the terminal display but writes the complete, untruncated log to a retained file. The path to this full log is clearly indicated in the terminal, allowing you to access every detail of your `gfortran` diagnostics and `test-drive` assertions without loss. This capability is crucial for Fortran projects where a single test run might generate hundreds of lines of output from various modules and subroutines.

Analyzing Fortran Test Failures for Root Causes with grep

After running `fpm test`, the challenge for Fortran developers in 2026 is to distill a potentially vast log of failures into a manageable list of distinct root causes, a task Atlas simplifies with its `grep` tool. This approach is crucial for logs that can easily exceed 2000 lines.

Instead of sifting through individual `test-drive` failure messages, Atlas guides you to group failures by their underlying root causes using its `grep` tool on the complete test log. For example, you might use `atlas grep "Segmentation fault" /path/to/full_log.txt` or `atlas grep "Error in subroutine calculate_flux" /path/to/full_log.txt` to identify common patterns. This is particularly useful in Fortran, where a single memory error or an incorrect array bound in a core module can cascade into multiple test failures across different `test/` unit tests. Atlas's ability to search the entire log, rather than just a truncated view, ensures that no critical diagnostic from `gfortran` or runtime error is missed. By focusing on these distinct patterns, you can identify the fundamental issues in your Fortran code, whether they stem from a `COMMON` block misuse, an interface mismatch, or an incorrect `INTENT` declaration.

Tracking Fortran Fixes with Atlas's todowrite Tool

Once distinct root causes for Fortran test failures are identified, Atlas's `todowrite` tool provides a structured way to track each required fix, ensuring no issue is forgotten. This creates a prioritized list, often containing 3 to 6 key takeaways for resolution.

With a clear understanding of the distinct root causes from your `fpm test` run, Atlas's `todowrite` tool allows you to create a prioritized list of fixes. For each unique issue identified, you can add an entry like `atlas todowrite "Fix array bounds in module_physics.f90" --status pending`. This transforms the wall of red output into actionable tasks. This is especially valuable in Fortran development, where complex numerical algorithms or legacy code often have interconnected issues. By tracking each distinct cause, such as "Incorrect `ALLOCATE` size in `solver.f90`" or "Mismatch in `INTERFACE` for `subroutine_io`", you ensure that fixes are systematically addressed. The `todowrite` entries serve as a persistent record, allowing you to manage the debugging process effectively and prevent issues from being overlooked in large Fortran codebases.

Iterative Fortran Development and Review with Atlas

Atlas facilitates an efficient iterative development cycle for Fortran, allowing you to fix issues one at a time using its `edit` tool and then re-run only the affected `fpm test` cases. This focused approach is one of the 4 documented workflow steps for triage.

After identifying a distinct root cause and adding it to your `todowrite` list, Atlas supports an iterative fix-and-verify workflow. You use the `atlas edit` tool to modify the relevant Fortran source files, such as `src/my_module.f90` or `test/unit_test_data.f90`. For example, `atlas edit src/data_processing.f90` opens the file for modification. Once changes are made, instead of re-running the entire `fpm test` suite, you can use `atlas bash "fpm test --only my_specific_test"` to target only the tests relevant to your recent changes. This rapid feedback loop is critical for Fortran development, where compilation times can be significant for large projects. Before committing, Atlas can also run `fprettify` over your changed sources, ensuring adherence to coding standards, and then presents a unified diff for your approval, showing exactly what changes will be written to your `fpm.toml` project.

Ensuring Code Quality and Safety in Fortran with Atlas

Atlas integrates robust safety mechanisms, including permission-gated tool calls and unified diffs, to ensure that all changes to your Fortran codebase are intentional and reviewed. This provides a critical layer of protection for `fpm` projects, especially in 2026.

Atlas prioritizes the integrity of your Fortran codebase. Every tool call, whether it's `bash` executing `fpm test`, `edit` modifying a `.f90` file, or `fprettify` formatting your sources, is permission-gated. This means Atlas will ask for your explicit approval before running any command that could alter your project. Before making any changes, Atlas drafts a plan in a read-only agent, allowing you to review the proposed actions. When it switches to a build agent to implement changes, such as moving a `COMMON` block into a `MODULE` or adding `test-drive` unit tests under `test/`, it computes a unified diff for every file edit. This diff is surfaced for your approval, providing a clear, line-by-line view of all modifications to your Fortran source files, `fpm.toml`, or other project assets. This rigorous review process, combined with the ability to snapshot file changes as git patches for easy rollback, ensures that all modifications, from fixing `gfortran` diagnostics to applying `fprettify` formatting, are transparent and fully controlled by the Fortran developer.

Step by step

01Run the full Fortran test suite: Use `atlas bash "fpm test --compiler gfortran --flag -O3 --timeout 300000"` to execute your `fpm test` suite, ensuring a generous 300-second timeout for complex Fortran computations.
02Access the complete Fortran test log: If Atlas's terminal output indicates truncation (e.g., "output truncated..."), use `atlas read /path/to/full_log.txt` to view the entire `fpm test` log, including all `gfortran` diagnostics.
03Group Fortran failures by root cause: Employ `atlas grep "Error message pattern" /path/to/full_log.txt` to identify distinct underlying issues, such as "Array index out of bounds" or "Uninitialized variable in module_name.f90", rather than individual `test-drive` failures.
04Record distinct Fortran failure causes: For each unique root cause, create a tracking entry with `atlas todowrite "Fix specific Fortran issue in src/file.f90" --status pending`.
05Edit the Fortran source code: Use `atlas edit src/problematic_module.f90` to open and modify the Fortran file identified as the source of the failure.
06Re-run affected Fortran tests: After making changes, validate your fix by running only the relevant tests with `atlas bash "fpm test --only specific_test_name"`.
07Approve Fortran code formatting and commit: Before finalizing, allow Atlas to run `fprettify` over changed sources and review the unified diff, then approve the changes to your `fpm.toml` project.

Frequently asked questions

How does Atlas handle large Fortran test outputs from `fpm test`?: Atlas's `bash` tool truncates terminal output at 2000 lines or 50 KB but always writes the complete `fpm test` log, including all `gfortran` diagnostics, to a retained file. You can then use `atlas read` to view the entire log for comprehensive analysis.
Can Atlas help me understand `gfortran` error messages during Fortran development?: Yes, Atlas captures all `gfortran` diagnostics in the full test log. By using `atlas grep` on this log, you can quickly find and group specific `gfortran` error patterns, helping you pinpoint the root causes of compilation or runtime issues in your Fortran code.
How does Atlas ensure I don't accidentally break my Fortran codebase when making changes?: Atlas employs several safety features: all tool calls are permission-gated, requiring your approval. It drafts plans in a read-only agent, and before writing any changes to your Fortran files or `fpm.toml`, it presents a unified diff for your explicit approval.
What Fortran project structure does Atlas expect for `fpm test` integration?: Atlas works direct with projects managed by `fpm`, expecting a standard `fpm.toml` configuration. It can read your Fortran modules, explicit interfaces, and `INTENT` declarations, and it supports `test-drive` unit tests located under the `test/` directory.
Can Atlas format my Fortran code automatically with `fprettify`?: Yes, Atlas can run `fprettify` over your changed Fortran sources. It will prompt for permission and then present a unified diff of the formatting changes for your review and approval before writing them to disk, ensuring your code adheres to style guidelines.
How does Atlas prioritize Fortran test failures for debugging?: Atlas encourages grouping failures by distinct root causes using `grep` on the full log, rather than by individual test names. These distinct causes are then recorded as `todowrite` entries with a "pending" status, creating a prioritized, actionable list for Fortran developers.
Can Atlas work with legacy FIXED-form Fortran code, or only modern Fortran?: Atlas is designed to work with both modern Fortran features like modules, interfaces, and coarrays, as well as legacy FIXED-form numerics. Its code indexing and search capabilities are effective across the full spectrum of Fortran codebases.

Try Atlas in your terminal

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

Install Atlas

Related guides

Run the Test Suite and Triage the Failures with Atlas in 2026

How to triage a failing test suite with Atlas in 2026: bash truncates at 2000 lines or 50 KB and saves the full log, then grep groups failures by root cause.

Atlas for Fortran: fpm.toml, Explicit Interfaces, and fprettify in 2026

Atlas is a terminal-native AI coding agent for Fortran in 2026. It reads modules, explicit interfaces, and intent declarations, runs fpm test behind a prompt, and runs fprettify.

Automate GitHub Issue and Pull Request Triage in Fortran with Atlas in 2026

Automate GitHub issue and pull request triage for Fortran projects using Atlas. Safely respond to PRs and issues, run `fpm test`, and format with `fprettify` for trusted users in 2026, ensuring code quality and security.

Migrate a deprecated API across every callsite in Fortran with Atlas in 2026

Streamline Fortran API migrations in 2026 with Atlas. Enumerate all callers, apply context-anchored patches, and validate changes with fpm test and fprettify for a complete, verified transition.

Plan a Multi-File Change in Fortran with Atlas Before Editing in 2026

Design and review complex Fortran code changes across multiple files using Atlas in 2026. Plan safely with fpm, fprettify, and gfortran integration before modifying a single line.

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

Fortran developers in 2026 use Atlas to add regression tests for bug fixes. Leverage fpm test (test-drive) to confirm failures and passes, ensuring robust code quality.

Audit a Fortran Repo with Parallel Subagents in 2026

Sweep your Fortran codebase for problems without context window limits. Atlas uses parallel subagents to audit fpm projects, leveraging fprettify and fpm test for comprehensive review in 2026.

Onboard to an Unfamiliar Fortran Codebase in 2026 with Atlas

Quickly build a working mental model of any Fortran repository using Atlas. Leverage semantic search, `fpm` package layouts, and `fprettify` formatting for rapid understanding and safe code exploration in 2026.

Browse this resource hub