Comparing two versions

git diff tells you which lines moved, and does it better than anything else. It cannot tell you what moves changed:

• a routine present in one version and not the other
• a routine that writes to a table it did not write to before
• a signature whose types differ
• a call that resolves in one version and not the other
• an argument a caller passes that it did not pass before

A comparison in DunneFlow states those. It also works where a diff cannot: two directories with no shared history, such as this quarter's vendor drop against last quarter's.

Getting a second version#

A program directory holds one working snapshot, which each analysis replaces. To keep two, you seal the first:

# 1. analyse the older tree
uv run dunneflow analyze ~/code/some-project-2026-09-08/src --name some-project

# 2. seal it, with a label you will recognise
uv run dunneflow revisions output/some-project \
    --seal --label "some-project at f795bc3 - 2026-09-08"

# 3. analyse the newer tree into the same program
uv run dunneflow analyze ~/code/some-project/src --name some-project

With the application, drop uv run and use the program's own path, and use your maps folder instead of output/ (see Installing).

Check what a program holds at any time:

uv run dunneflow revisions output/some-project

revision               state            captured               files  label
2026-09-10T18:48:42Z   WORKING          2026-09-10T18:48:42Z      78
2026-09-10T18:48:30Z   FOR_COMPARISON   2026-09-10T18:48:30Z      73  some-project at f795bc3 - 2026-09-08

Sealing is a command, not a button. If you analyse into a program that already has a working snapshot, the dialog warns that it will rewrite it and suggests sealing first.

Choosing the pair#

With two or more versions, the version menu appears in the top bar. Its options are pairs: the version you are reading, which decides what the whole screen shows, and the version it is held against. on its own turns comparison off. A program with two versions opens comparing them, and your choice survives a reload and a server restart.

Which one is newer?#

DunneFlow does not know, and does not pretend to. The only instant it records is when it read the bytes, which says nothing about when the code is from. So the version strip carries the assumption as a button you can flip. Where both versions state version numbers that can be ordered, it says the order comes from their versions; where they cannot, it says assuming the compared version is newer. Beside it, captured: compared first (or the reverse) is a fact about when each was read, never used to decide the order. Flipping the assumption only relabels; nothing is re-queried.

What differs#

Open the Changes group in the navigator, or The whole comparison inside it. The bands are exclusive, so every routine that differs is in exactly one:

Alongside the bands, explained differently tags a rewritten comment or docstring on a row already in a band, and modules explained differently lists rewritten module docstrings. Prose is compared with line wrapping collapsed, so re-wrapping a comment is not a difference; docstring paragraphs are kept. Below the bands: ways in that appeared or vanished, named files, and constants.

Seeing the difference in the views#

• Routine list and Table mark each row with what the comparison found.
• Code draws the line difference over the source, and lists which routines behave differently and how. Lines from the other version appear where they belong, with their own numbers.
• Graph can colour by what changed.
• The anomaly worklist can say which findings the other version also has, and whose count, severity or confidence moved.

What is never done to your snapshots#

The two graphs are joined read-only for the length of a query. Neither snapshot is copied, moved or rewritten to be compared, and a sealed snapshot is never re-analysed in place. That is what makes a sealed snapshot useful: it stays readable after its source tree is gone.

For a step-by-step walk-through, see the tutorial Compare two versions.