Linguagem de sistemas · AI-first · compilada via LLVM

A linguagem escrita para a era da inteligência

Kyven é a primeira linguagem de sistemas AI-first: projetada para que modelos de IA gerem código correto em uma única tentativa — e compilada para binário nativo com performance de nível C.

·
RPS HTTP +18,5% vs C
0
Anotações de memória
0
Dependências externas
Menos tokens que Rust
server.kv quantum: api
-- API HTTP, memória gerenciada pelo compilador
use kv.os.http_server

fn fast greet(req Request) Response
  name = req.param("name")
  body = "{ \"hi\": \"{name}\" }"
  Response.ok(body).with_type("application/json")

fn main()
  server = HttpServer(8080)
  server.iocp()
  server.workers(8)
  server.registerRoute(Router().get("/hi/:name", greet))
  server.start()
  -- sem malloc. sem free. sem GC.
A tese

Linguagens tradicionais têm ambiguidade demais para a IA gerar com confiança.

Toda linguagem feita para humanos esconde decisões avançadas de memória, performance e hot-paths — exigir esse domínio de todo programador seria inviável. Kyven aposta o contrário: modelos de IA operam melhor sobre uma superfície explícita de intenção, desde que o compilador valide, diagnostique e meça. A linguagem não esconde tudo no compilador — ela remove a complexidade acidental e estrutura a estratégica.

Superfície da linguagem

Você & a IA
  • Sintaxe plana, uma forma canônica por intenção
  • Assinaturas top-level claras, sem boilerplate
  • Intenção de otimização declarada, não adivinhada
  • ~30% menos tokens que Rust equivalente
KMM ↓ complexidade mecânica
desce ao compilador
memória, lifetimes, frees
Quantum ↑ intenção estratégica
sobe à superfície
arena, SIMD, paralelismo

Motor de compilação

O compilador
  • Análise de último uso insere frees deterministas
  • Escape analysis decide arena vs heap
  • LLVM 20–22 gera código nativo otimizado
  • Erros estruturados (JSON) para corrigir em loop
Por que Kyven

Sete decisões de design que definem o Kyven.

AI-first de verdade

Gramática LL(1) determinística, uma forma canônica por construct, 1 arquivo = 1 módulo, AST serializável e erros estruturados que alimentam o ciclo gerar → compilar → corrigir. Projetada para o modelo acertar de primeira.

KMM — memória sem anotações

Zero lifetimes, zero GC, zero refcount no caminho comum. O compilador transforma valores heap em SSA e insere o free no último uso seguro. Você escreve código imperativo; a memória se resolve sozinha.

Quantum

Otimização como intenção declarável: arena, simd, parallel, zero_copy. Auditável, mensurável, validada pelo compilador.

Performance de nível C

Toda operação hot-path é builtin nativo. Em nossos benchmarks — lógica idêntica, checksums validados — Kyven iguala ou supera C em SHA-256, JSON, Vec e HTTP, e fica à frente de Go, Java, Node, Python e .NET.

Independente por design

Sem runtime C. Sem libssl, libcurl, zlib. Crypto, TLS, HTTP e drivers em Kyven puro. Um binário, roda em qualquer máquina.

11 tipos concorrentes nativos

Pool, Workers, Batch, Ring, Cache, Limit, Circuit, State, Timer, Meter, Index — com conhecimento direto no compilador. Sem segunda camada lenta sobre wrappers.

Multiplataforma por design

A PAL liga apenas a APIs do próprio sistema operacional (ws2_32, IOCP, io_uring, kqueue). Windows, Linux e macOS validados com paridade de símbolos imposta no CI.

A linguagem, em código

Plana, explícita e sem ruído. Como a IA — e você — querem ler.

Sem chaves, sem ponto-e-vírgula, sem let/var/mut. Uma forma canônica para cada intenção.

hello.kv stdlib
fn main()
  name = "World"
  print("Hello, {name}!")

  -- Vec inicializado direto — sem free manual
  nums = Vec(2, 4, 6, 8)
  total = 0
  for n in nums
    total += n
  print("total = {total}")
KMM · Kyven Memory Model

Segurança de memória sem GC e sem você ver um único lifetime.

KMM substitui malloc/free, garbage collection, reference counting e borrow-checking exposto por gerenciamento em tempo de compilação, baseado em análise de último uso e escape. O programador escreve código imperativo; o compilador transforma valores heap em registradores SSA e insere o free no último uso seguro.

  • Zero anotações. Nada de &T, &mut T ou 'a na superfície.
  • Desalocação determinística. Sem pausas de GC, sem custo de contagem no caminho comum.
  • Escape analysis. O que não escapa vive em arena; o que escapa é gerido com segurança entre fronteiras.
  • Fronteira unsafe declarativa. Apenas Ptr/FFI usa contratos use/edit/keep/take.
