Objective comparison · measured facts · API-first

Do these two files match — and where?

Collate aligns separation plates against an approved 1-up — or N candidate PDFs against a reference sheet — and reports exactly where they differ: per-ink coverage and geometry deltas, which separations are missing or extra, and a raw match score. It states the numbers; your policy engine decides what's in tolerance.

Compare — Cloud hosted Self-host — open source →

AGPL-3.0 · plate ↔ 1-up + document ↔ document · measured deltas, never a verdict · built on codex

How it works

From two files to measured differences

Collate is the objective comparison layer of the stack: it reads facts from codex, measures where two files differ, and hands the numbers to the policy and viewer engines. Each engine owns exactly one job.

Extract

codex reads each file into stable, schema-versioned facts — per-separation coverage, screen ruling and angle, Pantone spot intents, dieline geometry. Collate consumes those facts; it owns no raster primitives of its own.

Compare

Collate aligns the two sides — a plate set against a 1-up, or N candidates against a reference sheet — normalizes ink names so the namespaces match, then measures: coverage delta per ink, geometry delta in millimetres, and which separations are on both, one, or neither.

Apply policy

lint takes the raw deltas and decides what's acceptable. Tolerances — the coverage percent or millimetre shift that fails a job — live in lint as policy, never in collate. The objective layer states the numbers; policy judges them.

Review

lens renders the result for a prepress operator — per-ink separations, the difference image, and the spots that moved. The visual inspection that turns a measured delta into a confident decision.

Comparison, as measured facts

Built for prepress teams and web-to-print platforms that need to know exactly where a file differs from the approved proof — without an engine guessing at the verdict for them.

Plate ↔ 1-up compare

Align a set of decoded separation plates (1-bit TIFF / Esko LEN) against an approved 1-up PDF. Collate reports per-ink coverage and geometry deltas and which separations are missing or extra — with an optional per-ink visual difference image.

Document ↔ document

Collate's “global vision” compare: one or more candidate PDFs against one reference — a single 1-up or a stepped, gang, or imposed sheet. Inks auto-align and each candidate is mapped to the reference instance it best matches.

Measured deltas, never a verdict

Collate ships coverage_delta_percent, geometry_delta_mm, and presence ∈ {both, plate_only, pdf_only}. No tolerance constant, no coverage_mismatch flag, no overall_match roll-up. It measures; lint decides whether a delta is out of tolerance.

Raw match score

Document compares carry a per-candidate match_score — a raw similarity in [0, 1] from the mean coverage delta over shared inks, minus a small penalty per missing or extra separation. A number, not a judgement: whether a score is acceptable is policy's call.

RFC 7807 + self-skip

Errors are Problem Details (application/problem+json), never a stack trace. When Ghostscript is unavailable the PDF side self-skips — plate-side facts plus pdf_rendered: false and a note — so a consumer never mistakes a non-render for a clean compare.

Self-host or hosted

AGPL-3.0 OSS you can run on Docker with Ghostscript, or call the in-process client straight from lint — one call shape whether collate is a sidecar or a library. Or use managed Print With Synergy hosting; same engine, managed and metered.

Where it fits

One job per engine

codex extracts the facts, collate measures the differences, lint owns the tolerances and verdicts, lens shows the result. Collate stays strictly in the objective layer — so the numbers it reports are never coloured by someone else's policy.

Built on codex

Collate owns no raster primitives of its own. It reuses codex for plate decode, the Ghostscript tiffsep separation render, ink normalization, and the Pantone catalogue. codex stays the extraction layer; collate is comparison built on top — no duplicated decode/coverage code to drift.

Tolerances live in lint

Collate never carries a coverage or millimetre threshold. It states the deltas; lint applies its LPDF_PLATE_CMP_* policy and returns the pass/fail. A non-render floors to INCONCLUSIVE in lint, not here. That clean split — measure here, judge there — is exactly why collate exists.

Schema-versioned facts

The neutral-facts contract (CollateCompareResult) is versioned by COMPARE_SCHEMA_VERSION, independent of the engine version. Additive fields don't bump the schema, so a downstream consumer can read new signals without a breaking upgrade.

Sidecar or in-process

The CollateClient is HTTP-first with an in-process fallback, so lint uses one call shape whether collate runs as a sidecar service or a library on the same host. Compare over HTTP in the cloud, or in process where they share a deployment.

Pricing

Free to self-host, managed when you want it

Run the comparison engine as a managed hosted service, or self-host the open source — same engine, you pick who runs it.

Open source

Self-hosted

Free

AGPL-3.0 · your infrastructure

Run the whole comparison engine yourself on your own Docker host. No quotas, no per-compare fees — ever.

Get the source →

Pros

Every capability — plate ↔ 1-up and document ↔ document
Call it over HTTP, or in process straight from lint
Your bytes never leave your deployment
Deploy on-prem or any cloud (Docker, with Ghostscript)

Cons

You provision and run the service + Ghostscript
You own upgrades, scaling, and monitoring
Community support only — no SLA

Cloud hosted

Collate · Managed

Usage-based

metered on the managed platform

Add managed comparison to your workspace. We run the service, Ghostscript, and the scaling — you call the API.

Compare with us

Pros

Fully managed — zero ops; we run the engine + Ghostscript
Per-tenant isolation, auth, quotas, and audit
Metered usage — pay for the compares you run
Feeds your prepress jobs' compare step out of the box
Automatic upgrades and backups, with support

Cons

Usage billed per workspace
Files processed in the managed cloud

The open-source edition is AGPL-3.0 and free forever. Managed pricing and any metered rates are shown when you connect a workspace.

Coming soon Cloud

The print-data integration hub — canonical jobs, orders, and customers kept in sync across your MIS, ERP, and prepress tools.

Visit site GitHub Cloud hosted