Cyr es el dialecto nativo de Cyra — compilado AOT mediante LLVM, desde servidores hasta un MCU desnudo. Sin VM, sin GC. El lenguaje que escriben las máquinas, ahora sobre el metal.
Esta página comparte las primeras ideas, la filosofía de concepción y las expectativas para Cyr. El nombre, la relación tronco/rama, los nombres del runtime y de la CLI, y un conjunto de decisiones angulares están fijados — pero Cyr aún no está disponible. Lo que lees aquí es una carta, no un lanzamiento.
Por qué existe Cyr
Cyra es excelente en aquello en lo que la BEAM es excelente: sistemas concurrentes, tolerantes a fallos y recargables en caliente. Pero clases enteras de trabajo viven por debajo de esa línea. Hoy, un desarrollador que choca con el muro debe bajar a C, Rust o Zig y abandonar el lenguaje por completo. Cyr es la salida de emergencia que te mantiene en la familia.
Cyr compila por adelantado a código objeto nativo mediante LLVM — sin VM, sin JIT. Un binario autónomo que se ejecuta en una plataforma Tier-1 sin nada instalado.
cyrtUn pequeño runtime enlazado en cada binario — asignador, manejador de pánico, intrínsecos. Apuntado a unos pocos cientos de kilobytes, no megabytes. Embebido y plausible en WASM.
@external(c, "...") es la única superficie de interoperabilidad nativa.
Llama a C y sé llamado por C con firmas completas, anchuras explícitas y
nulabilidad explícita — sin pegamento escrito a mano.
Flujo solo con switch, Option/Result,
tipos explícitos — ~85% de gramática idéntica a Cyra. La destreza y el
código cruzan la frontera gestionado/nativo.
Un lenguaje, dos dialectos
Una gramática, un núcleo semántico, dos backends — igual que C tiene una implementación hospedada y otra independiente. El tronco es la gramática compartida; las dos ramas divergen solo donde el modelo de runtime las obliga.
// el dialecto BEAM
Cálido y gestionado. Corre sobre una máquina.
pid / ref / port:erlang.* FFI · Cyra.* stdlib// el dialecto nativo
Metal puro. Es el código máquina.
ptr<T>, @external(c, "...")bigint opcionalcyrt runtime · Cyr.* stdlibAlcance de sistemas y SO
Cyr apunta explícitamente al desarrollo de sistemas de bajo nivel y de SO —
hasta e incluyendo un init/PID 1, demonios, controladores y código
bare-metal independiente. Cuanto más exigente es el perfil, más se aparta el lenguaje
del camino. El alcance de Cyr se organiza en tres perfiles de ejecución.
app · demonio · CLI
Un programa nativo normal sobre un SO completo. Toda la pila está disponible, y
cyrt usa el heap del SO y los hilos del SO.
init / PID 1 · binario estático mínimo
Hay un kernel presente, pero el userland es mínimo. El PID 1 no debería arrastrar una libc completa — una fina capa de syscalls directas habla con el kernel.
kernel · bootloader · firmware · ISR
Ningún SO en absoluto. Tú aportas el asignador; no hay hilos, ni libc,
ni desenrollado. Asm en línea, volatile/MMIO, atómicos, puntos de
entrada personalizados.
Míralo en acción
Un fragmento de controlador con FFI de C23, disposición empaquetada, Option
en lugar de null, y recursión de cola que corre en pila constante — todo con la
familiar sintaxis de Cyra.
module Sensor.Driver {
use Cyr.Result;
// C23 FFI — the single native interop surface
@external(c, "read_register")
fn read_register(addr: ptr<u32>) -> u32;
@repr(packed)
struct Reading { id: u16; value: i32; }
// switch-only flow; Option<T> for absence, never null
pub fn decode(raw: u32) -> Option<Reading> {
switch raw {
0 => None;
_ => Some(Reading { id: 1, value: raw as i32 });
}
}
// guaranteed constant stack — TCO holds at the CIR layer
fn sum(xs: list<i64>, acc: i64) -> i64 {
switch xs {
[] => acc;
h :: rest => sum(rest, acc + h); // i64 traps on overflow
}
}
@entry
pub fn main() -> i32 { 0; }
}Lo que ya está fijado
Cyr parte de las premisas que Cyra ya asentó, más un conjunto de puertas de un solo sentido ratificadas por el consejo de filosofía en la concepción. Estas son las expectativas a las que Cyr se compromete.
i64 por defecto; la aritmética atrapa por defecto.
wrapping, saturating y bigint
son opciones explícitas.
nil se retira de los tipos que no son Option. Null vive
solo detrás de ptr/any en el muro de C.
La recursión en posición de cola — incluida la recursión mutua — corre en pila constante. Una garantía semántica en la capa CIR, no fe en LLVM.
La memoria es ARC + arena opcional + weak. La seguridad se reubica
en los valores por defecto del compilador, no en anotaciones de tiempo de vida
escritas por el autor — la decisión correcta para un corpus escrito por LLM.
unsafe ruidoso y mínimo
El desreferenciado de ptr<T> en crudo y los down-casts de
any viven solo dentro de unsafe — localizable con
grep y auditable.
Cyr.* separada
Cyr reescribe su biblioteca estándar de forma nativa. La portabilidad vive en la
gramática, no en los nombres de la biblioteca — una línea use
siempre es honesta sobre su dialecto.
Posicionamiento honesto
Cyr no es "Cyra 2.0" y no diverge en sintaxis. Es un solo lenguaje con dos backends — no dos lenguajes compitiendo.
Cyr forma parte del mismo proyecto — las mismas herramientas, la misma comunidad — no un producto rival con su propia identidad.
pid, ref, port, spawn,
receive, send se eliminan. Cualquier cosa parecida a
un actor es una biblioteca, no una primitiva del lenguaje.
Cyr es para quienes ya aman Cyra y ahora quieren escribir la capa que está por debajo de sus aplicaciones — no una propuesta para el público general de la programación de sistemas.
Filosofía de diseño
"Continuidad de código y destreza"
La máxima pragmática de Peirce es la prueba de Cyr: ¿qué diferencia concreta aporta Cyr que "Cyra más simplemente usar C" no aporta? La respuesta — continuidad de código y destreza a través de la frontera gestionado/nativo — gobierna cada decisión de diseño.
"Gramática compartida, biblioteca honesta"
Los dialectos comparten ~85% de su sintaxis — el verdadero activo transferible. Deliberadamente no comparten los nombres de las bibliotecas: la coherencia pertenece a la sintaxis y la CLI; la honestidad pertenece al espacio de nombres.
"Veintiún filósofos, una carta"
Las Cuatro Causas de Aristóteles enmarcan el esfuerzo; Popper nombra lo que falsificaría el éxito; las antinomias de Kant mantienen honesto al consejo. Dieciocho dominios de diseño abiertos fueron leídos por los veintiuno, y las decisiones angulares ratificadas — el consejo funciona como organon, abierto en GitLab.