Falcato. El primer lenguaje gramatipado y morfosemántico del mundo: la gramática española es el sistema de tipos. Forjado sobre Cranelift. Compila a binarios nativos x86_64. Archivos .exe y .o

El Pipeline se ve así:

.fc → analizador léxico → Parser → Concordancia Lingüística → Codegen (Cranelift) → .o → enlazador → .exe

Opción A — MSI (Windows, recomendado): Descarga falcato-{versión}-x86_64.msi de Releases. Ejecuta el instalador gráfico: selecciona directorio y elige si añadir al PATH.

Opción B — Shell script (Linux/macOS):

curl -fsSL https://github.com/CerebroCanibalus/falcato/releases/latest/download/falcato-installer.sh | sh

Opción C — PowerShell script (multiplataforma):

iwr -useb https://github.com/CerebroCanibalus/falcato/releases/latest/download/falcato-installer.ps1 | iex

Opción D — ZIP manual:

# Extraer y ejecutar el asistente interactivo
.\install.ps1

Una vez instalado Falcato, puedes añadir componentes adicionales:

falcato setup --all        # VS Code extension + agentes OpenCode/Claude
falcato setup --vscode     # Solo VS Code extension
falcato setup --agents     # Solo agentes y skills
falcato setup --uninstall  # Desinstalar componentes adicionales

Abre una terminal nueva y escribe:

falcato version
# → Falcato v0.3.0

falcato run ejemplos\hola_mundo.fc
# → ¡Hola, mundo!

¿Prefieres compilar desde fuente? Ver INSTALL.md

Falcato es un lenguaje de programación de sistemas creado desde cero donde la gramática española es el sistema de tipos y el modelo de ejecución.

No traduce keywords de Rust al español, no interpreta pseudocódigo, y no es un wrapper sobre otro compilador.

Falcato tiene su propio analizador léxico (logos), parser (descendente manual con Pratt), análisis semántico (Concordancia Lingüística), y codegen (Cranelift → .o → .exe). El resultado son binarios nativos x86_64 con ABI de C, sin ejecución oculta, sin recolector de basura.

fn principal() -> Entero32 {
    el mensaje: Palabra = "Falcato compila. Punto.";
    imprimir(mensaje);
    retornar 0;
}

📖 Aprende Falcato desde cero: GUIA.md — 17 capítulos, 5-10 minutos cada uno.

Hay ~600 millones de hispanohablantes en el mundo (nativos + L2, Instituto Cervantes 2024). Menos del 5% programa. La barrera no es la lógica: es el lenguaje de la documentación, los errores y la sintaxis.

Falcato responde a tres preguntas:

Esta es la pregunta que más nos hacen, y merece una respuesta clara:

Falcato no usa español para "traducir keywords y que los latinos aprendan". Lo usa porque el español tiene herramientas gramaticales que el inglés no tiene, y esas herramientas permiten construir sistemas de verificación de compilación más expresivos.

No es una decisión de inclusión: es de ingeniería.

El inglés es un lenguaje analítico y minimalista. El español es flexivo y sintético — transmite mucha más información en cada palabra mediante desinencias, género, número, tiempo, modo y aspecto. En programación, más dimensiones gramaticales = más ejes de verificación.

Un LLM genera texto en lenguaje natural. Cuando el lenguaje de programación es lenguaje natural (estructurado), la distancia entre lo que el LLM "piensa" y lo que escribe se acorta.

// Lo que un LLM "piensa" en español:
// "Guarda este texto en una variable. El texto es mutable (el).
// Si está vacío, retorna error."

// Lo que genera en Falcato:
el contenido: Texto = texto_desde("datos");
si contenido.tam() está 0 { retornar Resultado.Error(-1); }

// En Rust tendría que "traducir" su pensamiento al inglés:
// "Store this text in a variable. The text is mutable (let mut).
// If it's empty, return an error."
let mut contents: String = String::from("data");
if contents.len() == 0 { return Err(-1); }

Esa fricción de traducción es el motivo principal por el que la programación tiene una barrera de entrada artificial para 600M de hispanohablantes. También explica por qué los LLM generan código con más errores semánticos en lenguajes inglés-nativos: el modelo tiene que traducir dos veces (idea → lenguaje natural → código) en vez de una (idea → código en su idioma).