kmm.kv compile-time
fn build_greeting(name Str) Str
  s = "hello " + name
  print(s)
  s.upper()

-- o que o compilador deriva, sozinho:
--   alloc  Str  ← "hello " + name
--   use    Str  in print
--   move   Str  → s.upper() consome s
--   free   inserido no último uso seguro
--   escape Str  retornado → ownership ao chamador
Quantum · perfis de compilação

O inverso do KMM: intenção de performance vira sintaxe canônica.

Onde o KMM empurra o mecânico para baixo, o Quantum puxa o estratégico para cima. Técnicas que antes viviam só como heurística interna do compilador, pragmas dispersos ou flags externas tornam-se opções explícitas, auditáveis e mensuráveis — aplicáveis a função, loop, bloco ou objeto.

O compilador nunca abdica da decisão técnica: ele recebe a intenção e responde com aplicação, fallback, warning ou erro — e prova o efeito com benchmark.

enable arena enable simd enable vectorize enable parallel(N) enable workers(N) enable zero_copy enable inline_all enable eliminate_bounds enable io_uring enable pin_cpu(N) enable numa_aware enable keepalive enable shard enable read_ahead(N) 22 capabilities
quantum.kv intent
quantum hot
  enable arena(64kb)
  enable simd
  enable eliminate_bounds

-- aplica a uma função inteira
fn hot transform(data Vec[F64]) F64
  acc = 0.0
  for i in 0..data.len()
    acc += data[i] * 2.0
  acc

-- aplica só a um loop
for hot i in 0..n
  process(i)

-- aplica só a um bloco inline
quantum hot
  total = total + buf.scan()
Performance · benchmarks reais

Não é "rápido para uma linguagem de alto nível". É performance de nível C.

Lógica idêntica em cada linguagem, cada uma com sua stdlib, checksums validados — números reproduzíveis, não slogans. Onde o Kyven ganha, mostramos por quanto; onde empata com C, dizemos. Menor é mais rápido (ms) — exceto throughput HTTP, onde maior é melhor.

SHA-256

ms · 100K iter
Hardware-accelerated (SHA-NI)
Kyven6
Go7
C15
.NET27
Java30
Python78
Node163

JSON parse

ms · 100K
Extração de campos, payload via runtime
Kyven6
C17
Node38
Java62
.NET111
Python129
Go172

HTTP server

RPS · 1 nó
Maior é melhor · servidor estático, Linux
Kyven1.74M
C1.47M
Go0.42M
Node0.09M

SHA-1 HW: 1ms (C: 12ms) · AES-128 HW: 0ms · fib(30)×1M: 0ms · Vec search 10K: 0ms — benchmarks reproduzíveis sob regras estritas de validação.

Eficiência de tokens

Menos tokens, menos ambiguidade, menos pontos de erro.

Cada token a menos é uma chance a menos de a IA errar. A mesma lógica, lado a lado — sem ginástica de sintaxe que favoreça um dos lados.

Kyvencanônico
struct User
  name Str
  age Int

fn tier(u User) Str
  ? u.age < 13 : "kid"
  ? u.age < 18 : "teen"
  "adult"

fn main()
  users = Vec()
  users.push(User { name: "Ana", age: 9 })
  users.push(User { name: "Léo", age: 30 })
  for u in users
    print("{u.name}: {tier(u)}")
Javaequivalente
import java.util.*;

record User(String name, int age) {}

public class Main {
  static String tier(User u) {
    if (u.age() < 13) return "kid";
    if (u.age() < 18) return "teen";
    return "adult";
  }
  public static void main(String[] args) {
    List<User> users = new ArrayList<>();
    users.add(new User("Ana", 9));
    users.add(new User("Léo", 30));
    for (User u : users)
      System.out.println(u.name() + ": " + tier(u));
  }
}
menos tokens que Java neste exemplo — sem public static, sem tipos repetidos, sem new, com guards ? cond : e interpolação nativa.
Em média, ~30% a menos que Rust para código equivalente.
Independência por princípio

Kyven é independente. Zero dependências. Um binário.

Kyven não tem runtime em C. Nenhuma parte do seu comportamento observável depende de uma biblioteca externa. Crypto, TLS 1.3, HTTP/2, compressão e drivers de banco são 100% Kyven. Quatro camadas, escopo absolutamente claro.

