Vision#
Same code. Same bits. Any GPU.
GPU simulation on any vendor, without CUDA, with bit-identical results everywhere and a receipt that proves it. Don’t trust the result: check it.
Vision is a small language for spatial simulations (.vis) and a tensor library with autodiff
(vision.tensor), both compiled to WebGPU. The same program gives the same 32 bits in every pixel
on NVIDIA, Intel, the CPU and a pure-numpy reference, and every run can produce a signed receipt
that anyone can check by re-running it, even without a GPU.
Every operation is rounded the same way on every device. Tested on NVIDIA, Intel, llvmpipe and numpy: all 4 294 967 296 inputs of every math function give the same bits.
Runs through WebGPU on Vulkan, Metal and DX12. All 46 built-in functions, including sin,
exp and erf, are implemented by Vision itself, not by the driver.
A run can produce a receipt that hashes the program, parameters, data and every output, signed (Ed25519) and time-stamped (RFC 3161). The verifier re-runs it and compares bit by bit.
A kernel only writes to its own pixel and reads the state at the start of the step. The compiler rejects anything else, so there are no data races and no atomics.
Loads .npy, .csv, Esri ASCII grids (.asc, exported by GDAL from any GeoTIFF) and .png
drawings. Missing cells are an error until you say what to put there.
vision.tensor has autodiff, transformer layers, AdamW and int8 inference. A GPT trained from
scratch gives the same weights on NVIDIA, Intel and the CPU.
Where it stands (measured, October 2026)#
The same bits |
60 of 60 conformance checks on NVIDIA, Intel, llvmpipe and numpy; 16 of 16 on Apple Silicon (Metal) |
Against the alternative |
PyTorch + CUDA is 1.70× faster on the exact path (it was 2.51×: the automatic mode, the tile chosen by measurement and the pipelining closed most of the gap) |
Verification cost |
~2% of a fleet’s work, not a flat 20%: each machine is checked against what it has already proved |
Loading a model |
0.5B in 2.9 s, 3B in 13.5 s (the host quantiser moved to Rust: 5.5–8.6× on the same bytes) |
What fits |
~3B in mx8 on a 6 GB card; larger models belong to the cluster, not to one GPU |
The reasoning and every measurement are in docs/development/otimizacao-2026-10-28.md; the plan for the
hardware classes that cannot be tested here is in docs/development/testes-em-instancia.md.
Try Vision#
A metal plate with a heat source in the middle:
param steps = 500
param alpha = 0.2
canvas plate[256, 256] edge clamp {
temperature
source
}
kernel heat on plate {
if (x - 128)^2 + (y - 128)^2 < 100 {
source = 1
}
}
kernel diffuse on plate {
let neighbours = temperature[x - 1, y] + temperature[x + 1, y]
+ temperature[x, y - 1] + temperature[x, y + 1]
temperature += alpha * (neighbours - 4 * temperature)
if source > 0.5 {
temperature = 100
}
}
measure average = mean(temperature) on plate
run {
heat
repeat steps { diffuse }
average
print average
save plate.temperature "plate.png"
}
pip install ".[proof]"
vision compare plate.vis # every device against the numpy reference, bit by bit
Documentation#
Install Vision and write, run and verify your first simulation in ten minutes.
The .vis language, measures, real data, receipts, the determinism guarantees and the tensor
library, explained.
Every keyword, built-in function, command-line option and Python class and function.
What is in this version and where it has been tested.