La diferencia crucial entre Falcato y todos los demás lenguajes en español:

En Falcato, cambiar el artículo cambia las garantías de compilación:

la x: Entero32 = 10;    // Prestado, inmutable — no se puede modificar
el x: Entero32 = 10;    // dueño, mutable — se puede modificar
x = 20;                  // ✅ si es 'el', ❌ si es 'la'

Eso no es decoración: es el sistema de affine types integrado en la gramática.

En WN++, pega en vez de fn es un cambio léxico. El intérprete trata pega exactamente como cualquier otro lenguaje trata function o def. En Falcato, el vs la no es léxico — es semántico. El compilador razona sobre esa diferencia.

Falcato existe porque el español tiene recursos gramaticales que permiten construir un lenguaje de sistemas más expresivo y verificable, y más cercano al pensamiento humano, que cualquier lenguaje diseñado exclusivamente en inglés.

No estamos "traduciendo Rust al español". Estamos explorando una pregunta que nadie en la industria del software se ha tomado en serio:

¿Y si 500 años de evolución lingüística pudieran informar el diseño de lenguajes de programación, en vez de ignorarse porque "el inglés es el estándar"?

En Falcato, la concordancia gramatical es verificación de tipos. Un adjetivo que no concuerda con su sustantivo es un error de compilación, igual que en español.

[T001] test.fc:4:8: Disconcordancia de tipo: 'a' es 'Entero32' pero se declaró como 'Booleano'
       │ sugerencia: Cambia el tipo a 'Entero32' o el valor

Si hablas español, ya entiendes la diferencia entre "el libro" (lo tengo yo, puedo cambiarlo) y "la casa" (me la prestaron, solo la uso). Falcato convierte esa intuición en garantías de compilación.

región nombre { ... } — arena asignación determinística. &yo T — estructuras auto-referenciales sin rodeos. Dos cosas que Rust no puede hacer de forma correcta.

lanzar expr → CreateThread real. canal_nuevo → mutex + semaphore + ring buffer. con_executor(N) → grupo de hilos con cancelación estructurada. Todo verificado.

De vez en cuando alguien compara Falcato con Latino, PSeInt, EsJS o proyectos similares. La comparación es natural — todos usan español. Pero técnicamente no pertenecen ni a la misma categoría de lenguaje. Veamos:

PSeInt — Es una herramienta educativa que ejecuta pseudocódigo paso a paso. No produce binarios. No tiene tipos reales. No tiene memoria dinámica. No puede llamar al sistema operativo. No está diseñado para producir software — está diseñado para enseñar lógica a principiantes.

// PSeInt — pseudocódigo educativo, no ejecutable fuera del intérprete
Escribir "Hola mundo"
Leer nombre

Latino — Es un lenguaje interpretado con bytecode VM, como Lua o Python pero en español. Sus tipos son dinámicos. No tiene compilación a nativo. No tiene control de memoria. Es válido como lenguaje de scripting educativo, pero está en las antípodas de un lenguaje de sistemas que corre sobre el metal.

// Latino — scripting dinámico, interpretado, sin tipos estáticos
escribir("Hola mundo")

EsJS — Es un transpilador que reemplaza keywords de JavaScript por sus equivalentes en español (si → if, mientras → while). No tiene su propio parser, no tiene su propio sistema de tipos, no tiene su propio motor. Es JavaScript con un diccionario de sinónimos.

// EsJS — transpila 1:1 a JavaScript. Sigue siendo JS.
si (verdadero) {
    consola.escribir("Hola")
}

Sí — Es un preprocesador que traduce keywords al español y genera código en C++ o Python. No tiene implementación propia. No añade semántica nueva. Es un sed con esteroides.

// Sí — preprocesador que genera C++. No aporta semántica nueva.
imprimir("Hola")

