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 pageA 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 textUTF-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.
JSONOne 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 reportOpens 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. It also names every filter that left something out: a file mask on a path (Files listed: *.ini;*.json), the excludes and the .gitignore rules, so a filtered report never reads like a complete one. Then one row per compared item:

differentBoth sides exist and differ
only left/only rightExists on one side only
identicalBoth sides agree (listed only with Include identical items)
unverifiedSame 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.
not comparedCommand line without --content only: same size, contents not read. Counted in the summary and listed with --include-equal, but never called identical — a file changed without changing its size would otherwise pass unnoticed. It does not count as a difference for the exit code.

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 reports through an exit code, the report file and a log file (started through DiffoniqC.exe, the log lines also appear in the console):

Diffoniq /report <left> <right> --out <file>|-
        [--format html|text|json] [--include-equal] [--content] [--reverify]
        [--gitignore] [--only <status,...>] [--max-entries <n>]
        [--offset <n>] [--exclude <patterns>] [--under <folder>] [--collapse] [--folders <n>] [--defaults]
        [--skip-online-only] [--progress] [--log <file>] [compare switches]

From a script, call DiffoniqC.exe: Diffoniq.exe is a windowed program, so a shell neither waits for it nor sees its exit code. The console launcher DiffoniqC.exe next to it takes the same arguments, waits, prints the log lines and returns the exit code (Scripting and AI Assistants). The --out file is written to a temporary name and appears only when it is complete.

/report, -report and --report are the same. Use --report in Git Bash, which rewrites a leading slash into a path: /report arrives there as C:/Program Files/Git/report, and Diffoniq opens its window to compare that path instead of writing a report.

--out <file>Where to write the report (required). Missing folders are created. --out - writes the report to the standard output instead — for a script that reads it directly. The log lines then go to the standard error, so they never mix with the report.
--format html|text|jsonOutput format. Without it the extension of --out decides: .txt (also .text, .log) writes text, .json writes JSON, anything else HTML. On the standard output (--out -) the default is text.
--include-equalList identical items/lines too, not just count them.
--only <status,...>List only items (or lines) of these states, separated by commas: different, onlyLeft, onlyRight, unverified, notCompared, identical. The summary still counts everything. Example: --only onlyLeft,onlyRight lists what exists on one side only. renamed is no state but lists every pair the rename/move detection found, also an identical one.
--max-entries <n>List at most n items (or lines). The summary still counts everything, and in JSON omitted says how many were left out.
--offset <n>Skip the first n items (or lines) of the list before listing — the next page of a list that --max-entries cut. In JSON skipped says how many were skipped.
--exclude <patterns>Leave out files and folders matching these wildcard patterns on both sides, separated by semicolons (for example --exclude "*.bak;.obsidian"), like the Exclude fields of the window. An excluded folder goes with everything below it, and nothing of it is counted; the report names the patterns.
--under <folder>List only what lies below this folder, given relative to both roots — for example --under Docs\2024. The comparison still covers both trees completely and the summary counts all of it; the report adds how many items lie below the folder.
--collapseList a folder that exists on one side only once, with the number and size of what lies below it, instead of every file in it. A missing tree of thousands of files then takes one line. With --under pointing into such a folder, its first level is listed.
--folders <n>Add an overview: the n folders directly below the root (or below --under) with the most differences, each with its counts. It shows where a large comparison differs before the list does. When all differences lie in one folder that contains only one folder with differences, and so on, the overview goes down that chain and names the folders at its end.
--defaultsCompare with the factory settings instead of the ones saved by the window — for example without the window’s Ignore Case or Ignore Spaces. A script then gets the same result on every machine. Compare switches on the command line still apply.
--progressWhile the comparison runs, write a line to standard error every half second when it moved on: progress: scan <entries> while the folders are listed, progress: read <bytes done> <bytes total> <pairs done> <pairs total> while --content reads the files. The lines are not written to the log file. The MCP server uses them.
--skip-online-onlyNever download a file that a cloud service keeps online only. With --content such a pair is not read and counted as unverified, and the summary says how many; a file comparison of such a file is refused. Without the switch, reading the file downloads it, as in the window. Such a file is recognized by the attributes of the Windows cloud files API, which OneDrive, Dropbox and other providers set. Google Drive in streaming mode sets none of them, so a drive labelled Google Drive counts as kept online only as a whole: with the switch nothing is read from it (the root carries cloudDrive in the JSON), and a file comparison of a file on it is refused. A renamed drive is not recognized; its files are then downloaded when the content is compared.
--contentDecide by file content instead of size and timestamp: equal-sized pairs are hash-verified (using the hash cache, so repeat runs are cheap). Without it, no file is read: equal-sized pairs are reported as not compared, and the report header says so.
--reverifyLike --content, but every equal-sized pair is read again instead of being answered from the hash cache — the command-line twin of Re-verify Contents. Use it to check a backup: a file damaged or changed while its size and timestamp stayed the same is found only this way. Slower, because every file is read; the fresh checksums refresh the cache.
--gitignoreApply the .gitignore rules of both folders as an exclude filter. The report header then names how many entries the rules hid, so nobody takes the report for a complete one. A scripted run never inherits the window’s checkbox: without the switch, everything is compared.
--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, and so may a folder inside an archive (release.zip\release-2.4.0). A file beside a folder is compared with the file of the same name in that folder; if the folder has none, or the other side is an archive, there is no report and the exit code is 3. The compare switches of a normal start work here too — for example /c to ignore case, or a file mask on the paths — and the report header records what was in effect.

Result: exit code and log

0Report written — no differences
1Report written — differences found
2The report file could not be written
3Invalid arguments, or the comparison failed (for example an unreadable folder or an encrypted archive; the log names the cause)

The log is written to %APPDATA%\Diffoniq\report\report_YYYYMMDD_HHMMSS.log (the 30 newest are kept) unless --log <file> names a different location. It names the license the run saw (license: <licensee> (<file>) or license: none (evaluation)), so an evaluation note in a report can be traced to the machine that produced it.

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.4.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, "notCompared": 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, ...}}
  ]
}

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.