Saltar al contenido
cajulang
v0.5.0 · x86-64 · WebAssembly

Código simple.
Ejecutable nativo.

Caju es un lenguaje simple, de tipado estático, que compila directamente a código máquina x86-64, con ejecutables nativos para Linux y Windows, y también a WebAssembly. El compilador está escrito en Caju y se compila a sí mismo, e incluye de serie pruebas y un gestor de paquetes.

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 máquina nativo
ELF, PE, wasm
Linux, Windows y WebAssembly
52 KB
un hello world estático
Etapa 2 = 3
se compila a sí mismo

Fácil de escribir, nativo al ejecutar

Una sintaxis concisa, con tipos opcionales. El compilador genera un binario pequeño y estático, sin runtime que instalar.

Compilación nativa

Caju compila directamente a código máquina x86-64, sin máquina virtual. Un hello world se convierte en un ejecutable estático de 52 KB.

Linux, Windows y WebAssembly

Genera ELF para Linux y PE para Windows: desde el propio Linux, caju build --target windows produce un .exe. Con --target wasm, genera un módulo WebAssembly que se ejecuta en Node o en el navegador, como el playground.

Escrito en Caju

El compilador y el runtime están escritos en el propio lenguaje. El compilador se compila a sí mismo y el resultado es idéntico byte a byte.

Lenguaje completo

Structs, métodos, interfaces, punteros, slices, mapas, closures, defer, panic y recover, y errores como valores.

Tipos opcionales

Anota los tipos cuando quieras: con ellos, el compilador detecta errores antes de que el programa se ejecute. Sin ellos, los tipos se infieren.

Biblioteca estándar

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

Pruebas integradas

caju test ejecuta los archivos _test.caju con describe, it y expect, sin instalar nada.

Gestor de paquetes

Los paquetes son repositorios de GitHub. caju pkg elige las versiones y lo fija todo en un caju.lock con hashes.

Míralo en código

Dos programas cortos, con la salida que imprimen. Hay más en la página de ejemplos.

Los errores son valores

La función devuelve el resultado y un error, sin excepciones ocultas.

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

Un tipo satisface una interfaz solo por tener sus métodos, sin 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 los ejemplos

Frente a frente con Go, Rust y Python

Los mismos algoritmos, con el mismo orden de operaciones, en cada lenguaje. Caju gana o empata con Go en todos los desafíos, queda cerca de Rust y muy por delante de Python.

Tiempo de ejecución (menos es mejor)
DesafíoCajuGoRustPython
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

Tamaño del ejecutable

El mismo programa (fib), compilado en cada lenguaje.
Caju85 KB
Go2298 KB
Rust4436 KB

Medido en noviembre de 2026 en un AMD Ryzen 7 5700G: mejor de hasta 3 ejecuciones, incluido el arranque del proceso. Caju 0.3.0, Go 1.27.3, Rust 1.99.1 (opt-level=3), Python 3.12.3. Programas y resultados completos en bench/compare.

Servidor HTTP: Caju + web frente a Go

La misma API JSON escrita con web, el framework web de Caju, con Gin y con el net/http de la biblioteca estándar de Go. En las mismas CPU, Caju atiende de 1,5 a 2,2 veces más solicitudes por segundo.

1 CPU, 50 conexiones

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 conexiones

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

Solicitudes por segundo con keep-alive (más es mejor). El servidor queda fijado a sus CPU y el generador de carga corre en las demás; Ryzen 7 5700G, WSL2. GET /users devuelve una lista de 50 structs; POST /users lee JSON en una struct. El framework: github.com/cajulang/web · Método y todas las rondas en bench/http

Paquetes directamente desde GitHub

caju pkg viene incluido con el lenguaje. No hay servidor central: un paquete es un repositorio de GitHub con un caju.toml, y su nombre es lo que importas.

  1. Declara
    Las dependencias van en caju.toml, cada una con la versión mínima que necesita el proyecto.
  2. Resuelve
    Cuando dos paquetes piden versiones distintas, se usa la mayor de las mínimas. La elección solo cambia si alguien pide una versión mayor.
  3. Fija
    caju.lock guarda la versión, el commit y el hash SHA-256 de los archivos de cada paquete.
  4. Verifica
    Antes de compilar, caju build y caju run comprueban los hashes. Un archivo modificado impide la compilación.
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

Del código al ejecutable

  1. Instala
    curl -fsSL https://raw.githubusercontent.com/cajulang/cajulang/main/install.sh | sh
    Linux x86-64. En Windows, usa WSL.
  2. Ejecuta
    caju run hello.caju
    Compila en memoria y ejecuta.
  3. Genera el ejecutable
    caju build -o hello hello.caju caju build --target windows hello.caju
    Un binario para Linux y un .exe para Windows.

Compila tu primer programa en Caju

En desarrollo en el compilador nativo: goroutines, canales y select, y las funciones nativas que aún faltan en Windows.