Águila — Se presenta como "lenguaje profesional compilado de alto rendimiento", pero se instala vía npm install -g aguila-lang y su núcleo es privado (no hay compilador real que auditar). Es un lenguaje de scripting dinámico sobre Node.js con keywords y métodos nativos en español. Tiene 54 estrellas en GitHub, un gestor de paquetes, y funcionalidades de ciencia de datos. Su mérito no está en el motor: es esencialmente Node.js con sintaxis en español.

# Águila — scripting dinámico sobre Node.js
funcion saludar(nombre) {
    retornar a"Hola, {nombre}!"
}
imprime(saludar("Mundo"))

WN++ — Es un intérprete tree-walking escrito en Rust con identidad chilena (pega para fn, cachai para if, lorea para print). Es explícitamente educativo: su propósito es que alguien pueda leer el código fuente y entender cómo funciona un intérprete por dentro. Tiene 53 estrellas, es código abierto real, y es honesto sobre no ser un lenguaje de producción (todavía).

// WN++ — intérprete educativo chileno, tipado dinámico
pega fibonacci(n) {
  cachai (n <= 1) { n }
  si no { fibonacci(n - 1) + fibonacci(n - 2) }
}
lorea(fibonacci(10))  // 55

// Falcato — compilador propio, motor Cranelift, tipos reales, posesión, C ABI
el mensaje: Texto = texto_desde("Hola mundo");
imprimir_linea(mensaje);
mensaje.liberar();

inseguro función MessageBoxA(hwnd: Entero64, texto: Palabra,
    titulo: Palabra, tipo: Entero32) -> Entero32;

función principal() -> Entero32 {
    MessageBoxA(0, "Falcato compila a binario nativo", "Falcato", 0);
    retornar 0;
}

La diferencia es de categoría, no de grado:

Falcato no compite con Latino, PSeInt, EsJS, Águila, WN++ o Sí: compite con Rust, C, Go y Zig. Los proyectos en español existentes son herramientas educativas o transpiladores ligeros, válidos en su nicho, pero conceptualmente ortogonales a Falcato.

Sería como comparar Python con C: ambos son lenguajes de programación, pero están diseñados para problemas fundamentalmente distintos.

Si piensas en español cuando programas, Falcato elimina la fricción mental de traducir conceptos al inglés. La posesión, los tipos, los errores — todo en tu idioma.

Nivel 0 siempre compila. El compilador sugiere con códigos + intervalo + corrección concreto. Un LLM genera → compilador sugiere → LLM refina → compila. Menos iteraciones, más confianza.

C ABI por defecto. Cranelift para compilación rápida. Bitfields para hardware. Regiones para asignación de arena. Sin GC, sin ejecución oculta.

La concordancia lingüística hace que los errores sean intuitivos. Un estudiante entiende [T001] sin necesidad de leer documentación técnica.

Falcato + Cranelift + WASM = cadena de herramientas nativa para código generado por IA. Compilación ultra-rápida, sandbox WASM para ejecución segura, binarios nativos para rendimiento.

Falcato existe para una sola razón: hacer cosas que otros lenguajes de sistemas no pueden, no quieren o hacen mal. No es "otro lenguaje de sistemas": es lo que los demás no se atreven a ser.

Son proyectos reales que puedes construir hoy con Falcato y que cualquier programador de sistemas respetaría.

El proyecto por excelencia del programador de sistemas. Falcato está diseñado para esto.

Por qué Falcato encaja aquí:

• bits { } para registros, flags, y estructuras de CPU en tipo puro, sin macros ni crates
• [Entero8; 4096] para memoria del sistema — stack allocation, sin heap, latencia cero
• coincidir opcode { 0x00E0 => ... } para decoding de instrucciones — pattern matching nativo
• lanzar hilo_cpu() y lanzar hilo_ppu() — concurrencia real para CPU + GPU + audio en núcleos separados
• inseguro fn CreateWindowExA(...) — ventana nativa para pixel buffer, sin Electron, sin SDL, sin GLFW Qué sale: Un .exe de 30 KB que corre juegos de NES. Sin dependencias. Sin VM. Sin "runtime".

El administrador de tareas de Windows corre sobre una API C. Falcato habla C de forma nativa.

Por qué Falcato encaja aquí:

