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