DunneFlow

DunneFlow maps what moves through a program: where it starts, what it runs, what it touches, and why.

A program is started, fed inputs at its boundary, pulls more from its environment, moves things through its internal routines, and pushes results back out. What moves is the subject. Internal computation is not. DunneFlow reads a directory of source code, and the documentation beside it, and gives you a map you can walk around in: ways in, flows, routines, boundaries, database use, network and messaging, governance, a glossary, a naming standard and a list of anomalies.

Who it is for#

DunneFlow is built for someone orienting in a codebase they did not design, and for someone who reads code without necessarily writing it. It is particularly useful for code written by AI agents, where nobody may ever have read the whole thing: it shows you how information flows through the program before you open a single file.

The goal is comprehension, not documentation. Some things are deliberately left out: local variables, arithmetic, and private helpers that neither touch a boundary nor sit on a path to one. Leaving those out is most of what makes the map readable. Control flow is shown only where something moves inside it. A loop that increments a counter is not reported; a loop that makes one network call per item is a rate, and a rate is flow.

DunneFlow is not a code editor, a debugger or a profiler. It never runs your program.

Everything stays on your machine#

Nothing leaves your machine. No part of the analysis calls a model or opens a network connection, and DunneFlow's own test suite fails if anything on the analysis path starts importing an HTTP client or a model SDK. The dashboard is served locally and opened in your own browser, and it never fetches images or other remote content from the documents it shows you.

DunneFlow also never talks to a version control system. You bring it a directory of files; how the directory got there is up to you. See Getting the code.

Two promises#

These are worth knowing before you trust anything on the screen.

Every finding states what would make it a false alarm. An anomaly carries a severity (what it would mean for your program), a confidence (how sure DunneFlow is) and a blind spot (what would make it wrong). Those are three different questions, and DunneFlow never blurs them. Findings are produced by heuristic detectors and measurements over the map. They are not certainties: they are there to point your attention at places worth a look, and you judge each one.

Every reported meaning carries its provenance. A quoted definition proves itself with a file and a line you can click through to. A measured claim ships the SQL query that counted it, and you can run it yourself. A claim that was inferred says so.

Languages#

DunneFlow reads Python, TypeScript (.ts, .tsx, .mts and .cts, JSX syntax included), C++ and Kotlin. Python and TypeScript are read with call resolution; TypeScript is read by TypeScript's own compiler, so it needs Node.js 20 or newer. C++ and Kotlin are read syntactically. Every other file type, plain .js included, is counted and reported as unread, never silently dropped. See Installing.

Where to go next#

• Installing: the application for macOS, Windows and Linux, or running from source.
• Getting the code: preparing a directory to map.
• The start page and your first map.
• Your first map: the same thing as a step-by-step tutorial.

Martin Gardner wrote in Aha! Insight that "the sudden hunch, the creative leap of mind that 'sees' in a flash how to solve a problem in a simple way, is something quite different from general intelligence." DunneFlow is built for that moment. When you're reading code someone else wrote, whether a colleague's, a library's or an AI's, it works alongside your editor to show how the program and its data move, so the shape of the whole thing can click into place.