• inseguro fn CreateToolhelp32Snapshot(...) — la API de Windows se llama como si fuera Falcato nativo
• con_executor(2) { lanzar actualizar_lista() } — un hilo actualiza procesos, otro refresca la UI
• Diccionario<Entero32, InfoProceso> para asociar PID a proceso sin tener que escribir un hash map
• Vector<InfoProceso> ordenado por CPU, memoria, o nombre — integrado, sin crates Qué sale: Un procexp.exe de 40 KB. Lista procesos, memoria, CPU. Sin .NET, sin Node, sin Electron, sin Python. Cero dependencias.

No es un event loop con corutinas que fingen paralelismo. Es CreateThread real.

Por qué Falcato encaja aquí:

• con_executor(N) { lanzar atender(peticion) } — cada petición en su propio hilo del SO, paralelismo real en todos los núcleos
• canal_nuevo<Socket>(100) + seleccionar { } — aceptar conexiones en un hilo, distribuirlas a workers por canal, todo con cancelación
• inseguro fn send(s: Socket, buf: &[Entero8], ...) — Winsock2 directo, sin wrappers, sin overhead
• Texto para construir respuestas con interpolación: "HTTP/1.1 {codigo} {mensaje}\r\nContent-Length: {tam}\r\n\r\n{cuerpo}" Qué sale: Un server.exe de 25 KB. Sirve archivos estáticos, peticiones concurrentes reales. Sin Node, sin Python, sin IIS, sin Apache.

Manipulación de bytes a nivel de bit con tipos de Falcato.

Por qué Falcato encaja aquí:

• bits { } para interpretar estructuras binarias en tiempo real — FAT, BMP, PNG, ELF, PE
• archivo_leer(ruta) -> Texto — archivo completo a memoria en una línea
• [Entero8; N] para buffer de trabajo — stack allocation, cero GC
• imprimir_linea("{byte_a:08b} | {byte_b:08b}") — dumping binario con interpolación y formato Qué sale: Un hexview.exe de 20 KB. Abre cualquier archivo binario, interpreta cabeceras, edita bytes. Sin Node, sin Python, sin dependencias.

Esto es lo que Falcato hace mejor: concurrencia real + networking + cero GC.

Por qué Falcato encaja aquí:

• con_executor(8) { lanzar gestionar_jugador(socket) } — cada jugador en su propio hilo, paralelismo real
• región partida { ... } — toda la memoria de una partida se asigna al entrar y se libera al salir. Sin GC, sin leaks, sin pausas.
• canal_nuevo<Comando>(256) — cola de comandos del jugador, procesada por el hilo de simulación
• seleccionar { ... } — el hilo de simulación espera comandos de múltiples jugadores a la vez Qué sale: Un server.exe de 35 KB. Sala de juego con 32 jugadores concurrentes, estado compartido sin race conditions, sin GC que pauses el juego.

Falcato es un Lenguaje Natural Controlado (CNL — Controlled Natural Language). Esto significa que es un subconjunto preciso del español con gramática y vocabulario restringidos para eliminar ambigüedad. Como ACE (Attempto Controlled English) o ASD Simplified Technical English, pero diseñado para compilar a código máquina.

Un CNL tiene dos propiedades que lo hacen ideal para IA:

1. Formalizable — su sintaxis restringida se traduce unívocamente a lógica de primer orden (o, en nuestro caso, código Cranelift)
2. Comprensible por humanos — un hispanohablante lo entiende sin aprender una sintaxis nueva

La mayoría de los CNL existentes se usan para especificación de requisitos y representación de conocimiento. Falcato es el primer CNL que compila a binario nativo.

Un lenguaje de programación basado en español tiene ventajas sobre uno basado en inglés cuando el programador es una IA entrenada en lenguaje natural.

1. Los LLMs ya saben español.

Un LLM no necesita aprender qué significa función — ya lo sabe de su entrenamiento en lenguaje natural. Cuando ve el x: Entero32, entiende la posesión implícita de "el" sin haber visto nunca una línea de Falcato en entrenamiento. El conocimiento del español se transfiere directamente a la comprensión del código.

Con Rust o C, el LLM tuvo que aprender sintaxis artificial (fn, let mut, unsafe) desde cero en su entrenamiento con código fuente. Con Falcato, la sintaxis es español. El LLM ya la conoce.

