Obsign  ·  by Coherence Energy Labs™

Computation you can prove.

Write a kernel once. Run it on CPU or GPU. Ship a cryptographic receipt anyone, on any machine, can re-execute to confirm the result bit-for-bit. Don't trust it. Re-run it.

Prove the computation on your photo → Watch CPU = GPU, live
Deterministic
Bit-identical across CPU, GPU and native - engineered, then proven live in your browser.
Accountable compute
Every edit is reversible, signed, and re-runnable. The original is always recoverable.
Provenance you re-run
Not a watermark you trust. A proof you execute. Standard-aligned with C2PA.
scroll
The claim, executed

Your CPU and your GPU
will agree to zero ULP.

GPU floating-point is non-deterministic by default - the same code gives different bits on different hardware. Obsign runs its kernels in a fixed-point integer mode where every substrate computes byte-for-byte the same answer. Here is that mode, running the framework's own coherence-field PDE, right now, on your machine.

  1. 1
    We evolve the same screened reaction-diffusion field twice - once on your CPU (JavaScript integer math), once on your GPU (a WebGPU compute shader).
  2. 2
    Both results are hashed with SHA-256 in your browser. Nothing is uploaded.
  3. 3
    If the hashes match, you have just watched two different processors produce an identical result - the thing the entire compute-trust problem says is hard.
See a full signed certificate →
obsign · tau_field · fixed-point i32 96×96 · 80 steps
CPU-
awaiting run
GPU · WebGPU-
awaiting run
Press Run to prove it on your hardware
detecting GPU…
Don't trust us

Re-run it.

Every Obsign output ships a signed receipt. Paste one into the verifier and your browser re-hashes the claim and checks the Ed25519 signature locally - the same way a Content Credentials viewer would. Nothing is uploaded, ever.

The free public verifier
100% client-side. Re-hashes the receipt, verifies the signature, and tells you plainly: authentic, unsigned, or altered. Verification should be a public good - so it is free, forever.
Ed25519 cryptographic signature, checked in Web Crypto
SHA-256 integrity, recomputed from the receipt's own contents
Open the verifier → Download a sample receipt
The category nobody else has

Computation you can hold accountable.

The world is racing toward generative output that hallucinates, can't be reproduced, and can't be undone. Obsign inverts every one of those: a deterministic integer operation whose output is bit-reproducible, whose every changed pixel is receipted, and whose original is always recoverable.

Accountable computation: input, enhanced, exactly what changed, the coherence map, and the invention map
input · enhanced · what the operation changed · coherence · invention

Obsign preserves the original, hashes it, and receipts the exact pixel diff - precisely what the operation added. A structure-tensor coherence map measures trust; large changes in low-structure regions light up the invention map as suspicious.

original = enhanced − diff   // bit-exact, always

The enhancement is provably reversible. You can always get the source image back, exactly, and prove that the receipt belongs to it. Generative quality becomes transparent, reversible, and usable in trust-critical work.

Run it on your own photo → See a signed certificate
Bring any model

Three tiers of provability.
Accountability never disappears.

From a bit-exact integer model to a frontier diffusion network, Obsign wraps any architecture in the strongest guarantee it can honestly support - and degrades gracefully, never to zero.

A

Bit-exact

DETERMINISTIC · CROSS-DEVICE

Quantized integer inference. Identical to the last bit on CPU, GPU, and native C++. Re-run it anywhere and it reproduces. This is the flagship.

B

Reproducible

SEEDED · ANY TORCH MODEL

Any neural network, run with fixed seeds and deterministic ops, wrapped in an accountable receipt. Reproduce it on the same setup; the diff is still receipted and reversible.

C

Accountable

ANY OUTPUT · ANY MODEL

Even a black-box generative model gets the preserved original, the signed diff, and the coherence and invention maps. You always know exactly what changed, and can undo it.

When there is no receipt

Two regimes. One examiner.

A receipt gives certainty. But most files in the world arrive with no provenance at all. For those, Obsign runs a forensic panel that localizes traces and reports calibrated evidence - and, uniquely, the analysis itself is deterministic, signed, and re-runnable: another examiner re-runs the exact pipeline and gets a bit-identical report. The way forensic science is supposed to work.

Deterministic findings

Copy-move cloning (localized at source and destination) and editor-signature byte facts (Photoshop, Topaz, GIMP, Office) - exact and reliable, on images and PDFs.

