Nyx — el lenguaje compilado hecho para agentes de IA

AI-first, por diseño

Hecho para la forma en que la IA escribe código

La mayoría de los lenguajes se diseñaron para humanos y después se les agregaron herramientas encima. Nyx se construyó al revés: cada error, cada capacidad, cada aspereza es algo que un modelo puede parsear, accionar y reportar de vuelta — de forma determinista.

Errores que un modelo parsea

NYX_DIAG=json emite cada diagnóstico como NDJSON con un código estable (NYX01xx–NYX12xx), line:column y una sugerencia de arreglo — en las fases de parse y semantic, multi-error, bilingüe. Sin scrapear stderr, sin adivinar qué falló.

Capacidades que el agente lee

nyx init siembra AGENTS.md (un playbook) y CAPABILITIES.md (un índice por-tarea de la stdlib), y nyx build los mantiene al día. Un agente aprende qué existe sin leer el código de cada módulo.

Inferencia LLM on-device

std/llm bindea llama.cpp: carga un modelo GGUF, genera, transmite tokens de vuelta a Nyx — el drop determinista libera el modelo exactamente una vez. La IA no es solo un servicio al que llamás afuera; es una librería que enlazas.

Un compilador que nunca te atrapa

El parser nunca se cuelga (presupuesto de errores acotado). Sugerencias "did you mean" para métodos, campos y variables. Un canal de fricción (nyx report) convierte los callejones sin salida en feedback estructurado. Cada aspereza es una señal, no una falla silenciosa.

$ NYX_DIAG=json nyx build
{"phase":"semantic","code":"NYX1005","line":12,"col":18,
 "message":"argument 2 of 'indexOf' must be int, got String",
 "hint":"pass a byte offset, e.g. s.indexOf(needle, 0)"}
# una línea, código estable, ubicación exacta, sugerencia accionable — para el modelo, no para el humano

Sintaxis

Como se ve Nyx

Sintaxis limpia y familiar. Compila a codigo nativo via LLVM.

fn handle_usuario(req: Request) -> Response {
    let id: String = req.params.get("id")
    return response_json(200, "{\"id\": \"" + id + "\"}")
}

fn main() {
    let app: App = app_new()
    app_use(app, mw_cors)
    app_get(app, "/usuarios/{id}", handle_usuario)
    serve_app(app, 3000, 64)
}

$ redis-cli -p 6382

> CREATE TABLE eventos (id INTEGER PRIMARY KEY, nombre TEXT)
OK
> INSERT INTO eventos VALUES (1, 'deploy')
OK
> SELECT nombre FROM eventos WHERE id = 1
1) "deploy"

$ redis-cli -p 6381

> ENQUEUE tareas '{"tarea": "enviar_email", "a": "alice@ejemplo.com"}'
"msg_0001"
> DEQUEUE tareas
1) "msg_0001"
2) "{\"tarea\": \"enviar_email\"}"
> ACK tareas msg_0001
OK

fn handle_request(method: String, path: String,
                  headers: Array, body: String) -> Array {
    let hdrs: Array = ["content-type", "application/json",
                       "server", "nyx-http2"]
    return [200, hdrs, "{\"ok\": true, \"protocolo\": \"h2c\"}"]
}

fn main() -> int {
    h2_serve(3004, 4, handle_request)
    return 0
}

Entregado · v0.22

Lo que el lenguaje hace hoy

No es un roadmap — esto está entregado y corriendo en producción. Changelog completo →

Auto-hospedado, con fixed point verificado

El compilador está escrito en Nyx y se compila a sí mismo — recompilar produce IR byte-idéntico. Cada release pasa ese chequeo de fixed point más 300+ tests de regresión.

compilador en Nyx · nativo vía LLVM

Un borrow checker en serio

Move-checking real, detección de use-after-free / double-free sobre memoria manual, drop determinista para tipos #[affine], y análisis de escape de referencias colgantes — opt-in con NYX_BORROW=error.

