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.
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.
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:
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. |
not compared | Command 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).
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
/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] [--convert] [--ignore-blank-lines] [--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|json | Output 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-equal | List 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. |
--collapse | List 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. |
--defaults | Compare 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. |
--progress | While 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, progress: convert
<name> before --convert turns a file into
text. The lines are not written to
the log file. The MCP server uses
them. |
--convert | Compare two Word, Excel, PowerPoint, OpenDocument, EPUB or JSON files as the text the built-in converters make of them, as the window does. Only the built-in converters run, never your own converter rules, and only when both sides are files: a folder comparison stays byte for byte. The report names the converter of each side, or why a file could not be converted (then it is compared as it is), and says whether the files are also identical byte for byte: equal texts do not make equal files. Line numbers count the lines of the converted text, not pages. Without the switch the bytes are compared, as before. |
--ignore-blank-lines | A file comparison
passes over lines that are empty or hold only spaces and tabs: a
blank line that exists on one side only, or is blank on both, is
neither listed nor counted, and the JSON summary says in
ignoredBlank how many there were. A blank line against
a line with text stays a change. Useful when converted documents
differ mostly in empty paragraphs. The window has no such
option. |
--skip-online-only | Never 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. |
--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). Without it, no file is read: equal-sized pairs are reported as
not compared, and the report header says so. |
--reverify | Like --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. |
--gitignore | Apply 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.
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 (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.
--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.1", "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, ...}}
]
}
status is one of different,
onlyLeft, onlyRight, identical,
unverified, notCompared. Treat
unverified and notCompared as their own
cases — both mean equal size with the content unknown,
never “identical” (notCompared: the run was
told not to read contents). Add --content if the script
needs a decision.null, so
entry.right === null is exactly “only on the
left”.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.onlineOnly marks a side kept online only by a cloud
service; summary.onlineOnly counts the unverified pairs
that --skip-online-only left unread. A root on a drive
that streams its files from the cloud carries
"cloudDrive": "Google Drive"; with
--skip-online-only every file of that side is marked
onlineOnly."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. Its left and right root
objects say in content what each file was read as:
text, binary (size, hash and the first
differing offset instead of lines), image (pixel rows,
no text) or version (the version information of a
program), and in size (bytes) and modified
(ISO 8601 UTC) the size and last change of the file you named —
the original, also when it was converted. With --convert a converted side carries
converted (the converter, such as
"Word (built-in)"), a side that could not be converted
converterError (why: "password-protected (encrypted
Office document)", "older binary format (Word
97-2003)"), and the report bytesIdentical: whether
the two files are equal byte for byte. When one side converts and the
other cannot, both are compared byte for byte and the report says
"comparedAsBytes": true. A converted spreadsheet side
lists sheets (name, rows: its
last row), and each of its lines carries sheet and
row, the row in the sheet. A converted presentation side
gives its number of slides, and each of its lines
slide and part ("slide" or
"notes"); a line of a converted document carries its
section ("body", "footnotes",
"endnotes", "header", "footer",
"headersAndFooters" for an old .doc,
"textBoxes"). The converter states these places while it
writes the text; nothing is guessed from the text. Two Office files that are not
identical byte for byte while their texts are equal, or compared
without --convert, get packageParts: in
container whether they are ZIP packages
("zip": .docx, .odt and their kin) or old Office files
("ole": .doc, .xls, .ppt, whose parts are the streams of
a compound file), how many parts are identical, different or on one
side only, the parts that are not identical, and the
properties that changed — from
docProps/core.xml, docProps/app.xml,
meta.xml or the summary information of an old file
(part, name, left,
right). The root stays the original file.--collapse, the entry of a folder that exists on one
side only carries items and bytes: what lies
below it, counted in the summary but not listed. --under
adds scope (the folder and its counts),
--folders adds folders (path and counts,
most differences first; "." stands for the files directly
in the root) and foldersMore (folders with differences
that did not fit). renamed in the summary counts every
pair of the rename/move detection, also identical ones the list leaves
out; renamedUnlisted says how many of them are not listed,
and --only renamed lists them all. A name in two Unicode
forms (for example an umlaut as one character on one side and as a
letter plus dots on the other, as some cloud services store it) counts
as renamed: Windows treats the two as different names. When the overview went down a chain of single
folders, foldersBelow names its end, and the files
directly in it are the entry with that path and
"filesOnly": true.reportVersion changes only when an existing key changes
meaning; new keys may appear without it. Since 2.0.1 a
run without --content no longer counts same-size pairs as
identical but as notCompared: a script that
expects identical to equal the number of files, or knows
only the earlier status values, has to accept the new one. 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.4.1
evaluation version — diffoniq.com”), a licensed copy writes
just “Generated by Diffoniq 2.4.1”. The report itself is
complete either way — nothing is held back. In the HTML footer
the domain is a link with a fixed campaign tag (see
Links to the Diffoniq website); it is the
same in every report and identifies neither you nor the recipient.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.