facts

Calibrated evidence

Noise, CFA/demosaic and resampling detectors flag traces with explicit confidence and limits - never a verdict. Absence of a finding never establishes authenticity.

not proof

Re-runnable + signed

Most forensic tools are black boxes. Obsign's report reproduces to the bit and is signed - the reproducibility Daubert and NIST actually ask for.

Regime A vs B
Run the forensic examiner → Inspect Content Credentials
Why this has to exist

Whole markets cannot buy
what they need.

GPU floating-point is non-deterministic by default.
Bit-identical CPU↔GPU output is a hard, engineered capability. CERN's ALICE built a special mode just to compare GPU to CPU bitwise; NVIDIA's own docs warn results "may not be bit-identical."
// the determinism nobody ships
Forensic enhancement isn't reproducible.
NIST flagged that standard forensic image enhancement is non-reproducible and asked for a deterministic, auditable alternative. Court admissibility (Daubert / FRE 702) turns on testability and reproducibility.
// the beachhead: court-admissible imaging
Provenance proves that, not what.
C2PA / Content Credentials log that an edit happened and a hash of the result. They cannot re-run the edit. The deterministic, reversible operation itself is the gap the standard leaves open. Inspect any image's credentials →
// ride the rails, fill the gap

The whitespace Obsign owns

Nobody productizes provably-deterministic, auditable, programmable image and compute transforms. Capture-provenance is commoditizing - cameras and labs already sign at the source. Edit-provenance, the part regulation is forcing and no one has solved, is wide open.

Bit-identical substrates6 - CPU, GPU, Rust, FFI, C++, .cl
Standard alignmentC2PA / Content Credentials
Ships asSDK · CLI · OFX plugin
Compute you can prove, on your own input

Program your camera in .cl.

Write a per-pixel kernel in Coherence Language. Obsign's compiler turns it into a GPU shader inside your browser and runs it live on your webcam - with a receipt that proves the CPU and GPU paths produced the same pixels. The same engine that powers the SDK, running on glass.

Live, on-device

getUserMedia → GPU shader → canvas, compiled from your .cl source in real time. Nothing leaves the page.

WebGPU

One source, every target

The same kernel lowers to WGSL on the GPU and to native integer code on the CPU - and they agree bit-for-bit.

.cl → WGSL / native

Receipted by construction

A live CPU=GPU readback comparison proves the transform is reproducible before you ever trust the output.

0-ULP
Launch the camera compiler → Explore the whole engine Enter the field in VR →
Built for trust-critical work

Where "probably fine" isn't good enough.

Forensics & courts

Deterministic, auditable enhancement with a chain-of-custody report shaped for Daubert / FRE 702. The examiner re-runs it; the result is identical.

Beachhead

Newsrooms & C2PA

A real Content Credentials edit step that adds something the standard can't: the operation re-runs and reverses. Unbroken provenance chain.

Standard-aligned

Post-production

An OFX plugin that ships the model into Resolve and Natron, with tile-invariant output - no seams, bit-identical regardless of how the host tiles the frame.

OFX

AI labs & platforms

Wrap any model - even your best closed one - in a provable, reversible, signed layer. Sell trust over commodity quality.

Tier A–C
The honesty line

What this is, and what it isn't.

If the trust pitch isn't honest, the whole thing collapses. So here is the calibrated truth.

What Obsign is

  • A working platform: SDK, CLI, native core, OFX plugin, and a free verifier.
  • Genuine 0-ULP determinism across six substrates, and reversible, signed edits.
  • The strongest proof-of-idea in a near-empty lane: edit-provenance you re-run.
  • Standard-aligned with C2PA, not competing with it.

What it isn't - yet

  • Not a deployed product with paying customers. We are seeking the first design partners.
  • Receipts here are signed with development keys; production trust needs a CA cert on the C2PA trust list.
  • Not the world's best pixel quality - the paid value is provability and accountability, not PSNR.
  • The court rules on admissibility. The tool confirms the technical criteria; it cannot promise the verdict.
Coherence Energy Labs™

Be the first to ship
computation you can prove.

We are looking for design partners in forensics, journalism, and post-production - the places where reproducible, reversible, signed compute changes what is possible. The bottleneck is validation, not code. If that's you, let's talk.

Become a design partner Verify a receipt See a certificate