Deep Phi · The structure engine

Information, neither invented nor lost.

Two trades, one discipline: processing images with phiXplorer, guided by φ, Deep Phi’s structural measure — and compressing them losslessly with Phidelity. Deterministic, verifiable, light, on the device.

A nebula and its φ structural map
Input → φ structural mapEven the cosmos has structure. Image: NASA/ESA, Hubble — public domain.
φImagesφSuper-ResolutionφEnhancementφVideoφCompressionφComputer VisionφScientific ImagingφSignalφImagesφSuper-ResolutionφEnhancementφVideoφCompressionφComputer VisionφScientific ImagingφSignal
0.2–0.8M
parameters — featherweight
0.71 MB
model — up to +7.3 dB on real ISO 6400 noise
×2.3
lossless, over the actual storage of a fusion archive
0
invented pixels, 0 lost bits

The core

Two trades, one discipline

Deep Phi processes images and compresses them; it detects what matters in them and checks they were neither invented nor tampered with. Each trade has its own tools — the φ measure guides image processing, compression has methods of its own — but the rules are the same.

Image processingCompression
Read where the information livesThe φ map shows where structure is: textures, edges, micro-patterns.Spend bits only where the signal really holds information.
Invent nothing, lose nothingNo hallucinated pixel: the model strengthens what is there.Lossless, or with a maximum error you set and that is guaranteed.
VerifiableSame input, same output, and a map you can look at.Every file carries the checksum of the decoded data; the result is checked bit for bit.
Light, on the device0.2 to 0.8 million parameters, in the browser.Decoding on a microcontroller in a few tens of KB; one core is enough for a camera.
See

Image processing — phiXplorer

Super-resolution, enhancement, denoising, deblurring and video restoration, guided by φ.

  • Up to +7.3 dB on real ISO 6400 noise
  • 100 % in the browser, zero server
  • No invented pixel, reproducible output
Try phiXplorer
Keep

Compression — Phidelity

A lossless or guaranteed-error format for 8 to 16-bit sensors: infrared, medical, sonar, hyperspectral, depth.

  • ×2.3 over the actual storage of a fusion archive
  • −35 % against FFV1 on infrared video
  • Byte-identical streams on PC and ARM
Discover Phidelity
Detect

Detection — φ

Find objects and structures — drones, defects, targets — in visible and infrared light, and track them through video, with φ as a safeguard behind the detector.

  • Structure detection validated in our publications, visible and infrared
  • Regions of interest without semantics, driven by φ alone
  • Deterministic: same input, same result
Propose a test
Verify

Verification — fidelity and tampering

Tell whether an image was invented or tampered with: what an upscaler added, what was erased or cloned in a thermal image.

  • A zone-by-zone map of the detail an upscaler invented
  • Tampering in thermal images: blur, cloning, erasure
  • No need for the original image
Discover verification

What is φ

A measure of structure — not a model

φ scores, at every point of an image, how rich the local structure is — independent of meaning. The formula stays inside Deep Phi; only its behaviour ships in the model.

01

Input

Any image, exactly as it is — no labels, no priors, no setup.

02

φ map

Hot where structure lives — textures, edges, micro-patterns. Dark where it’s flat.

03

Structure-aware result

Models spend their effort exactly where φ points, and nowhere else.

Image and its φ map
Feathers, beak and eye light up; the blurred background stays ignored.
Image and its φ map
The fence, the stones and the railing glow; the smooth sky is left at rest.

Same pixels in, same map out — no randomness, nothing hallucinated. φ is a deterministic measure you can audit, not a generative model you have to trust.

Explore the technology →

Deterministic by nature

φ, seen as a relief of structure

Read an image as a landscape: peaks where structure is dense — feathers, edges, texture — plains where it is flat. The very same pixels always produce the very same surface. A measurement, drawn to the pixel.

The image as a structural landscape — peaks are rich zones, plains are flat areas.φ in 3D
The image as a structural landscape — peaks are rich zones, plains are flat areas.
The same values as isolines — a topographic map of structure, traced to the pixel.Level curves
The same values as isolines — a topographic map of structure, traced to the pixel.

Why φ

The least that works, and the proof that it does

Deterministic

Same input, same output. Reproducible and auditable — the opposite of a generative guess.

Featherweight

0.2–0.8M parameters. Runs on-device, inside a browser — no datacenter, no GPU farm.

Transparent

φ’s output is a picture you can look at. You literally see what the model sees.

Two trades

φ guides image processing (super-resolution, enhancement, deblurring); Phidelity compression has methods of its own. Same rules: nothing invented, nothing lost, everything verifiable.

Applications

One structural prior, many pipelines

What ships today, what’s in research, and where φ is heading.

Super-Resolution ×2

● Live

Upscale images and video, structure-first, no invented detail.

φ Enhancement

● Live

Contrast and sharpness placed exactly where φ sees structure.

Denoising

● Live

Removes sensor noise and grain while φ preserves real detail — a small model that keeps structure sharp.

Gradient removal

● Live

Astrophotography: φ lifts the light-pollution and vignetting gradient while preserving stars and nebulosity.

