The problem never went away
For years, Java teams had tools that made package structure, dependency cycles, and architectural drift visible. Stan4J gave you a precise lens on your package graph. Structure101 offered deep layer analysis, even if it took effort to get there. Both are gone. And the platforms that grew to fill that space moved in a different direction: fixed diagrams, rolled-up metrics, and steadily less resolution at the level where architecture decisions actually live. The problem stayed exactly where it was: inside real codebases, where boundaries blur, cycles accumulate, and architecture decisions get separated from the source they are supposed to govern.
The same gap exists for TypeScript. The go-to tool is dependency-cruiser, which maps your imports into a DOT file rendered to SVG via Graphviz, a static snapshot you can read but not navigate. ESLint with SARIF exports provides metrics. LCOV provides coverage data. All useful on their own, none of it integrated. The picture of the architecture is scattered across files and formats, with no single interactive tool to hold it all together.
AtlasArc started from that gap. The goal is not to recreate an old tool screen by screen. The goal is to bring the useful part back: a precise way to read the architecture you actually have, inside the IDE where the code already lives.
Built around a few beliefs
Architecture analysis should be local by default. A tool that reads source code should not need to upload the project to prove its value. AtlasArc runs inside IntelliJ IDEA and keeps the analysis on your machine.
Architecture work should also stay connected. A graph, a matrix, a heatmap, a subsystem view, and a report should not feel like five unrelated exports. AtlasArc builds one shared model and lets you inspect it through different lenses, so the same package, dependency, metric, and exception keeps its meaning as you move through an investigation.
Code architecture should be browsable. The tool should move at the user's speed and keep the right things in focus. AtlasArc has a strong navigable interface that lets you switch viewing angles and shift between focus modes, pinning subjects to reveal their neighbourhoods and expanding boundaries to follow dependency flows.
And exceptions should be governed instead of hidden. Some dependency problems are real defects. Some are accepted trade-offs. AtlasArc treats that distinction as part of the architecture: decisions can live with the source, be reviewed by the team, and be enforced in CI instead of disappearing into a private tool database. That way you can focus on real problems, not noise.
And metrics should be explorable, not fixed. A plot that combines coupling, complexity, coverage, and size on axes you choose reveals far more than a roll-up score ever can. That kind of flexibility used to exist in the ecosystem. AtlasArc's Hotspots lens brings it back.
Published by Seamra Works, built with a product point of view
AtlasArc is developed and published by Seamra Works. The product is built independently by Benny Bottema, a software architect with 20+ years of experience working across Java, Kotlin, and frontend systems where architecture was important enough to discuss but too hard to keep visible day to day.
The vision behind AtlasArc is fifteen years old. It took shape when Stan4J went dark, and sharpened over the years that followed. The goal was never just to recreate what had been lost. It was to build the tool that should have come next. Modern graph libraries and AI-assisted development finally made that possible.
AtlasArc isn't a generic diagramming surface, a metrics dump, or a dashboard you check once a quarter. It's a working cockpit for architecture questions: map the structure, find what's broken, expose the risky code, decide what to fix first, keep the exceptions you've chosen to live with, and report it all clearly enough that the team can act.
Try the workflow in your own project
The fastest way to understand AtlasArc is to run it on a codebase you already know. Start with the product overview, then install AtlasArc free from the JetBrains Marketplace and compare the architecture you remember with the one the code actually contains. The 30-day trial of the full workspace is optional.