Simulation · exact tensors · signed receipts

Write the equation.
Get the same bits on every GPU.

A language for spatial simulation and a tensor library with autodiff, compiled to WebGPU, with a published specification. Typed channels, 2-D and 3-D canvases, scenarios, 46 built-in functions — one program, the same 32 bits on NVIDIA, AMD, Apple Silicon, Intel and CPU, with a signed receipt.

See the language Verify a receipt

1 program: one source, every engine, the same result
4 294 967 296: inputs of every math function, identical everywhere
Ed25519: every run signed, every output hashed
0 GPU: to verify a receipt

Why Vision exists

One engine for every area,
on the machines you already own.

Vision is a generalist: the same language models heat and dispersion, images, terrain, reliability and tensors. And it is built for private networks of mixed machines — it divides the work, keeps each model where it fits and moves it between computers when it has to, and gives the same bit-exact result wherever the work lands. Then it proves it, every run.

Generalist by design Physics, images, terrain, reliability, tensors. A new equation is a new kernel, not a new tool.
A mixed fleet, one fabric Apple Silicon, NVIDIA, AMD, Intel and CPU joined in one private network, seen as a single pool.
Divide and share Work is split across machines, models stay resident and are shared between them, and every task carries the arithmetic contract it must respect.
The same bits, proven Whatever the mix, the outputs are identical; every run signs a receipt and the conformance kit checks a new machine before it joins.

Apple M‑series NVIDIA AMD Intel GPU CPU → the same 32 bits

The whole path, in seven steps

From an equation to a signed receipt

Each step is one command, and each one leaves something behind: a checked program, an output, a receipt. The sections below expand them.

01
Write the model

A canvas, a kernel for each equation, a measure for the number you care about. Three lines of physics are three lines of .vis.
02
Check it before anything runs

Types, bounds, canvas sizes and the one-writer-per-cell rule are verified on the source. Nothing reaches a device until the program is sound.
```
$ vision check main.vis
ok: 1 canvas, 2 kernel(s), 1 measure(s)
```
03
Run it on the device you have

The engine picks the device, compiles the kernels for it, and prints the measures and the outputs.
```
$ vision run main.vis
device: NVIDIA RTX 4050 · Vulkan
mean_t = 1.562500019
saved output/tutorial.png
```
04
Compare the engines

The same program on every device you have, against the numpy reference. This is the step that turns "it works here" into "it works everywhere".
```
$ vision compare main.vis
numpy · NVIDIA · Intel · llvmpipe
the same 32 bits on all four
```
05
Emit the receipt

The run hashes the program, the parameters, the data and every output, signs the file with your Ed25519 key and can add a third-party time stamp.
```
$ vision run main.vis --receipt run.json \
    --sign id.pem --timestamp
receipt written: 4 hashes · signed · time-stamped
```
06
Verify it anywhere

Whoever receives the receipt re-runs the program and compares bit by bit — on a laptop, in a container, on a server with no graphics card.
```
$ vision verify run.json --device numpy --trust id
matches · signature valid · 0 differences
```
07
Hand it over and keep the trail

The receipt travels with the result. On a private network the coordinator re-runs a share of the work on another machine, and the auditor role reads the hash-chained trail.
```
$ vision.cluster status --url https://coordinator --identity ./id
job 4f1c… · 240 tasks · 48 verified · 0 disputes
```

Step 01 · write and 02 · check

The language

A complete language, specified and checked. Typed channels (f32 and i32), 2-D and 3-D canvases with edge policies, kernels, measures with compensated reduction, scenario ensembles, data loading that refuses to guess, and 46 built-in functions implemented by Vision itself. The grammar is published, every error code has its own page, and the checker rejects anything unsafe before a device runs.

// heat moving through a plate, with a hot corner
param steps = 20
canvas plate[64, 64] edge clamp { t }

kernel start on plate {
    t = select(x < 8 and y < 8, 100.0, 0.0)
}

kernel diffuse on plate {
    t += 0.25 * (t[x-1, y] + t[x+1, y]
              + t[x, y-1] + t[x, y+1] - 4.0 * t)
}

measure mean_t = mean(t) on plate

run {
    start
    repeat steps { diffuse }
    print mean_t
}

// a convolution layer, one kernel per channel
canvas in[96, 96] edge zero { a }
canvas out[96, 96] edge clamp { a b }
canvas w[3, 6] { c0 }

kernel conv on out {
    var acc = 0.0
    for i in 0 to 2 {
        for j in 0 to 2 {
            acc += w.c0[0 + i, 0 + j]
                 * in.a[x + i - 1, y + j - 1]
        }
    }
    a = gain * acc + bias
}

// exact integer matrix product, four int8 per word
canvas A[256, 1024] edge clamp { a: i32 }
canvas B[1024, 256] edge clamp { b: i32 }
canvas C[1024, 1024] edge clamp { c: i32 }

kernel gemm on C {
    var acc = 0
    for k in 0 to 255 {
        let pa = A.a[k, x]
        let pb = B.b[y, k]
        acc += ((pa << 24) >> 24) * ((pb << 24) >> 24)
        acc += ((pa << 16) >> 24) * ((pb << 16) >> 24)
        acc += (pa >> 24) * (pb >> 24)
    }
    c = acc
}

output