Video ×2

● Live

Frame-by-frame upscaling, encoded to MP4 in your browser.

See all applications →

Zoom ×8

On requestDrag to compare

Real low-resolution details, enlarged ×8 — no downscale, nothing hallucinated. A capability preview: run offline, not in the ×2 studio.

Macaw — eye & feathersMacaw — eye & feathersRealDeepPhi ×8
Macaw — eye & feathers
A real detail enlarged ×8 — plumage and eye rebuilt from the pixels that exist.
Tiny textTiny textRealDeepPhi ×8
Tiny text
Letters become legible again — not a single character invented.
Moon — cratersMoon — cratersRealDeepPhi ×8
Moon — craters
Crater rims recovered from a small, real crop.
Jupiter — cloud bandsJupiter — cloud bandsRealDeepPhi ×8
Jupiter — cloud bands
Banding and the storm regain their edge.
Lighthouse — stoneworkLighthouse — stoneworkRealDeepPhi ×8
Lighthouse — stonework
Masonry sharpens; the smooth sky stays clean.
Foliage — branchesFoliage — branchesRealDeepPhi ×8
Foliage — branches
Branch edges and veins reconstructed.

×8 model — 4.66 MB, φ inside. Runs offline on your own hardware; available on request.

Denoising — real sensor noise

On requestDrag to compare

Real camera pairs: the same scene shot at base ISO and at ISO 6400. No synthetic noise — this is what the sensor actually produced. The in-browser studio runs the synthetic-noise model; this is the one trained on real noise. Hover for the pixel loupe.

Bronze, ISO 6400Bronze, ISO 6400ISO 6400DeepPhi denoised
Bronze, ISO 6400
Real sensor noise, not simulated. The chroma blotches go; the pitting and patina of the metal stay.
Carved drapery, ISO 6400Carved drapery, ISO 6400ISO 6400DeepPhi denoised
Carved drapery, ISO 6400
Grain lifted from the stone while every chisel mark and fold survives.
Sculpted shell, ISO 6400Sculpted shell, ISO 6400ISO 6400DeepPhi denoised
Sculpted shell, ISO 6400
Colour speckle cleared from the shadows; the carved edges keep their bite.
Lobster shell, ISO 6400Lobster shell, ISO 6400ISO 6400DeepPhi denoised
Lobster shell, ISO 6400
Chroma noise is worst on saturated reds — cleared here without smearing the shell.
Stone detail, ISO 6400Stone detail, ISO 6400ISO 6400DeepPhi denoised
Stone detail, ISO 6400
A harder case: fine relief, where the model stays deliberately cautious.
Claw, ISO 6400Claw, ISO 6400ISO 6400DeepPhi denoised
Claw, ISO 6400
Wet highlights and speckled shell — texture kept, grain gone.

Real-noise model — 0.71 MB, φ inside: the same size as the one running in the studio, but trained on genuine camera pairs instead of synthetic noise. +3.4 dB over the in-browser model on real photographs, up to +7.7 dB on the noisiest. Runs offline on your own hardware; available on request.

Source pairs: NIND — Natural Image Noise Dataset, by Trougnouf (Benoit Brummer) — CC BY 4.0.

Weather radar archives

ResearchDrag to compare

Radar maps archived as images keep only a colour per pixel: the rainfall itself is lost. Drag the slider: left, the archive as stored; right, the rain recovered inside each colour — never outside it.

Real US archive, 24 May 2016Real US archive, 24 May 2016ArchiveRecovered
Real US archive, 24 May 2016
NEXRAD composite archived in 13 colours. Year never seen during training.
German radar, summer stormsGerman radar, summer stormsArchiveRecovered
German radar, summer storms
Rain map in 10 colours, 21 July 2025. Day never seen during training.
Météo-France, hourly rainfallMétéo-France, hourly rainfallArchiveRecovered
Météo-France, hourly rainfall
France, January 2026, in 10 colours — no French data used for learning.

On a real archive and a whole year never seen (2016, 19 million rain pixels): 28 % less error than the best colour-by-colour reading — more than 2.5× the gain of the classic restoration method — and the yearly rainfall total within 1.5 % instead of 7.2 %. Our compact model matches a state-of-the-art network with 32× fewer parameters and runs 1.8× faster on an ordinary CPU (a whole continental map in about 7 s; 0.7 s on a consumer GPU). A high-accuracy version goes beyond the state of the art with 8× fewer parameters.

Data: NOAA NEXRAD composites archived by the Iowa Environmental Mesonet (Iowa State University); Deutscher Wetterdienst (DWD) open data; Météo-France COMEPHORE reanalysis (Licence Ouverte).

Open the live studio Runs entirely in your browser — nothing uploaded.

Roadmap

From a measure to a platform

2025

Foundations

φ core, dense structural maps, on-device inference.

2026

phiXplorer

The web studio — super-resolution, enhancement, video. This site.

2027

Deep Phi platform

Specialised models per domain, batch tooling, quality metrics.

Next

SDK & Cloud API

φ-guided processing as a building block for your own products.