Em números
1Velocidade e tamanho: 100 mil registros
O jsonW contra o mesmo conjunto em JSONL: 100 mil cartões de base de conhecimento, com texto, decimal, lista e um vetor de 384 dimensões. O .jsw grava 124 vezes mais rápido, lê tudo 48 vezes mais rápido, lê uma coluna 1.886 vezes mais rápido e ocupa 6,6 vezes menos. Em toda execução a ferramenta confere que as duas leituras contaram 100 mil linhas com a mesma soma.
| Operação | JSONL | jsonW 1.4.2 | Razão (faixa) |
|---|---|---|---|
| Gravar | 15.312 ms | 130 ms | 124× (94 a 136) |
| Ler tudo, todos os campos | 3.756 ms | 79 ms | 48× (35 a 51) |
| Ler tudo, 8 threads (o JSONL em uma) | 3.756 ms | 8,4 ms | 453× (262 a 598) |
| Ler uma coluna | 3.756 ms | 2,00 ms | 1.886× (1.487 a 2.542) |
| Ir direto à linha N, um campo | ler do começo | 0,075 µs | |
| Uma mensagem na forma linha | 5.157 B | 1.073 B | 4,8× (nas 10) |
| Arquivo | Tamanho | Razão |
|---|---|---|
| JSONL | 519,3 | 1,0× |
.jsw, vetor vf16, nível padrão | 79,1 | 6,6× |
.jsw, vetor vq8 | 41,1 | 12,6× |
.jsw, vetor vf16, --max | 1,36 | 381× |
.jsw sem a coluna de vetor, --max | 0,0175 | 2.185× (contra 38,2 MB) |
- Data: 19/11/2026, entre 23:00 e 23:06 UTC (tempos); tamanhos às 23:06 UTC.
- Versão: jsonW 1.4.2 público,
bin/linux-x86_64/wjswda tagv1.4.2, SHA-2563e4e587b7153e69875c6e946a1596d99207ace61c41f016603f966a924e43e55. - Máquina: servidor virtual AMD EPYC 9355P, 8 vCPUs, 18 GB de memória, Linux 7.3; arquivos num
tmpfs. - Método:
wjsw medircom 100 mil linhas, 10 execuções seguidas; tamanhos pelogerar-cartoes.awkewjsw de-texto, custódia dos 6 arquivos conferida (ok: 100000 linhasem todos). O lado JSON é gravado e lido pelo leitor de texto do próprio jsonW. - Saídas brutas: medir-01 a medir-10, tamanhos, custódia e máquina.
git clone --branch v1.4.2 https://github.com/developer-wortic/jsonw && cd jsonw
export JSONW_SEM_PING=1
for i in $(seq 1 10); do bin/linux-x86_64/wjsw medir /tmp 100000; done
2Base real do INPI: 55,3 milhões de linhas
Os sete arquivos dos dados abertos de marcas do INPI, convertidos 1:1, sem cortar nada: 55.278.212 linhas e 12,53 GB de CSV. Em .jsw a base ficou 4,9 vezes menor que o CSV no nível padrão, 6,5 vezes no nível máximo e 12,8 vezes menor que o XML, com o SHA-256 e o CRC32C de todos os blocos dos sete arquivos conferidos. Na contagem dos registros em vigor, o .jsw respondeu em 43 ms, à frente do Parquet lido pelo DuckDB, do DuckDB lendo o CSV, do grep e do CSV comprimido, com a resposta certa: 2.343.607.
| Formato e leitor | Tempo | Resposta |
|---|---|---|
.jsw --max 1.3.11, wjsw calcular --onde | 43 | 2.343.607 |
.jsw 1.3.11, wjsw calcular --onde | 44 | 2.343.607 |
| Parquet, DuckDB 2.0.0, 8 núcleos | 54 | 2.343.607 |
| CSV, DuckDB 2.0.0, 8 núcleos | 375 | 2.343.607 |
CSV, grep -c | 519 | 2.343.607 |
CSV + zstd, zstd -dc | grep -c | 798 | 2.343.607 |
- Data: 13/11/2026, 06:21 UTC (quinta rodada); dados do INPI baixados em 12/11/2026.
- Versão:
wjsw1.3.11 do lançamento; a 1.4.2 lê os mesmos arquivos. - Máquina: servidor de 8 núcleos, 31 GB de memória, Linux 7.3.
- Método: esquema escrito à mão para cada arquivo; o conversor em C confere cada número e data contra o texto do CSV; cada consulta rodou 5 vezes com o arquivo em cache e vale a menor; Parquet gravado e lido pelo DuckDB 2.0.0 com zstd.
- Onde está: Tabelas 5C e 5D do paper.
curl -O https://dadosabertos.inpi.gov.br/download/marcas/marcas.zip
# cada CSV convertido para .jsw com um esquema escrito à mão, como na Seção 5.4 do paper
wjsw calcular MARCAS_DADOS_BIBLIOGRAFICOS.jsw --onde "codigo_situacao = IPAS023"
wjsw conferir MARCAS_DADOS_BIBLIOGRAFICOS.jsw
3Busca por chave: 1 milhão de linhas
A busca por chave da ABI, num arquivo de um milhão de linhas, mediana de 200 buscas por id: 77,4 ms varrendo a coluna e 0,126 ms pelo índice, 613 vezes mais rápido, com 0 respostas erradas nas 400 buscas. O índice levou 160 ms para montar, uma vez. O mesmo programa roda os casos de prova (chave única, repetida, ausente, tipo errado e a visão por tenant) e termina com TUDO CERTO (0 falhas).
- Data: 19/11/2026, 23:07 UTC.
- Versão:
sdk/prova_chave.cdo repositório, ligado àlibjsonw.a1.4.2 pública. - Máquina: a mesma da prova 1.
- Resultado: varredura mediana 77,3590 ms, p95 88,8815 ms; índice mediana 0,1263 ms, p95 0,2122 ms; gravar o milhão de linhas, 535 ms.
- Saída bruta: saidas-1.4.2.txt, seção "busca por chave".
cc -O2 -Isdk -o prova_chave sdk/prova_chave.c bin/linux-x86_64/libjsonw.a -lpthread -lm
./prova_chave # os casos de prova
./prova_chave --medir 1000000 # a medida
4Leitura remota parcial
O wremoto abre um .jsw de 79,1 MB baixando 8,7 KB (cabeçalho e rodapé). Para ler a linha 50.000 baixa 0,98% do arquivo; para o filtro id > 99990, 0,84%, porque as zonas descartam os outros blocos antes do download. Na leitura local, o mesmo filtro pula 102 de 103 blocos e responde em 0,9 ms.
- Data: 19/11/2026, 23:07 UTC. Versão:
wremotoewjsw1.4.2. Máquina: a mesma da prova 1. - Método: o arquivo de 100 mil registros da prova 1, lido pelo endereço
file://, com os mesmos pedidos por faixa de bytes que owremotofaz a um servidor HTTP, ao R2 ou ao S3; o própriowremotoconta os bytes baixados. - Saída bruta: saidas-1.4.2.txt, "Listagem 6".
$ wremoto ver file://$PWD/com.jsw 50000 1
baixado no total: 777.8 KB em 5 pedidos (0.98% do arquivo)
$ wremoto filtrar file://$PWD/com.jsw 'id > 99990'
baixado no total: 667.7 KB em 5 pedidos (0.84% do arquivo)
5Custódia: nenhum byte muda sem aviso
Um byte trocado no meio do arquivo falha no conferir; um arquivo cortado no fim, como numa gravação interrompida, é apontado e o reparar o devolve inteiro; a cadeia funciona com SHA-256 e com BLAKE3.
$ wjsw conferir vendas.jsw
ok: 2 linhas, 1 blocos, sha256 e crc32c conferidos
$ wjsw conferir adulterado.jsw
FALHOU: bloco 0: nao veio ou nao confere
$ wjsw conferir cortado.jsw
FALHOU: sem rodape: rode wjsw reparar
$ wjsw reparar cortado.jsw && wjsw conferir cortado.jsw
ok
ok: 2 linhas, 1 blocos, sha256 e crc32c conferidos
$ wjsw regravar vendas.jsw vendas-b3.jsw --hash blake3 && wjsw conferir vendas-b3.jsw
2 linhas: 708 -> 708 bytes (100.0%), 0.0 s
ok: 2 linhas, 1 blocos, blake3 e crc32c conferidos
- Data: 19/11/2026, 23:07 UTC. Versão:
wjsw1.4.2. Máquina: a mesma da prova 1. - Método:
adulterado.jsw= umXgravado no terço do arquivo comdd;cortado.jsw= o arquivo sem os 20 últimos bytes. Entradas em jsonw.org/paper/exemplos. - Saída bruta: saidas-1.4.2.txt, "Listagem 7".
6Visão por permissão em todo comando
Num arquivo de clínica com CPF marcado +pessoal, valor marcado +escopo(financeiro) e uma coluna tenant, cada credencial vê só o que pode: a recepção da unidade 1 vê a agenda da unidade 1 sem CPF e sem valor; o financeiro vê o valor; ninguém da unidade 1 vê a unidade 2. Sem escopo, o para-texto entrega CPF e valor nulos, e o filtro pelo CPF é recusado. Na nossa prova da visão por linha de comando, a 1.4.1 passa as 37 verificações.
$ WJSW_ESCOPOS="tenant:1" wjsw ver clin.jsw
{paciente:"Ana Souza",cpf:null,valor:null,data:t"2026-11-12T13:00:00.000000Z",tenant:1}
{paciente:"Carla Dias",cpf:null,valor:null,data:t"2026-11-12T15:30:00.000000Z",tenant:1}
$ WJSW_ESCOPOS="financeiro tenant:1" wjsw ver clin.jsw
{paciente:"Ana Souza",cpf:null,valor:180.00 BRL,data:t"2026-11-12T13:00:00.000000Z",tenant:1}
{paciente:"Carla Dias",cpf:null,valor:180.00 BRL,data:t"2026-11-12T15:30:00.000000Z",tenant:1}
$ wjsw filtrar clin.jsw "cpf = 012.345.678-90"
coluna sem permissao: cpf (exige escopo)
- Data: 19/11/2026, 23:07 UTC, com o
wjsw1.4.2 (as listagens); 37 de 37 com a 1.4.1 em macOS arm64, na publicação da 1.4.1 em 15/11/2026, registrado no README do pacote. - Máquina: a mesma da prova 1. Dados da clínica fictícios, em clin.jsonl.
- Saída bruta: saidas-1.4.2.txt, "Listagem 8".
7Cifra em repouso
Um .jsw cifrado com XChaCha20-Poly1305 e uma chave de 256 bits fora do arquivo não abre sem a chave, nem para conferir nem para ler; com a chave, a custódia confere e as linhas voltam. Trocamos um byte do arquivo cifrado em três posições: nas três, o conferir e o para-texto recusaram o arquivo.
$ wjsw cifrar cifrado.jsw --chave chave.hex
$ wjsw conferir cifrado.jsw
FALHOU: arquivo cifrado: falta a chave do tenant (WJSW_CHAVE_ARQ ou credencial wjsw-chave)
$ wjsw conferir cifrado.jsw --chave chave.hex
ok: 1 linhas, 1 blocos, sha256 e crc32c conferidos
# um byte trocado na posição 238 de 716
$ wjsw conferir troca.jsw --chave chave.hex
FALHOU: bloco cifrado nao e o que o indice assinou
- Data: 19/11/2026, 23:13 UTC. Versão:
wjsw1.4.2. Máquina: a mesma da prova 1. - Método: chave de teste gerada na hora com
/dev/urandom, nunca impressa e apagada no fim; posições 238, 358 e 477 de 716 bytes. - Roteiro e saída bruta: provar-cifra.sh e saidas-cifra-1.4.2.txt.
8Medida, dinheiro e documentos
A coluna de medida guarda o valor convertido sem perda: 1 lb vira 0.45359237 kg numa coluna medida[kg], e 1 mi vira 1609.344 m numa medida[m]. O calcular --valor soma dinheiro em centavos inteiros e devolve a moeda: 12,50 + 0,25 = 12.75 BRL. A coluna mascara(cpf) aceita o CPF com e sem pontuação, guarda a mesma forma canônica e recusa o CPF com dígito verificador errado.
$ wjsw de-texto "id:i64,peso:medida[kg],preco:dinheiro" m.jsonl m.jsw && wjsw ver m.jsw
2 linhas -> m.jsw
{id:1,peso:0.45359237 kg,preco:12.50 BRL}
{id:2,peso:0.90718474 kg,preco:0.25 BRL}
$ wjsw calcular m.jsw --valor preco
1 grupo(s) em 0.4 ms
total: 2 linha(s) · soma 12.75 BRL · min 0.25 · max 12.5 · media 6.375
$ wjsw de-texto "id:i64,cpf:mascara(cpf),cnpj:mascara(cnpj)" docs.jsonl docs.jsw && wjsw para-texto docs.jsw
2 linhas -> docs.jsw
{id:1,cpf:"12345678909",cnpj:"11222333000181"}
{id:2,cpf:"12345678909",cnpj:"11222333000181"}
- Data: 19/11/2026, 23:07 UTC. Versão:
wjsw1.4.2. Máquina: a mesma da prova 1. - Saída bruta: saidas-1.4.2.txt, seções "1.4.2" e "1.4.0: máscaras".
9Perfis de protocolos de agentes e de comércio
49 objetos de A2A, UCP, ACP, AP2, Verifiable Intent, x402, MPP, AG-UI, OpenTelemetry, L402 e Pix, cada um gravado em .jsw com o esquema do perfil, conferido pela custódia e devolvido em JSON byte a byte igual à amostra: 49 ok, 0 falhas.
$ bash perfis/provar-perfis.sh bin/linux-x86_64/wjsw | tail -1
perfis: 49 ok, 0 falhas
- Data: 19/11/2026, 23:07 UTC. Versão:
wjsw1.4.2 e a pastaperfis/da tagv1.4.2. Máquina: a mesma da prova 1.
10Transmissão pós-quântica
A conexão com jsonw.org negocia a troca de chaves híbrida X25519MLKEM768 (X25519 com o ML-KEM-768 da FIPS 203), com TLS 1.3 e a cifra TLS_AES_256_GCM_SHA384.
$ openssl version
OpenSSL 4.1.0 23 Oct 2026 (Library: OpenSSL 4.1.0 23 Oct 2026)
$ echo | openssl s_client -connect jsonw.org:443 -servername jsonw.org 2>&1 | grep -E "Negotiated|Cipher is"
Negotiated TLS1.3 group: X25519MLKEM768
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
- Data: 19/11/2026, 23:04 UTC. Máquina: servidor Linux no Brasil, OpenSSL 4.1.0.
11SuperVendor: a busca em C sobre jsonW
A busca de empresas do SuperVendor, reescrita em C sobre arquivos jsonW, devolveu a mesma resposta que a busca antiga no banco de dados em 18 de 18 pedidos, inclusive 4 pedidos de WhatsApp. Tempo da busca em C: de 55 a 1.562 ms por pedido; no banco: de 83 a 90.010 ms.
- Data: 13/11/2026, 13:45. Máquina: o servidor de produção da Wortic, numa instância paralela com o SHA-256 do processo conferido antes da prova.
- Método: o mesmo pedido mandado às duas buscas e as respostas comparadas uma a uma; roteiro
prova-sv-busca.sh, registrado no relatório da sessão de 13/11/2026.
12Modelos de IA da Wortic
Os modelos de IA da Wortic respondem a partir de bases de conhecimento em jsonW. Cada um é medido contra o seu gabarito: uma pergunta conta como certa quando o modelo decide e a primeira resposta está entre as aceitas no gabarito; numa pergunta fora do conhecimento, conta como certa quando o modelo diz que não sabe.
| Modelo | Perguntas | Certas | Acerto | Mediana | p95 |
|---|---|---|---|---|---|
| Adam ESG | 967 | 957 | 99,0% | 546 µs | 729 µs |
| Gestão SaaS | 220 | 219 | 99,5% | 191 µs | 436 µs |
| Roteiro | 181 | 181 | 100% | 378 µs | 593 µs |
| Site Construtor | 164 | 157 | 95,7% | 233 µs | 415 µs |
| SuperVendor | 151 | 151 | 100% | 379 µs | 642 µs |
- Data: 16/11/2026, cerca de 22:45. Máquina: o contêiner de compilação da Wortic no servidor de 8 núcleos, gcc 15.3.
- Método: a régua roda todas as perguntas do gabarito de cada modelo e registra perguntas, porcentagem de acerto, top 3, top 10 e os tempos; as certas são a porcentagem aplicada ao total de perguntas.
- Registro: arquivo da régua
regua/depois.jsw.txt, em jsonW-texto, de 16/11/2026.
13Como refazer tudo
As provas 1 e 3 a 9 rodam com o pacote público, numa máquina Linux x86_64, com dois roteiros:
git clone --branch v1.4.2 https://github.com/developer-wortic/jsonw jsonw
mkdir -p exemplos-142/entradas && cd exemplos-142
for f in clin dup hoje leite marcas ontem prod termos vendas; do curl -s -o entradas/$f.jsonl https://jsonw.org/paper/exemplos/$f.jsonl; done
curl -O https://jsonw.org/paper/exemplos/rodar-exemplos.sh -O https://jsonw.org/paper/exemplos/provar-cifra.sh
bash rodar-exemplos.sh ../jsonw saidas.txt
bash provar-cifra.sh ../jsonw saidas-cifra.txt
O rodar-exemplos.sh refaz cada listagem do paper e as provas novas da 1.4.0 à 1.4.2, e escreve cada comando com a saída real embaixo. Os tempos mudam com a máquina; os resultados, as contagens e as mensagens são os mesmos. Correções e medidas de terceiros são bem-vindas pelo repositório público.