Pular para o conteúdo
cajulang
v0.5.0 · x86-64 · WebAssembly

Código simples.
Executável nativo.

Caju é uma linguagem simples, de tipagem estática, que compila direto para código de máquina x86-64, com executáveis nativos para Linux e Windows, e também para WebAssembly. O compilador é escrito em Caju e compila a si mesmo, e já vem com testes e gerenciador de pacotes.

curl -fsSL https://raw.githubusercontent.com/cajulang/cajulang/main/install.sh | sh
hello.caju
fn greet(name: str) -> str {
return "Hello, " + name + "!"
}
print(greet("world"))
$ caju run hello.caju
Hello, world!
x86-64
código de máquina nativo
ELF, PE, wasm
Linux, Windows e WebAssembly
52 KB
um hello world estático
Estágio 2 = 3
compila a si mesmo

Simples de escrever, nativa ao rodar

Uma sintaxe enxuta, com tipos opcionais. O compilador gera um binário pequeno e estático, sem runtime para instalar.

Compilação nativa

Caju compila direto para código de máquina x86-64, sem máquina virtual. Um hello world vira um executável estático de 52 KB.

Linux, Windows e WebAssembly

Gera ELF para Linux e PE para Windows: do próprio Linux, caju build --target windows produz um .exe. Com --target wasm, gera um módulo WebAssembly que roda no Node ou no navegador, como o playground.

Escrita em Caju

O compilador e o runtime são escritos na própria linguagem. O compilador compila a si mesmo, e o resultado sai idêntico byte a byte.

Linguagem completa

Structs, métodos, interfaces, ponteiros, slices, mapas, closures, defer, panic e recover, e erros como valores.

Tipos opcionais

Anote os tipos quando quiser: com eles, o compilador encontra erros antes de o programa rodar. Sem eles, os tipos são inferidos.

Biblioteca padrão

strings, strconv, math, bytes, os, fs, path, net, http, json, toml, crypto, hash, hex, base64, cli e testing.

Testes embutidos

caju test roda os arquivos _test.caju com describe, it e expect, sem instalar nada.

Gerenciador de pacotes

Pacotes são repositórios do GitHub. caju pkg escolhe as versões e fixa tudo num caju.lock com hashes.

Veja em código

Dois programas curtos, com a saída que eles imprimem. Há mais na página de exemplos.

Erros são valores

A função devolve o resultado e um erro, sem exceções escondidas.

divide.caju
fn divide(a: int, b: int) -> (int, error) {
if b == 0 { return 0, errors.New("division by zero") }
return a / b, nil
}
for _, d := range []int{5, 0} {
q, err := divide(10, d)
if err != nil {
print("error:", err)
continue
}
print("10 /", d, "=", q)
}
$ caju run divide.caju
10 / 5 = 2
error: division by zero

Structs, métodos e interfaces

Um tipo atende a uma interface só por ter os métodos dela, sem declarar nada.

shapes.caju
interface Shape { area() -> num }
struct Rect { w: num, h: num }
struct Circle { r: num }
fn (r: Rect) area() -> num { return r.w * r.h }
fn (c: Circle) area() -> num { return 3.14159 * c.r * c.r }
shapes := []Shape{Rect{2, 3}, Circle{1}}
for _, s := range shapes { print(s.area()) }
$ caju run shapes.caju
6
3.14159
Ver todos os exemplos

Lado a lado com Go, Rust e Python

Os mesmos algoritmos, na mesma ordem de operações, em cada linguagem. Caju ganha ou empata com Go em todos os desafios, fica perto de Rust e muito à frente de Python.

Tempo de execução (menor é melhor)
DesafioCajuGoRustPython
fib n=3525 ms38 ms21 ms1,21 s
sieve n=10M22 ms21 ms24 ms2,17 s
nbody n=1M66 ms173 ms66 ms9,10 s
mandelbrot n=1k39 ms38 ms37 ms6,40 s
matmul n=30010 ms32 ms11 ms5,86 s
sort n=2M142 ms142 ms135 ms7,24 s
maps n=3M513 ms612 ms358 ms1,94 s

Tamanho do executável

O mesmo programa (fib), compilado em cada linguagem.
Caju85 KB
Go2.298 KB
Rust4.436 KB

Medido em novembro de 2026 num AMD Ryzen 7 5700G: melhor de até 3 execuções, incluindo o início do processo. Caju 0.3.0, Go 1.27.3, Rust 1.99.1 (opt-level=3), Python 3.12.3. Programas e resultados completos em bench/compare.

Servidor HTTP: Caju + web contra Go

A mesma API JSON escrita com web, o framework web da Caju, com Gin e com o net/http da biblioteca padrão do Go. Nas mesmas CPUs, a Caju atende de 1,5 a 2,2 vezes mais requisições por segundo.

1 CPU, 50 conexões

req/s
GET /users/:id2,2×
Caju + web72.468
Gin33.424
Go net/http32.687
GET /users2×
Caju + web41.463
Gin18.824
Go net/http21.054
POST /users2,1×
Caju + web65.638
Gin29.354
Go net/http31.434

4 núcleos, 1.000 conexões

req/s
GET /users/:id1,9×
Caju + web134.502
Gin70.738
Go net/http71.297
GET /users1,5×
Caju + web64.907
Gin43.028
Go net/http38.256
POST /users1,8×
Caju + web122.580
Gin60.591
Go net/http66.844

Requisições por segundo com keep-alive (maior é melhor). O servidor fica preso às suas CPUs e o gerador de carga roda nas outras; Ryzen 7 5700G, WSL2. GET /users devolve uma lista de 50 structs; POST /users lê JSON para uma struct. O framework: github.com/cajulang/web · Método e todas as rodadas em bench/http

Pacotes direto do GitHub

O caju pkg vem junto com a linguagem. Não há servidor central: um pacote é um repositório do GitHub com um caju.toml, e o nome dele é o que você importa.

  1. Declare
    As dependências ficam no caju.toml, cada uma com a versão mínima de que o projeto precisa.
  2. Resolva
    Quando dois pacotes pedem versões diferentes, vale a maior das mínimas. A escolha só muda se alguém pedir uma versão maior.
  3. Trave
    O caju.lock guarda versão, commit e o hash SHA-256 dos arquivos de cada pacote.
  4. Confira
    Antes de compilar, caju build e caju run verificam os hashes. Um arquivo alterado impede a compilação.
terminal
$ caju pkg init github.com/acme/app
created caju.toml for github.com/acme/app
$ caju pkg add github.com/acme/strutil
downloading github.com/acme/strutil@1.1.0
added github.com/acme/strutil@1.1.0; 1 packages ok
$ caju run app.caju
CAJU!
$ caju pkg tree
github.com/acme/app@0.1.0
└── github.com/acme/strutil@1.1.0

Do código ao executável

  1. Instale
    curl -fsSL https://raw.githubusercontent.com/cajulang/cajulang/main/install.sh | sh
    Linux x86-64. No Windows, use o WSL.
  2. Rode
    caju run hello.caju
    Compila em memória e executa.
  3. Gere o executável
    caju build -o hello hello.caju caju build --target windows hello.caju
    Um binário para Linux e um .exe para Windows.

Compile seu primeiro programa em Caju

Em desenvolvimento no compilador nativo: goroutines, canais e select, e os recursos nativos que ainda faltam no Windows.