NYX12xx · gates sound

Async real, WebAssembly, inferencia LLM

Goroutines stackful sobre un scheduler M:N con event loop epoll; make wasm corre Nyx en el navegador con DOM + eventos; std/llm bindea llama.cpp para inferencia on-device.

spawn/await · wasm32 · ggml

Diagnósticos AI-first

Errores machine-readable: NYX_DIAG=json con códigos estables, line:column, multi-error en parse y semantic. Bilingüe vía NYX_LANG. El parser nunca se cuelga.

NYX01xx–NYX12xx · JSON · EN + ES

Empezar

De cero a ejecutar en 30 segundos

1 — Instalar

$ curl -sSf https://nyxlang.com/install.sh | sh

Linux (x86_64, ARM64) · Requiere Clang · ~10 segundos

Verificar: $ nyx --version → nyx 0.22.0

2 — Inicio Rápido

Hola Mundo

$ echo 'fn main() { print("Hola!") }' > hola.nx
$ nyx run hola.nx
Hola!

Crear un proyecto

$ nyx init miapp
$ cd miapp && nyx run
Hola desde miapp!

Servidor web en 8 líneas

import "std/http"

fn serve_req(request: Array) -> String {
    return http_response(200, "Hola desde Nyx!")
}

fn main() {
    http_serve_mt(8080, 4, serve_req)
}

$ nyx run servidor.nx
# Abrir http://localhost:8080

3 — Ejemplos

API JSON

Endpoint REST con rutas y respuesta JSON

▼

import "std/web"

fn get_users(req: Request, resp: Response) {
    response_json(resp, "[{\"name\": \"Alice\"}]")
}

fn main() {
    let app: App = app_new()
    app_get(app, "/api/users", get_users)
    serve_app(app, 3000, 16)
}

Almacén Clave-Valor

Conectar a nyx-kv con el protocolo RESP

▼

fn main() {
    let conn: int = tcp_connect("localhost", 6380)
    tcp_write(conn, "SET nombre Alice\r\n")
    let resp: String = tcp_read(conn)
    print(resp)  // +OK
    tcp_close(conn)
}

Procesar Archivos

Leer, parsear y filtrar contenido de archivos

▼

fn main() {
    let content: String = read_file("datos.csv")
    let lines: Array = content.split("\n")
    var count: int = 0
    for line in lines {
        if line.contains("error") {
            print("Encontrado: " + line)
            count = count + 1
        }
    }
    print("Total: " + int_to_string(count))
}

Tareas Concurrentes

Concurrencia estilo goroutine con canales

▼

fn work(id: int, ch: Map) -> int {
    print("Worker " + int_to_string(id))
    channel_send(ch, id * 10)
    return 0
}

fn main() {
    let ch: Map = channel_new(2)
    thread_spawn(fn() -> int { return work(1, ch) })
    thread_spawn(fn() -> int { return work(2, ch) })
    let r1: int = channel_recv(ch)
    let r2: int = channel_recv(ch)
    print(int_to_string(r1) + ", " + int_to_string(r2))
}

Leer el Libro Probar en Playground

31 capítulos · Bilingüe EN/ES · De lo básico a construir bases de datos

Package Manager

Gestiona tus proyectos Nyx

Todo lo que necesitas para crear, compilar, ejecutar y compartir proyectos Nyx.

Instalar y actualizar

Instalar desde cero

$ curl -sSf https://nyxlang.com/install.sh | sh
  Nyx installed successfully!

Se instala en ~/.nyx/ y enlaza nyx a ~/.local/bin/nyx. Agrega el PATH a tu perfil de shell automáticamente.

Actualizar a la última versión

$ nyx update
Updating Nyx...
Rebuilding compiler...
Rebuilding package manager...
Nyx updated successfully.
nyx 0.22.0

Descarga el código más reciente y recompila. Ejecuta esto en cualquier momento para obtener nuevas funcionalidades y correcciones.

