SysCorpus builds living maps of real codebases: complete enough to trust, deep enough to take you all the way down to the code, and honest enough to tell you what they don't know.
This is not a screenshot. It is one block of HTML on this page, a miniature of the map with illustrative numbers, dressed by three stylesheets. The buttons are radio inputs and the switch is pure CSS. Open your inspector and watch while you click: the markup never changes. That separation is the standard we are building the product toward: a map's dress never welded to the map, all the way to dressing your own map in your own brand.
AI can now produce a working system in an afternoon. Understanding that system still takes as long as it ever did, and the tools we reach for assume knowledge the reader doesn't have yet. Class diagrams assume you know the object model. Dependency graphs assume you recognize the libraries. Documentation assumes someone kept it current.
The result is a widening gap between what exists and what anyone actually understands. Code gets reviewed without being comprehended, extended without being mapped, and trusted without being verified. Every serious decision about a system, whether to change it, buy it, secure it, or bet on it, rests on somebody's mental model of what it is. Those mental models are getting thinner while the systems get bigger.
SysCorpus exists to close that gap. Not with a summary, and not with a chatbot's paraphrase, but with a map: complete, navigable, and accountable for every claim it makes.
Point the engine at a codebase and it produces an interactive architecture map. Not a diagram someone drew once and let rot: a map generated from the code itself, regenerated as the code changes, and navigable from the whole system down to a single line.
The map carries a coverage ledger: every file in the codebase is either on the map or listed with a stated reason it isn't. No sampling, no approximation, no silent gaps. When the map can't account for something, it says so instead of pretending.
Structure, flow, data, rules, activity, capability, inventory, and design stress. The same map answers different questions depending on how you look at it, and a lens only appears when the underlying data can actually support its answers.
System, then component, then module, then file, then symbol, then the code itself, with documentation, tooltips, and tests along the way. Every level links back to the real repository, because the map is a way into the code, never a replacement for it.
Humans get the interactive viewer. AI agents get a structured front door: the same facts, exposed as tools they can call directly. Both are generated from the same underlying facts and checked against each other, so a claim appearing in one and not the other is treated as a defect, not a difference of opinion.
We will be publishing interactive maps of multiple widely used open-source codebases, beginning shortly and growing over time. Each one is kept fresh on a schedule, stamped with the exact commit it was built from, and held to the same gates: complete coverage, verified claims, and fair representation of its subject.
We're not announcing the subjects yet. When they arrive, they will be here, and you'll be able to judge the maps against codebases you already know. That's the point.
Where this stands, honestly.
SysCorpus is early and independent, the work of a very small team with a very large ambition. The engine, the viewer, the quality gates, and the instruments that measure whether a map actually teaches are built and tested. The public proof is what comes next, and we intend to prove it in public: demos on codebases you know, refreshed on a schedule, open to challenge and feedback at every step. We're confident, and we're also aware that confidence isn't evidence. This page states intent. The demos will carry the proof, or they won't ship.