Simulação · tensores exatos · recibos assinados

Escreva a equação.
Receba os mesmos bits em qualquer GPU.

Uma linguagem para simulação espacial e uma biblioteca tensorial com autodiff, compilada para WebGPU, com especificação publicada. Canais tipados, canvases 2-D e 3-D, cenários, 46 funções embutidas — um programa, os mesmos 32 bits em NVIDIA, AMD, Apple Silicon, Intel e CPU, com um recibo assinado.

Ver a linguagem Verificar um recibo

1 programa: uma fonte, todos os motores, o mesmo resultado
4 294 967 296: entradas de cada função matemática, idênticas em toda parte
Ed25519: cada execução assinada, cada saída com hash
0 GPU: para verificar um recibo

Por que o Vision existe

Um motor para todas as áreas,
nas máquinas que você já tem.

O Vision é generalista: a mesma linguagem modela calor e dispersão, imagens, terreno, confiabilidade e tensores. E foi feito para redes privadas de máquinas mistas — divide o trabalho, mantém cada modelo onde cabe e o move entre computadores quando é preciso, e dá o mesmo resultado, bit a bit, onde quer que o trabalho caia. E prova isso, em cada execução.

Generalista por construção Física, imagens, terreno, confiabilidade, tensores. Uma equação nova é um kernel novo, não uma ferramenta nova.
Frota mista, uma só malha Apple Silicon, NVIDIA, AMD, Intel e CPU numa só rede privada, vistos como um único conjunto.
Dividir e compartilhar O trabalho é dividido entre máquinas, os modelos ficam residentes e são compartilhados entre elas, e cada tarefa leva consigo o contrato aritmético que precisa respeitar.
Os mesmos bits, provados Seja qual for a mistura, as saídas são idênticas; cada execução assina um recibo e o kit de conformidade verifica uma máquina nova antes de entrar.

Apple M‑series NVIDIA AMD Intel GPU CPU → os mesmos 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

A linguagem

Uma linguagem completa, especificada e verificada. Canais tipados (f32 e i32), canvases 2-D e 3-D com políticas de borda, kernels, medidas com redução compensada, conjuntos de cenários, leitura de dados que se recusa a adivinhar, e 46 funções embutidas implementadas pelo próprio Vision. A gramática é publicada, cada código de erro tem a sua página, e o verificador recusa tudo o que seja inseguro antes de qualquer dispositivo executar.

// 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
}

saída

$ 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

recibo assinado

SHA-256 do canvas: e3b0c442…7852b855
Assinatura Ed25519: valid
Carimbo RFC 3161: atestado de tempo por terceiro
Paridade: idêntico em Apple M4 e RTX 4050
Contrato: auditable · MX8 · 4 motores

Qualquer pessoa reexecuta vision verify receipt.json e chega ao mesmo bit.

Step 03 · run and 04 · compare

Todas as GPUs que tem

Um programa, todos os motores: NVIDIA, AMD, Apple Silicon, Intel e CPU — AMD pelo driver Vulkan — mais uma referência em numpy puro. O Vision encontra o dispositivo em execução e escolhe o caminho mais rápido que mantém o resultado idêntico. O kit de conformidade congela as assinaturas em NVIDIA, Intel, Apple Metal, CPU e numpy — numa placa que ainda não viu, o vision conformance responde em dois minutos.

Uma fonte, todos os motores

O Vision compila o mesmo programa para Vulkan — que inclui AMD —, para Metal e DX12, e para a CPU. As 46 funções embutidas — incluindo sin, exp e erf — são implementadas pelo próprio Vision, por isso o arredondamento é igual em todo o lado.

verificado 60/60 verificações · 16/16 em Apple Metal

Roda em AMD

Radeon e Instinct rodam o mesmo programa pelo driver Vulkan: sem ROCm, sem HIP, nada para compilar para uma placa específica. Os bits são conferidos na máquina que os executa — o vision conformance responde em dois minutos.

alvo Vulkan · qualquer placa RDNA ou CDNA

Três modos de aritmética, declarados

auditable dá os mesmos bits em qualquer dispositivo; gpu-exact usa a multiplicação e soma fundida onde o hardware a tem; fast fica ligado a uma família de GPU. Cada execução regista o modo que usou.

