Comparison Reports

A report turns the comparison on screen into a file you can hand over: attach it to a mail, drop it into a ticket, archive it as evidence of what changed between two states. Diffoniq writes reports as a self-contained HTML page or as plain text — interactively from File > Export Report..., or headless from the command line with /report.

Reports are read-only: nothing on either side is touched, and the report file is written wherever you point it. Unlike printing, the result is a file that can be forwarded, searched and kept. For driving /report from scripts or an AI assistant, see Scripting and AI Assistants.

The Export Report dialog

File > Export Report... reports whatever is on screen — a directory comparison, an archive comparison or a single file comparison — using the comparison that already ran; nothing is scanned again.

HTML page	A single self-contained file: colored rows, no external images, style sheets or scripts. Opens in any browser, prints cleanly, and follows the system's light or dark mode.
Plain text	UTF-8 text in aligned columns (folder report) or in a diff-like marker layout (file report) — readable everywhere, easy to grep or to diff against yesterday's report.
JSON	One document for programs — see JSON for scripts below. Pick this when something other than a human reads the result.
Include identical items/lines	Off for a folder report: identical files are counted in the summary but not listed, so the report is a list of changes. On for a file report, where the unchanged lines are the context. Turn it on or off as you need.
Open the report	Opens the finished file with whatever is registered for its type — usually the browser or the text editor.

Browse... opens the usual save dialog; the file type you pick there also sets the format. The suggested name combines both compared roots with a timestamp and lands in your Documents folder.

What is in a folder report

The header states both roots and the options the comparison ran with (subfolder depth, the active Ignore switches, rename detection) — a report should explain itself to whoever receives it. Then one row per compared item:

`different`	Both sides exist and differ
`only left`/`only right`	Exists on one side only
`identical`	Both sides agree (listed only with Include identical items)
`unverified`	Same size, but the content hash was still being computed (or was canceled) — never silently reported as identical. Let the background compare finish and export again.

Each side carries its path, size (<DIR> for folders) and timestamp. A pair found by rename/move detection is marked as renamed, and entries that live inside an archive are marked as such — a report of a ZIP comparison stays recognizable as one.

The Single files/Subdirectories view filters hide rows on screen only; a report always covers the whole comparison (it says so in the header when a filter is active).

What is in a file report

The HTML file report is the two panes side by side, with line numbers and changed, added and removed lines colored. The text file report uses one marker column instead, which keeps long lines readable:

    12     12    unchanged line
    13     13  < the old text
    13     13  > the new text
    14      -  - line only on the left
     -     15  + line only on the right

Command line (`/report`)

The headless twin of the dialog — it prints nothing and reports through an exit code, the report file and a log file:

Diffoniq /report <left> <right> --out <file>
        [--format html|text|json] [--include-equal] [--content]
        [--log <file>] [compare switches]

The shell does not wait by itself: Diffoniq is a windowed program, so a bare call returns immediately — use start "" /wait (cmd) or Start-Process -Wait (PowerShell, recipes in Scripting and AI Assistants); the --out file is written to a temporary name and appears only when it is complete.

`--out <file>`	Where to write the report (required). Missing folders are created.
`--format html\|text\|json`	Output format. Without it the extension of `--out` decides: `.txt` (also `.text`, `.log`) writes text, `.json` writes JSON, anything else HTML.
`--include-equal`	List identical items/lines too, not just count them.
`--content`	Decide by file content instead of size and timestamp: equal-sized pairs are hash-verified (using the hash cache, so repeat runs are cheap).
`--log <file>`	Write the run log elsewhere than `%APPDATA%\Diffoniq\report\`.

Two folders produce a folder report, two files a file report; archives may be used on either side. The compare switches of a normal start work here too — for example -s to include subfolders or the file mask on the paths — and the report header records what was in effect.

Result: exit code and log

`0`	Report written — no differences
`1`	Report written — differences found
`2`	The report file could not be written
`3`	Invalid arguments, or the comparison failed

The log is written to %APPDATA%\Diffoniq\report\report_YYYYMMDD_HHMMSS.log (the 30 newest are kept) unless --log <file> names a different location.

JSON for scripts

--format json (or the JSON option in the dialog) writes a single UTF-8 document instead of a page — for batch files, CI jobs and anything else that has to act on the result rather than read it. It avoids the two bad options a script has otherwise: hanging on the exit code alone (too coarse) or parsing the text layout (brittle).

{
  "diffoniq": {"version": "2.0", "reportVersion": 1, "licensed": true},
  "kind": "folder",
  "created": "2026-08-13T08:31:19Z",
  "left":  {"root": "D:\\work\\a", "archive": false},
  "right": {"root": "D:\\work\\b.zip", "archive": true},
  "options": ["Subfolders: included (max level 64)", ...],
  "summary": {"total": 5, "different": 3, "onlyLeft": 0, "onlyRight": 0,
              "identical": 2, "unverified": 0, "renamed": 1,
              "folders": 1, "files": 4, "listed": 3},
  "entries": [
    {"status": "different", "directory": false, "renamed": false,
     "left":  {"path": "docs\\readme.txt", "size": 18, "directory": false,
               "modified": "2026-08-13T06:57:39Z",
               "modifiedLocal": "2026-08-13 08:57", "inArchive": false},
     "right": {"path": "docs\\readme.txt", "size": 32, ...}}
  ]
}

status is one of different, onlyLeft, onlyRight, identical, unverified. Treat unverified as its own case — it means equal size with the content hash unresolved, never “identical”. Add --content if the script needs a decision.
A side that does not exist is null, so entry.right === null is exactly “only on the left”.
Sizes are numbers, never formatted text. modified is ISO 8601 UTC, or null when the source carries no UTC timestamp (archive entries) — modifiedLocal then still shows what the display shows.
inArchive marks an entry inside an archive, and the root object says which side is one.
A file comparison writes "kind": "file" and a lines array instead of entries: per line a status plus left/right objects of line (may be null for an inserted line) and text.
reportVersion changes only when an existing key changes meaning; new keys may appear without it. Encoding is UTF-8 with LF line ends, and text that is not valid UTF-8 (binary content in a compared file) is emitted as U+FFFD so the document always parses.
licensed is false when the report was written by an evaluation copy; the HTML and text formats say the same in their footer (“Generated by Diffoniq 2.0 evaluation version — diffoniq.com”), a licensed copy writes just “Generated by Diffoniq 2.0”. The report itself is complete either way — nothing is held back.

A nightly report

schtasks /create /tn "Nightly change report" /sc daily /st 06:00 ^
  /tr "\"C:\Program Files\Diffoniq\Diffoniq.exe\" /report D:\work \\nas\backup\work --out D:\reports\work.html --content"

Together with /sync this closes the unattended loop: the sync does the work, the report says what it found.

↑ File Menu