2. La concordancia gramatical es verificación de tipos.

El género gramatical en español (el/la/un/los/las) codifica posesión, mutabilidad y compartición. Un LLM entrenado en español entiende que "el" implica control sobre algo, que "la" implica préstamo temporal, que "los" implica recurso compartido. No necesita aprender un sistema de tipos affine — el español ya se lo enseñó.

3. El modo subjuntivo como marcador de incertidumbre.

si x fuese > 10 — el subjuntivo en español marca irrealidad, duda, condición. Un LLM entiende esta carga semántica implícitamente. En otros lenguajes, la diferencia entre if y if let o entre if y match es sintaxis críptica que el LLM debe memorizar.

4. Eficiencia de tokenización.

Los tokenizadores de LLMs (BPE) fueron entrenados mayoritariamente en inglés. El español tiene aproximadamente 2× más tokens que el inglés para el mismo contenido semántico. Pero para código, la estructura sintáctica de Falcato (palabras significativas en vez de símbolos) puede ser más eficiente en tokens que lenguajes simbólicos como C o Rust. función vs fn gana en legibilidad para el LLM, aunque pierda en caracteres.

5. Lenguaje autocontenido para el agente.

Con Lenguajes Naturales Controlados, la investigación reciente (CNL-P, 2025) demuestra que los LLMs pueden hacer análisis semántico a CNL con más precisión que a lenguajes formales tradicionales, precisamente porque el CNL reduce la distancia entre el prompt natural y el código generado. Falcato lleva esta idea a su conclusión lógica: cero distancia entre el prompt en español y el código Falcato.

Cualquier LLM hoy puede escribir Falcato sin haberlo visto nunca en entrenamiento.

Lo hemos probado con GPT-4, Claude, Gemini, DeepSeek y otros modelos: todos generan código Falcato funcional en el primer intento si se les explica la gramática básica. No necesitan ajuste fino ni ejemplos en el prompt. El conocimiento del español + la gramática restringida del CNL es suficiente.

Para un LLM, Falcato no es "un lenguaje de programación que hay que aprender": es instrucciones en español con formato estructurado. El LLM no traduce tu prompt a código Falcato — el prompt ya está en Falcato.

Flujo de trabajo:

1. El agente IA recibe una instrucción en español
2. Genera código Falcato — que es español estructurado
3. falcato check — análisis completo en <50ms
4. Si hay errores, el compilador da [T001] con intervalo + sugerencia parseable
5. El agente corrige en la siguiente generación
6. falcato build — binario nativo listo en <100ms total

El LSP de Falcato tiene 7 funcionalidades para agentes: autocompletado completo (60+ keywords), ayuda de firmas, acciones de código, símbolos del documento, información contextual mejorada, ir a definición, buscar referencias. Integrado con OpenCode, VS Code, Claude Code, Cursor.

No es una lista de features: es una lista de batallas que dejas de pelear:

• El ownership de Rust sin su complejidad: gradual, educativo, con opciones de fix
• La velocidad de C sin su peligro: nativo, ABI C, pero con verificación de tipos y memoria
• La velocidad de prototipado de Python sin su lentitud: compila rápido, corre rápido
• La simplicidad de Go sin su GC: sin pausas, sin recolector, sin runtime
• Español real: no necesitas inglés para programar sistemas. Los errores los entiendes, no los traduces

• Variables con tipos explícitos (el x: Entero32 = 10)
• Operaciones aritméticas con precedencia (+, -, *, /, %)
• Operaciones de comparación (==, !=, <, >, <=, >=)
• Operadores lógicos (&&, ||, !)
• Asignación a identificadores y elementos de array
• Retorno (retornar valor)

• Condicionales si / sino con ser/estar y subjuntivo
• Bucles mientras y para sobre arrays
• Pattern matching con coincidir
• Select pattern para canales (seleccionar)