Stdlib · .kv Todo algoritmo e estrutura de dados. Parsers, protocolos, routers, middleware, serializadores, crypto, compressão, caches, filas — tudo escrito em Kyven.
Compiler builtins A definição da própria linguagem. Tipos e operações com suporte de MIR/codegen: Workers, Pool, Batch, Buff, intrinsics e as capacidades quantum.
PAL · OS bridge Exclusivamente ponte para APIs do SO. syscalls, IOCP, io_uring, kqueue, BCryptGenRandom, CreateThread — apenas o que o sistema operacional já oferece. Toda a lógica e as estruturas de dados vivem em Kyven.
Libs externas Nenhuma. Sem libssl, libcrypto, boringssl, libcurl, libuv, zlib — a PAL só liga com o que já faz parte do SO (ws2_32, advapi32, crypt32, libpthread).
Baterias incluídas

11 tipos concorrentes nativos. Uma stdlib pronta para produção.

Tipos com conhecimento direto no compilador — sem segunda camada lenta — e mais de 60 módulos para backend e sistemas reais.

Pool
pool de objetos thread-safe
Workers
fan-out / fan-in de tarefas
Batch
acúmulo por threshold
Ring
buffer circular iterável
Cache
cache com TTL e eviction
Limit
rate limit / concorrência
Circuit
circuit breaker
State
estado atômico compartilhado
Timer
tempo decorrido / ticks
Meter
contadores e métricas
Index
índice chave→valor
+ Vec Map Str Buff
tipos nativos first-class
corejson · option · result · slice · traits
cryptosha1/256/512 · aes · hmac · hkdf · md5 · ecdsa
tlsTLS 1.2 + 1.3 · ALPN · SNI · HelloRetry · PEM/PKCS
nettcp · udp · dns · ipv6 · socket · websocket
httpHTTP/1.1 · HTTP/2 · router · middleware · keep-alive
dbPostgreSQL · MySQL · MSSQL · Oracle · ODBC
osfs · io · sys · async · gzip · math · multipart
allocvec · map · set · string heap-allocated
Construído com Kyven

Feito para o que a era da IA está construindo.

Backends & APIs de alta vazão

Servidores HTTP/HTTPS com router, middleware, route params, keep-alive e IOCP/io_uring — entregando mais de 1,7M RPS sem framework externo.

Sistemas seguros & crypto

TLS 1.3 completo, AES, SHA, HMAC e ECDSA em Kyven puro. Sem superfície de ataque herdada de libs externas, sem dependência de OpenSSL.

Pipelines de dados

Drivers nativos para Postgres, MySQL, MSSQL e Oracle, com pool de conexões, cursores em streaming e parsing de protocolo em alta performance.

Infra para agentes de IA

A linguagem que a IA escreve corretamente em one-shot é a linguagem ideal para o código gerado por IA: previsível, verificável e nativa — pronta para fechar o loop gerar→compilar→corrigir.

Onde o Kyven se posiciona

O melhor de cada linguagem, sem os custos de cada uma.

 KyvenCRustGoJava.NETPHPPython
Performance nativa
Memória sem GC
Sem anotações de lifetime
Otimização como intenção
Projetada para geração por IA
Zero dependências externas
Binário único de deploy

nativo / por design  ·  parcial / com esforço  ·  ausente

Status honesto

Realidade, plano e pesquisa — claramente separados.

"Implementado" no Kyven significa: código escrito + compilou + executou + resultado verificado correto. Nada de promessas vazias.

Implementado & verificado
  • Pipeline de compilação nativo via LLVM
  • Modelo de memória (KMM) validado por testes e AddressSanitizer
  • 22 capabilities quantum + perfis de compilação
  • 11 tipos concorrentes builtin
  • TLS 1.3 server-side em Kyven puro
  • Drivers PostgreSQL · MySQL · MSSQL · Oracle
  • Cross-platform: Windows · Linux · macOS
Em consolidação
  • KMM — cobertura de testes rumo à garantia formal
  • Quantum — medição de efeito por capability
  • Generics e traits (formas avançadas)
  • HTTP/2 produção · streaming · WebSocket
  • Concorrência async/pool/job — maturidade
Comece em minutos

Compile seu primeiro programa Kyven.

Toolchain: LLVM 20–22, clang e Rust 1.82+. Clone, compile o driver e rode. Um binário, zero dependências de runtime.

# build do compilador $ cargo build --release --bin kyven   # compilar e rodar $ kyven build examples/hello.kv $ kyven run examples/hello.kv Hello, World!   # o que o quantum aplicou $ kyven build server.kv --quantum-report