$ vision run diffuse.vis
mean_t = 1.562500019
$ vision compare diffuse.vis
numpy · NVIDIA · Intel · llvmpipe
the same 32 bits on all four

$ vision run conv_pool.vis
16 kernel runs · 34.2 ms
$ vision compare conv_pool.vis
the same 32 bits on all four engines

$ vision run int8_gemm.vis
int8 1024^3 · 4.12 ms · 521 GOPS
$ vision verify receipt.json
exact against the integer reference

signed receipt

SHA-256 of the canvas: e3b0c442…7852b855
Ed25519 signature: valid
RFC 3161 time stamp: third-party time attestation
Parity: identical on Apple M4 and RTX 4050
Contract: auditable · MX8 · 4 engines

Anyone re-runs vision verify receipt.json and reaches the same bit.

Step 03 · run and 04 · compare

Every GPU you have

One program, every engine: NVIDIA, AMD, Apple Silicon, Intel and the CPU — AMD through its Vulkan driver — plus a pure-numpy reference. Vision finds the device at runtime and picks the fastest path that keeps the result identical. The conformance kit freezes the signatures on NVIDIA, Intel, Apple Metal, the CPU and numpy — on a card it has not seen yet, vision conformance answers in two minutes.

One source, every engine

Vision compiles the same program for Vulkan — which includes AMD —, for Metal and DX12, and for the CPU. All 46 built-in functions — including sin, exp and erf — are implemented by Vision itself, so the rounding is the same everywhere.

checked 60/60 conformance checks · 16/16 on Apple Metal

Runs on AMD

Radeon and Instinct run the same program through their Vulkan driver: no ROCm, no HIP, nothing to build for one specific card. The bits are checked on the machine that runs them — vision conformance answers in two minutes.

target Vulkan · any RDNA or CDNA card

Three arithmetic modes, declared

auditable gives the same bits on any device; gpu-exact takes the fused multiply-add where the hardware has it; fast is bound to one GPU family. Each run records which mode it used.

guarantee written in the receipt

It measures the device

vision variants probes the GPU and reports the path it will take: flushing of subnormals, buffer limits, matrix units, vector width. The choice is measured, not guessed.

probe one second per device

Integer and float channels

f32 for physics, i32 for exact accumulation — flux() conserves a total to the last unit, and the packed int8 path runs at 520 GOPS with zero differences.

exactness verified element by element

Step 05 · the receipt

A receipt for every run

A run produces a file that anyone can check: it hashes what was computed, signs it, and can carry a third-party time stamp.

What goes into it

The hash of the program, the parameters, the data read and every output channel, plus the measures and the arithmetic contracted used. Same inputs, same receipt.

Authentication

Ed25519 signatures from a key you keep. Machines authenticate with certificates issued by the cluster's own authority; people and applications use API keys with roles.

Roles and revocation

admin issues and revokes, client submits, auditor reads the trail, operator runs the fleet. Revocation takes effect on the next request.

Audit trail

Every action appends an entry chained to the previous hash. /v1/audit/verify recomputes the chain, so tampering shows up as a broken link, not as a missing page.

Time you can point at

An RFC 3161 time stamp from a public authority, or your own, binds the run to a moment that a third party attests.

Verified without a GPU

vision verify re-runs the program and compares bit by bit. It runs on Python and numpy: a laptop, a container or an isolated server is enough.

artefact one JSON file

What people run on it

Each card is a program in the repository, validated against a published reference.

Risk and consequence analysis

DEGADIS 2.1, Britter-McQuaid, the Gaussian plume and SIL/LOPA, validated against Burro, Phast 6.7 and Prairie Grass.

criteria MRB · MRSE · MG · VG · FAC2

Image models

Convolution, ReLU, max-pool and chains that change size, with one weight file per layer and a comparison against PyTorch built in.

accuracy 5.36e-07 vs PyTorch

Geospatial monitoring

Esri ASCII grids with nodata, zonal statistics with geopandas, spatial Monte Carlo of fire spread.

stencil 21 Gpx/s at 4096²

Reliability and degradation

Weibull life models, damage accumulation and uncertainty over parameters, in the same language as the spatial models.

same receipt same verifier

LLM inference and training

vision.tensor brings autodiff, transformer layers, AdamW and int8 inference, with the same exactness rule.

int8 520 GOPS, exact

Your own kernels

A new equation is a new kernel: three lines of .vis. vision explain reads it back in words and formulas, and warns about the usual mistakes.

learning curve one day

A private network of mixed machines

Agents run on each machine and open the connection outwards; the coordinator holds the queue, the leases and the audit trail.

Each machine keeps its own identity

Certificates from an internal authority, one single-use enrolment token per machine, and revocation that applies on the next request.

Cross-verification

A share of the tasks re-runs on another machine. A disagreement becomes a dispute with a referee, and the arithmetic contract of each task is recorded.

Planned from measured capacity

The planner reads the measured inventory of every agent — memory, throughput, load time — and decides the format, the split and the placement.

Step 06 · verify

Verify a receipt

Drop a .json receipt. The page reads it and shows the one command that proves it — the proof is a re-run, and anyone can do it.

⌁ Drop the receipt here or click to choose a file

Write the equation.Get the same bits on every GPU.

One engine for every area,on the machines you already own.