garantia escrita no recibo

Mede o dispositivo

vision variants sonda a GPU e mostra o caminho que vai usar: tratamento de subnormais, limites de buffers, unidades matriciais, largura vetorial. A escolha é medida, não adivinhada.

sondagem um segundo por dispositivo

Canais inteiros e de vírgula flutuante

f32 para física, i32 para acumulação exata — flux() conserva um total até à última unidade, e o caminho int8 empacotado roda a 520 GOPS sem diferenças.

exatidão verificada elemento por elemento

Step 05 · the receipt

Um recibo para cada execução

Uma execução produz um arquivo que qualquer um confere: contém o hash do que foi calculado, a assinatura e pode levar um carimbo de tempo de terceiro.

O que entra no recibo

O hash do programa, dos parâmetros, dos dados lidos e de cada canal de saída, mais as medidas e o contrato aritmético usado. As mesmas entradas dão o mesmo recibo.

Autenticação

Assinaturas Ed25519 com uma chave que fica consigo. As máquinas se autenticam com certificados emitidos pela autoridade do próprio cluster; pessoas e aplicações usam chaves de API com papéis.

Papéis e revogação

admin emite e revoga, client submete, auditor lê a trilha, operator opera a frota. A revogação vale na requisição seguinte.

Trilha de auditoria

Cada ação acrescenta uma entrada encadeada no hash anterior. /v1/audit/verify recalcula a cadeia, por isso uma alteração aparece como elo quebrado, não como página ausente.

Tempo a que se pode apontar

Um carimbo RFC 3161 de uma autoridade pública, ou da sua, liga a execução a um momento atestado por um terceiro.

Verificado sem GPU

vision verify reexecuta o programa e compara bit a bit. Roda com Python e numpy: basta um notebook, um contêiner ou um servidor isolado.

artefato um arquivo JSON

O que roda aqui

Cada cartão é um programa do repositório, validado contra uma referência publicada.

Risco e análise de consequências

DEGADIS 2.1, Britter-McQuaid, pluma gaussiana e SIL/LOPA, validados contra Burro, Phast 6.7 e Prairie Grass.

critérios MRB · MRSE · MG · VG · FAC2

Modelos de imagem

Convolução, ReLU, max-pool e cadeias que mudam de tamanho, com um arquivo de pesos por camada e comparação com o PyTorch incluída.

precisão 5,36e-07 vs PyTorch

Monitoramento geoespacial

Grades ASCII Esri com nodata, estatística zonal com geopandas, Monte Carlo espacial de propagação de fogo.

stencil 21 Gpx/s a 4096²

Confiabilidade e degradação

Modelos de vida Weibull, acumulação de dano e incerteza sobre parâmetros, na mesma linguagem dos modelos espaciais.

mesmo recibo mesmo verificador

Inferência e treino de LLM

vision.tensor traz autodiff, camadas de transformer, AdamW e inferência int8, com a mesma regra de exatidão.

int8 520 GOPS, exato

Os seus próprios kernels

Uma equação nova é um kernel novo: três linhas de .vis. O vision explain lê o programa de volta em palavras e fórmulas, e avisa sobre os erros comuns.

aprendizagem um dia

Uma rede privada de máquinas mistas

Os agentes rodam em cada máquina e abrem a conexão para fora; o coordenador guarda a fila, os leases e a trilha de auditoria.

Cada máquina tem a sua identidade

Certificados de uma autoridade interna, um token de cadastro de uso único por máquina, e revogação que vale na requisição seguinte.

Verificação cruzada

Uma parte das tarefas é reexecutada em outra máquina. Uma divergência torna-se uma disputa com árbitro, e o contrato aritmético de cada tarefa fica registrado.

Planejado a partir da capacidade medida

O planejador lê o inventário medido de cada agente — memória, taxa, tempo de carga — e decide o formato, a divisão e a colocação.

Step 06 · verify

Verificar um recibo

Arraste um recibo .json. A página lê o arquivo e mostra o comando que o prova — a prova é uma reexecução, e qualquer um a pode fazer.

⌁ Solte o recibo aqui ou clique para escolher um arquivo

Escreva a equação.Receba os mesmos bits em qualquer GPU.

Um motor para todas as áreas,nas máquinas que você já tem.