Desinstalar

$ nyx uninstall
Nyx has been uninstalled.
  Removed: ~/.nyx/
  Removed: ~/.local/bin/nyx

Elimina Nyx completamente de tu sistema. Limpio y reversible.

Crear un proyecto

Inicializar

$ mkdir miapp && cd miapp
$ nyx init
Initialized project: miapp
  Created: nyx.toml, src/main.nx
  Build:   nyx build
  Run:     nyx run

nyx init crea dos archivos: nyx.toml (configuración del proyecto) y src/main.nx (punto de entrada).

Estructura del proyecto

miapp/
  nyx.toml          # Configuración del proyecto
  src/
    main.nx         # Punto de entrada (fn main)
  packages/     # Dependencias (se crea automáticamente)
  nyx.lock          # Archivo lock (generado automáticamente)

nyx.toml explicado

# Todo proyecto Nyx tiene un nyx.toml en su raíz
[package]
name = "miapp"          # Nombre del proyecto (nombre del binario)
version = "0.1.0"      # Versión semántica
main = "src/main.nx"   # Archivo de entrada
description = "..."    # Descripción (opcional)
no_gc = false           # Opcional: modo sistemas (sin GC)

[dependencies]
nyx-kv = "*"            # Desde el registro (github.com/nyxlang-dev/)
mylib = "https://..."  # Desde URL personalizada

Compilar y ejecutar

Compilar un proyecto

$ nyx build              # Compilar (debug)
Building: miapp v0.1.0
  Compiling: src/main.nx
✓ Built: miapp

$ nyx build --release    # Compilar con optimizaciones (-O2)
$ ./miapp                # Ejecutar el binario compilado

Compilar y ejecutar en un paso

$ nyx run                # Compilar + ejecutar (dentro de un proyecto)
Hola desde miapp!

Ejecutar un archivo suelto (sin proyecto)

$ nyx run hola.nx        # Compilar y ejecutar un archivo suelto
Hola!

$ nyx hola.nx            # Forma corta — mismo resultado
Hola!

No necesita nyx.toml. Perfecto para scripts y experimentos rápidos.

Dependencias

Agregar un paquete del registro

$ nyx add nyx-kv
Adding package: nyx-kv
  Fetching: https://github.com/nyxlang-dev/nyx-kv
  Updated nyx.toml
Package 'nyx-kv' added.

Los paquetes se descargan de github.com/nyxlang-dev/<nombre> por defecto y se guardan en packages/.

Agregar desde una URL personalizada

$ nyx add mylib --from https://github.com/user/mylib
Package 'mylib' added.

Usa --from para descargar desde cualquier repositorio Git.

Resolución automática

$ rm -rf packages/  # Borrar paquetes locales
$ nyx build             # Se descargan automáticamente
  Resolving: nyx-kv
  Fetched: nyx-kv
✓ Built: miapp

Las dependencias en nyx.toml se resuelven automáticamente al compilar. El archivo nyx.lock registra las versiones exactas.

Referencia de comandos

Comando	Descripción
`nyx init`	Crear un nuevo proyecto (nyx.toml + src/main.nx)
`nyx build`	Compilar el proyecto
`nyx build --release`	Compilar con optimizaciones
`nyx run`	Compilar y ejecutar el proyecto
`nyx run archivo.nx`	Compilar y ejecutar un archivo suelto
`nyx add <pkg>`	Agregar una dependencia del registro
`nyx add <pkg> --from <url>`	Agregar una dependencia desde una URL
`nyx info`	Mostrar detalles del proyecto
`nyx update`	Actualizar Nyx a la última versión
`nyx uninstall`	Eliminar Nyx del sistema
`nyx --version`	Mostrar versión instalada

El lenguaje que los agentes pueden escribir de verdad

Hecho para la forma en que la IA escribe código

Como se ve Nyx

Ocho productos, un lenguaje

Velocidad nativa