• 5 artículos con semántica de posesión
• mover x — transferencia explícita de posesión
• copiar x — clone explícito
• Use-after-move detection (Nivel 1)
• control de préstamos gradual (Nivel 0→2)
• Referencias &T, &mut T, dereferencia *ref
• vidas léxicos: &nombre T
• Field-level préstamo (&mut punto.x vs &mut punto.y)
• Branch-aware liveness (préstamos mueren por rama del CFG)
• Artículos extendidos: los = Posesión compartida, las = Prestado compartido

• Arrays: [T; N], literales, todos expr, acceso, asignación
• Structs: estructural Punto { ... }, disposición C, acceso a campos
• Enums: tag+union, variantes con datos, pattern matching
• Texto: texto en montón con texto_nuevo(), texto_agregar(), texto_liberar()
• Vector: vector en montón genérico con vector_nuevo(), vector_agregar(), etc.
• Resultado<T,E>: Exito(valor) / Error(codigo) con operador ?
• Diccionario/K/V y Conjunto (Fase R4)

• Const generics: fn longitud<N: Entero32>(nums: [Entero32; N]) -> Entero32
• Type generics con bounds: fn máximo<T que Comparable>(a: T, b: T) -> T
• Monomorfización automática por tipo concreto

• Declaración: rasgo Nombre { fn metodo(...); ... }
• Implementación: implementar Rasgo para Tipo { fn metodo(...) { ... } }
• Verificación semántica de métodos requeridos

• Operadores bitwise type-safe: & | ^ << >> ~ >>>
• Funciones integradas I/O: imprimir, imprimir_linea — polimórficos (Texto, Entero, Bool, Flotante)
• Interpolación de texto: imprimir_linea("x = {x}, y = {y}")
• tamaño_de::<T>() — tamaño en tiempo de compilación
• Métodos en enteros: x.poner_bit(3), x.unos(), x.ceros_izquierda()

• inseguro fn para funciones sin cuerpo
• Funciones C integradas: puts, malloc, free, printf
• archivo_leer(), archivo_escribir(), archivo_existe()
• abs(), max(), min(), raiz(), potencia()

• fut fn — funciones async
• esperar expr — await
• lanzar expr — spawn hilo real (CreateThread)
• dormir(ms) — Sleep de kernel32
• Canales mpsc: canal_nuevo, canal_enviar, canal_recibir, canal_intentar
• con_executor(N) — grupo de hilos real con cancelación estructurada
• seleccionar { } — select pattern sobre canales
• Stackless futures (state machine desugaring)

• CLI: falcato build, falcato run, falcato check, falcato lsp, falcato version
• LSP completo: diagnósticos, autocompletado, hover, ir a definición, buscar referencias
• Script build.ps1 automático (auto-detecta Visual Studio)
• 40 tests unitarios pasando
• 50+ ejemplos funcionando

Si quieres contribuir o necesitas la última versión:

• Rust (stable)
• Visual Studio Build Tools → "Desktop development with C++"

git clone https://github.com/CerebroCanibalus/falcato.git
cd falcato
cargo build --release
# falcato.exe está en target/release/

.\target\release\falcato.exe version

Resaltado de sintaxis, LSP integrado y tema "Falcato Dorado":

1. Descarga el .vsix desde Releases
2. Ctrl+Shift+P → "Extensions: Install from VSIX..."
3. Selecciona el archivo .vsix
4. Abre un .fc → sintaxis + diagnósticos en tiempo real
5. Ctrl+K Ctrl+T → busca "Falcato Dorado" para el tema

MIT OR Apache-2.0 — elige la que prefieras.

Falcato no es una traducción de Rust al español. Es un lenguaje de sistemas donde el español es el sistema de tipos. Donde la concordancia gramatical es verificación de compilación. Donde los tiempos verbales son modos de ejecución. Donde 500 años de evolución lingüística se convierten en garantías de código.

  ⠀⠀⠀⠀⠀⠀⠀"多謝垂注"
  ⠀⠀⠀⣏⡱ ⣏⡉ ⣏⡱ ⡇ ⣎⣱   ⡷⢾ ⢇⡸
  ⠀⠀⠀⠧⠜ ⠧⠤ ⠇⠱ ⠇ ⠇⠸   ⠇⠸ ⠇⠸
  ⠀https://ko-fi.com/general_beria