AI restoration invents history. Trueprint proves what's real.
When AI "restores" an old black-and-white photo, it doesn't recover the true colors. It makes a plausible guess. The guess looks beautiful, and once it spreads, nobody can tell which parts were real. Trueprint restores old photos and audio just like the best AI tools, but it also hands you a verifiable record of exactly what was original, what was cleaned up, and what the AI made up. Every result is sealed with cryptographic hashes and stored on Backblaze B2, so anyone can check it, forever.
Built for the Backblaze Generative Media Hackathon on Backblaze B2 + Genblaze.
Try it live: https://trueprint-production.up.railway.app Demo video: (add link)
Archives, museums, journalists, and families all want to bring old media back to life. But a restored photo that hides what the AI invented quietly corrupts the historical record. This is a real, timely problem: in 2026 the Library of Congress put out a call for tools that keep AI-touched collections authentic and verifiable, the EU AI Act began requiring machine-readable AI labels (Article 50), and the Ansel Adams Trust publicly condemned an undisclosed AI-colorized photo. Trueprint is built for that moment: restoration you can actually cite.
- Restores an old photo (or a noisy audio clip) with real AI models, orchestrated through Genblaze.
- Reveals what's real. It colorizes each photo with two independent AI providers and compares them. Where they agree, the color is grounded. Where they disagree, the AI is guessing, and Trueprint shows you exactly where (a confidence heatmap) and what they disagreed on (e.g. "necktie: black vs navy").
- Never fakes structure. The AI only supplies color; the original's shapes and detail are locked in place, so the restoration stays faithful by construction. Super-resolution and face handling are measured and disclosed, never silently invented.
- Proves it. Every result carries a signed C2PA Content Credential (the standard behind Adobe, the BBC, and the New York Times), a hash-verified manifest stored on Backblaze B2 next to an untouched original, and a public certificate page anyone can open and check.
- Works for audio too. A noisy archival clip is cleaned with a subtractive filter that can only remove noise, never invent sound, so audio is 0% fabricated by design, with a real measured quality gain.
- Live app: https://trueprint-production.up.railway.app (pick a sample, it restores instantly)
- Example certificate: open any result, click Public certificate, and share the link
- Run the tests locally (no accounts or keys needed):
python -m venv .venv && ./.venv/Scripts/activate # Windows (macOS/Linux: source .venv/bin/activate)
pip install -r backend/requirements.txt
pytest # 14 tests, all greenThe whole idea in one picture: restore, measure what's real vs. invented, sign it, and store it durably so it can always be verified.
flowchart LR
IN["Old photo<br/>or audio clip"] --> PIPE
subgraph PIPE ["Restore + measure (Genblaze pipeline)"]
direction TB
S1["Analyze<br/>(what's damaged, what's knowable)"] --> S2["Restore<br/>colorize x2 / denoise"]
S2 --> S3["Measure what's real<br/>vs. AI-invented"]
S3 --> S4["Sign<br/>C2PA credential"]
end
PIPE --> B2[("Backblaze B2<br/>untouched master +<br/>hashed provenance")]
B2 --> OUT["View · Verify · Certificate"]
Every step is recorded the moment it happens, so the "what's real" map is measured, not guessed after the fact. The same shape works for both photos and audio; only the engine in the middle changes.
B2 is the system of record, not just a file dump:
- Immutable originals. Every uploaded master is stored under Object Lock, so the source can never be quietly altered.
- Full archive layout. Masters, restored outputs, authenticity/confidence maps, super-res and face maps, audio + spectrograms, and a JSON manifest per run, all in a clean, queryable folder structure.
- Trust that travels. Results are served, verified, and re-hashed straight from B2. Change one byte of a downloaded file and verification catches it.
- Every restoration runs through the Genblaze Pipeline (steps, inputs, provider abstraction) with B2 wired in as the storage sink and Object Lock config.
- We wrote two custom Genblaze providers so both colorizers (Google Gemini and OpenAI gpt-image) run through Genblaze's pipeline, manifest, and lineage machinery.
- Multi-provider corroboration: the two providers colorize independently, and their disagreement becomes the confidence map. This is the heart of the product.
- LLM-as-judge: a Genblaze evaluator scores each result for implausible fabrication (it caught a real artifact during development and drove the fix).
- Genblaze's own hash-verified run manifests (real run IDs + canonical hashes) are folded into Trueprint's manifest and shown on every result.
| Role | Provider | Model |
|---|---|---|
| Photo analysis + LLM-as-judge | GMI Cloud | google/gemini-3.6-flash |
| Colorize (primary, drives the final image) | gemini-3.1-flash-image |
|
| Colorize (second, independent opinion) | GMI Cloud | gpt-image-2-edit |
| Super-resolution + invented-detail measurement | Local (OpenCV) | Lanczos + detailEnhance |
| Face detection (face-aware authenticity) | Local (OpenCV) | YuNet (bundled) |
| Audio denoise | Local (scipy) |
STFT spectral gate |
| Storage / system of record | Backblaze B2 (S3) | n/a |
If a provider is unavailable or declines a photo (some models refuse images with children), Trueprint records the refusal in the provenance and degrades gracefully instead of failing.
# 1. Install (Python 3.11+)
python -m venv .venv && ./.venv/Scripts/activate # Windows (macOS/Linux: source .venv/bin/activate)
pip install -r backend/requirements.txt
# 2. Add your keys
cp .env.example .env # fill in Backblaze B2 + provider keys (see .env.example)
# 3. Check your connections
python scripts/validate.py # B2 round-trip + provider reachability
# 4. (optional) pre-load instant demo samples
python scripts/precache.py # image samples
python scripts/gen_audio.py # the audio demo
# 5. Start the app
uvicorn backend.app.main:app --host 0.0.0.0 --port 8000
# landing http://localhost:8000/
# app http://localhost:8000/app (Restore · Collection · Audio · Verify)
# verify http://localhost:8000/verify
# 6. Run the tests (no keys needed)
pytestRun everything inside the activated
.venv. A bare system Python without the installed requirements will fail to importcv2/c2pa/genblaze_s3..envis git-ignored, so real keys are never committed.
Honest, deliberate hackathon-scope choices. Each has a clear production path:
| Area | In this demo | In production |
|---|---|---|
| C2PA signer | Self-signed dev cert (verifiers flag the signer as untrusted, disclosed on the result) | A cert on the C2PA trust list; audio C2PA (audio provenance today is the signed B2 manifest) |
| Audio clip | Synthetic, public-domain-safe clip (so we hold ground truth for a real SNR number) | Ingest real archival recordings; same path |
| Job registry | In-memory, single instance | Redis/DB-backed for scale |
| CORS | Open, for a frictionless demo | Locked to the deployed origin |
| Catalog lookup | Linear scan of B2 index | Indexed lookup at archive scale |
| Super-resolution | OpenCV detail synthesis (zero API cost); the measurement is the real contribution | Swap in a learned SR model; the measurement is model-agnostic |
Every regulatory and historical claim is cited in SOURCES.md (Library of Congress, EU AI Act Article 50, C2PA, OAIS, and more). The app and the landing hero show real measured numbers from live B2-backed runs; only the landing's stylized illustration (clearly tagged) uses placeholder figures. See PLAN.md for the full build plan.
MIT, see LICENSE.