Forja

Un lenguaje de programación en español con VM propia, JIT, compilador ASM (x86-64 / ARM64) y playground WASM

⎔ 2 VMs + JIT Nativo 🦀 Rust backend ⚡ Assembly nativo 🎯 Educativo 📦 Ejecutable único 🌐 WASM 🇪🇸 100% español 🔧 Uops 📐 Optimizador 🎨 GUI nativa (Xilem) 🧬 Traits / Genéricos 🧵 Hilos / Canales 🏷️ Atributos / derive 📖 Doc comments 🌀 GC Generacional 🔀 IR SSA ⚙️ Monomorfización 📈 PGO 📶 JIT Tiered 🪟 Registros / REX 🤖 Android (JNI)

🔥 Filosofía: Aprender conceptos modernos de sistemas (ownership, mutabilidad, borrowing, POO, pattern matching) sin la complejidad sintáctica de Rust, y en tu idioma. Todo en un compilador escrito en Rust puro.

Stack tecnológico

Componente	Tecnología	Archivo(s)
Lenguaje	Rust (edition 2021)	`src/main.rs`, `src/lib.rs`
CLI	20+ comandos en español/inglés	`src/main.rs` (2262 líneas)
Lexer + Parser	Recursive Descent	`src/lexer.rs`, `src/parser.rs`
Tokens	Definición de tokens del lenguaje	`src/token.rs`
AST	Árbol de Sintaxis Abstracta	`src/ast.rs`
Semántica	Type Checker + Borrow Checker	`src/semantics.rs` (2345 líneas)
Tabla de Símbolos	Resolución de nombres y ámbitos	`src/symbol_table.rs`
Descriptores de Clase	Metadatos de clases y herencia	`src/class_descriptor.rs`
Monomorfización	Instanciación de genéricos + inferencia	`src/monomorph.rs` (605 líneas)
IR SSA	Mid-level IR en Static Single Assignment	`src/ir.rs`, `src/ir_constructor.rs`, `src/ir_ssa.rs`
IR → Bytecode	Traducción de IR SSA a opcodes	`src/ir_to_bytecode.rs`
Backend de Registros	Stack→Reg, live intervals, linear scan, x86-64	`src/stack_to_reg.rs`, `src/register_ir.rs`, `src/register_alloc.rs`, `src/codegen_reg.rs`
Bytecode	60+ opcodes stack-based	`src/bytecode.rs` (5107 líneas)
Micro-opcodes	Expansión + optimización de opcodes	`src/uops.rs` (832 líneas)
VM v3 DT	Direct Threading (u8 planos)	`src/vm_jit.rs` (1570 líneas)
VM v5 Fast 🏆	NaN tagging, stack caching, producción	`src/vm_fast.rs` (8694 líneas)
GC Generacional	Young bump + old mark-sweep, write barriers	`src/gc.rs`, `src/gc_intrinsics.rs`
Arena / Shapes	Alocación por arenas y shapes de objetos	`src/arena.rs`, `src/shape.rs`
JIT Nativo ⚡	Generación de código x86-64 en memoria	`src/jit.rs`, `src/jit_engine.rs`
JIT Tiered	Interpret → JitSimple → JitOptimized + OSR	`src/jit_tiered.rs`
PGO	Optimización guiada por perfiles	`src/pgo.rs`
Compilador ASM	x86-64 Win/Linux, ARM64 + gcc -O2	`src/compiler_asm.rs` (3413 líneas)
Backend LLVM	Generación de LLVM IR + optimización	`src/compiler_llvm.rs`, `src/backend_llvm.rs`
Compilador AOT	.exe autónomo con bytecode incrustado	`src/aot.rs`, `src/selfrun.rs`
Optimizador	Constant folding + Dead Code Elimination	`src/optimizer.rs` (2743 líneas)
Cache Incremental	Compilación incremental persistente	`src/incremental_cache.rs`
Módulos	Importación con seguridad anti path traversal	`src/module.rs`
Transpilador Rust	Forja → código Rust	`src/transpiler.rs` (3484 líneas)
Preludio	Funciones intrínsecas del lenguaje	`src/prelude.rs`
WASM	wasm-bindgen → playground en navegador	`crates/forja-wasm/`, `crates/forja-wasm-gui/`
REPL	rustyline, variables persistentes	`src/repl.rs`
Formatter	Formateo automático de código	`src/formatter.rs`
Diagrama	HTML interactivo del AST	`src/diagrama.rs`
FFI	Llamadas a librerías nativas (C)	`src/ffi.rs`
Extensión VSCode	TextMate grammar + snippets	`vscode/forja-syntax/`
Design by Contract	pre/post condiciones, invariantes	`src/ast.rs`, `src/bytecode.rs`
Hot Reload	Recargar módulos en caliente	`src/module.rs`, `src/vm_fast.rs`
Profiler integrado	Perfilado de funciones y VMs	`src/fprofiler.rs`
Package Manager	add, remove, install, forja.json	`src/package_config.rs`, `src/package_resolver.rs`
Debugger DAP	Depurador integrado (DAP) + servidor	`src/debugger.rs`, `src/bin/forja_dap.rs`
Servidor LSP	Language Server Protocol para IDE	`src/bin/forja_lsp.rs`, `src/lsp/`
GUI Nativa	Xilem runtime, ventanas nativas	`crates/forja-gui-rt/` (gui_nativa.rs 6905 líneas)
GUI WASM	GUI Forja en Canvas 2D para navegador	`crates/forja-wasm-gui/`
Android Runtime	VM Forja en Android vía JNI (Rust ↔ Kotlin)	`crates/forja-android-rt/`
Procesos Win	Procesos nativos de Windows	`src/native_proceso_win.rs`
Sistema de Errores	Mensajes de error educativos en español	`src/error.rs`
Base64	Codificación/decodificación Base64	`src/base64.rs`
Criptografía	AES-GCM, ChaCha20-Poly1305, cifrado simétrico	`src/crypto.rs` (1004 líneas)
Criptografía Post-Cuántica	ML-KEM, ML-DSA, SLH-DSA (FIPS 205/206)	`src/crypto_pq.rs`
Hash	BLAKE3, SHA-2, SHA-3 familia completa	`src/hash.rs`
Memory-Mapped Files	E/S de archivos mapeados en memoria	`src/mmap.rs`
HTTP/2 Nativo (Core)	Implementación HTTP/2 sobre h2 crate	`src/native_h2_core.rs` (1370 líneas)
HTTP/2 Nativo (TLS)	Soporte TLS para HTTP/2 nativo	`src/native_h2_tls.rs`
Registro Nativo	Función FFI masiva: 4700+ líneas de bindings	`src/native_registry.rs` (4707 líneas)
SQLite Nativo	Bindings directos a libsqlite3	`src/native_sqlite.rs`
Sandbox	Aislamiento de red/archivos/procesos	`src/sandbox.rs`, `stdlib/std/sandbox.fa`
Terminal	Utilidades de terminal (colores, cursor)	`src/terminal.rs`
stdlib Incrustada	Módulos de std empaquetados en el binario	`src/stdlib_embedded.rs`
API Pública	Biblioteca pública para integración (lib)	`src/lib.rs` (814 líneas)
LSP Completado	Completado inteligente para IDE	`src/lsp/completado.rs`
LSP Firma	Firma de funciones en hover	`src/lsp/firma.rs`
LSP Índice stdlib	Índice de módulos stdlib para LSP	`src/lsp/index_stdlib.rs`
LSP Snippets	Snippets de código para IDE	`src/lsp/snippets.rs`

Hola, Mundo

Así de simple es escribir tu primer programa en Forja:

📄 hola_mundo.fa

// Tu primer programa en Forja
escribir("¡Hola, mundo desde Forja!")

¿Por qué Forja?

🌎

100% en español

Keywords, errores, documentación y mensajes completamente en español. Ideal para hispanohablantes.

🦀

Escrito en Rust

70+ módulos de Rust puro (~94,000+ líneas de Rust, ~6,800 líneas de stdlib en Forja). Sin dependencias externas para el núcleo del compilador (ni serde, ni JSON, ni runtime pesado).

⎔

VMs + JIT

ForjaFast (v5) con NaN tagging y stack caching como VM de interpretación, más la VM Direct Threading (v3) y el JIT nativo x86-64.

⚡

JIT Nativo + ASM

JIT nativo x86-64 en memoria (7x más lento que Rust). Compilador a assembly x86-64/ARM64 con gcc -O2 para velocidad nativa (~80x más rápido que Python).

📦

Ejecutable único

Generá un .exe autónomo con la VM + bytecode incrustado. Funciona en cualquier PC sin dependencias. Tecnología selfrun.

🔍

Borrow Checker

Análisis de ownership y préstamos al estilo Rust, con mensajes de error educativos en español con sugerencias.

💬

REPL interactivo

Probá código línea por línea con feedback inmediato. Las variables persisten entre líneas. Ideal para aprender.

🧱

POO nativa + Pattern Matching

Clases, constructores, métodos, herencia de campos. Y también coincidir/caso con tipos algebraicos (tipo).

🌐

Playground WASM

Compilador y VM compilados a WebAssembly. Ejecutá Forja directamente en el navegador sin instalar nada.

🔧

Micro-opcodes (Uops)

Sistema de expansión de opcodes compuestos a micro-operaciones. Permite optimizaciones como fusión de opcodes y eliminación de push/pop redundantes.

📐

Optimizador de AST

Constant folding en tiempo de compilación y eliminación de código muerto (DCE). Código más eficiente sin esfuerzo.

📂

Sistema de módulos

Organizá tu código en archivos separados con importar. Resolvedor con protección contra path traversal.

🔒

Design by Contract

Precondiciones (requiere), postcondiciones (asegura) e invariantes (siempre) para código más confiable.

🔄

Hot Reload

Recargá funciones y módulos sin reiniciar. Ideal para desarrollo interactivo con feedback inmediato.

📊

Profiler integrado

Perfilá tiempos de ejecución por función. Descubrí cuellos de botella sin herramientas externas.

🔀

IR SSA + Backend de Registros

Mid-level IR en Static Single Assignment con φ-nodes y dominator tree, más un backend register-based completo: stack→registros, live intervals, linear scan y generación x86-64 con encoding REX.

🌀

GC Generacional

Garbage collector generacional: young generation con bump allocation y old generation con mark-sweep. Write barriers, remembered sets y promoción por edad para reemplazar Arc en ForjaFast.

⚙️

Monomorfización de Genéricos

Instanciación de funciones y clases genéricas por tipo concreto (obtener_Entero), con inferencia de tipos desde los argumentos. Elimina el dispatch dinámico.

📈

PGO + JIT Tiered

Optimización guiada por perfiles (--pgo=recoger/usar) y compilación en niveles con contadores de hotness, OSR y deoptimización.

🔷

Compilador LLVM

Backend alternativo que genera LLVM IR. Optimizaciones avanzadas y potencial multi-plataforma con el pipeline LLVM.

🤖

Android Runtime

La VM de Forja corre en Android vía JNI con clases Kotlin (ForjaRuntime, ForjaSession) y Native Activity para la GUI. Compilá tu app con forja construir-apk.

Forja en acción

Mirá cómo se ve el código Forja comparado con Rust. La sintaxis es más natural para hispanohablantes:

🔥 forja/ejemplo.fa🦀 rust/ejemplo.rs

// ——————— Forja ——————————————————————— // ——————— Rust —————————————————————
funcion factorial(n) {                    // fn factorial(n: i64) -> i64 {
    si (n <= 1) {                           //     if n <= 1 {
        retornar 1                               //         return 1
    }                                         //     }
    retornar n * factorial(n - 1)                //     n * factorial(n - 1)
}                                             // }

escribir(factorial(5))                           // println!("{}", factorial(5))
// → 120                                        // → 120

Probá Forja ahora

Elegí tu forma preferida de usar Forja:

⚡ Modos de ejecución

# Assembly nativo (MÁS RÁPIDO ⚡) — x86-64 o ARM64
forja build-asm ejemplos/01_hola.fa -o programa

# Transpilar a Rust
forja transpile ejemplos/01_hola.fa -o programa.rs

# Ejecutar en VM (4 versiones disponibles)
forja run ejemplos/01_hola.fa

# GUI interactiva (requiere --features gui)
cargo run --features gui --bin forja -- run --native ejemplos/204_login_final.fa

# Modo interactivo
forja repl

# Ejecutable autónomo (VM + bytecode)
forja build ejemplos/01_hola.fa -o programa.exe

# En el navegador (WASM)
# Abrí la página de Playground

📊 Comparación de velocidad entre modos

Modo	fib(30)	Bucle suma 10M	nested_loop(1000)	vs Rust nativo
🦀 Rust nativo	~1.94 ms	~2.28 ms	~0.044 ms	1.0x
`transpile` (Forja AOT + rustc -O)	~1.94 ms	~2.28 ms	~0.044 ms	~1.0x ⚡
`build-asm` (gcc -O2)	54.94 μs	—	—	~2.3x ⚡
JIT Nativo x86-64	—	153.18 μs	—	7.0x ⚡
🐍 Python (CPython 3.12)	77.15 ms	320 ms	3.62 ms	~40–140x
`run` (ForjaFast v5 🏆)	113.99 μs	9,544 μs	—	~437x
`run --vm jit` (VM v3 DT)	28.59 μs	34,864 μs	—	~1,597x

Benchmarks actualizados al 9 Jul 2026. Forja AOT transpile + rustc -O rinde igual que Rust nativo (mismo backend LLVM). Los benchmarks de VM varían según el hardware.

Empezá a escribir en 5 minutos

Esto es todo lo que necesitás saber para arrancar:

📝 Conceptos básicos

// Variables mutables e inmutables
variable nombre = "Gaucho"
constante edad = 30

// Condicionales en español
si (edad >= 18) {
    escribir(nombre + " es mayor de edad")
} sino {
    escribir(nombre + " es menor")
}

// Bucles
para (variable i = 0; i < 5; i = i + 1) {
    escribir("Iteración " + i)
}

// Funciones
funcion suma(a, b) {
    retornar a + b
}
escribir("2 + 3 = " + suma(2, 3))

// Clases
clase Persona {
    nombre
    constructor(n) {
        este.nombre = n
    }
    funcion saludar() {
        escribir("Hola, soy " + este.nombre)
    }
}

variable p = nuevo Persona("Ana")
p.saludar()

// Pattern matching
coincidir (dia) {
    caso 1 { escribir("Lunes") }
    caso 2 { escribir("Martes") }
    caso _ { escribir("Otro") }
}

// Tipos algebraicos (enums)
tipo Resultado = Exito(Entero) | Error(Texto)

// Arreglos y mapas
variable arr = [1, 2, 3]
variable m = "nombre": "Ana", "edad": 30

Pipeline de compilación

Forja transforma tu código a través de 5+ fases, pudiendo generar Rust, bytecode (para 2 VMs), assembly nativo, LLVM IR, o ejecutarse en el navegador via WASM:

🔀 Arquitectura completa

┌─────────┐   ┌───────┐   ┌─────┐   ┌──────────────┐   ┌──────────┐   ┌─────────────┐
│ Source  │ → │ Lexer │ → │Parser│ → │Type + Borrow │ → │Optimizer │ → │ Transpiler  │ → Rust .rs
│  .fa    │   │       │   │     │   │   Checker    │   │(fold+DCE) │   │             │
└─────────┘   └───────┘   └─────┘   └──────────────┘   └──────────┘   └─────────────┘
                                                │  Monomorfización (monomorph.rs)
                                                ▼
                                       ┌──────────────┐   ┌──────────────────────┐
                                       │   IR SSA     │   │ Backend de Registros │
                                       │ (ir_constructor│  │ stack_to_reg → reg IR│
                                       │  → ir_ssa)   │   │ → register_alloc     │
                                       └──────┬───────┘   │ → codegen_reg (x86)  │
                                              │            └──────────────────────┘
                                       ┌──────▼───────┐
                                       │ IrToBytecode │
                                       └──────┬───────┘
                                       ┌──────▼───────┐
                                       │ Bytecode Gen │
                                       │  (bytecode)  │
                                       │       ↓      │
                                       │    Uops      │
                                       │ (expansión)  │
                                       └──────┬───────┘
                                              │
        ┌─────────────────────────────────────┼───────────────────────────────┐
        ▼                                     ▼                               ▼
┌──────────────┐   ┌──────────────┐   ┌──────────────┐   ┌────────────────┐   ┌──────────────┐
│ Compilador   │   │ 2 VMs        │   │ JIT Tiered   │   │ Backend LLVM   │   │ AOT + Self   │
│ ASM → .exe   │   │ vm_jit/      │   │ interpret →  │   │ (backend_llvm) │   │ Run → .exe   │
│ (gcc -O2)    │   │ vm_fast 🏆    │   │ jit → opt    │   └────────────────┘   │ autónomo     │
└──────────────┘   └──────────────┘   └──────────────┘                        └──────────────┘
                                                     │
                                              ┌──────▼──────┐
                                              │ WASM (web)  │ → Playground + GUI WASM
                                              └─────────────┘

Arquitectura de ejecución

Forja tiene 5 estrategias de ejecución ordenadas por velocidad:

#	Estrategia	Módulo	Velocidad	Descripción
1	Assembly nativo	`compiler_asm.rs`	⚡⚡⚡⚡⚡	Forja → .s + gcc -O2. Velocidad C/Rust. Multi-arquitectura.
2	Transpilación a Rust	`transpiler.rs`	⚡⚡⚡⚡⚡	Forja → .rs + rustc. Código compilado nativo.
3	Backend de Registros	`codegen_reg.rs`	⚡⚡⚡⚡	IR SSA → register IR → linear scan → x86-64 con encoding REX.
4	JIT Nativo / Tiered (x86-64)	`jit.rs`, `jit_tiered.rs`	⚡⚡⚡	Código máquina generado en memoria con tiers y OSR.
5	ForjaFast (VM v5)	`vm_fast.rs`	⚡⚡	VM con NaN tagging + stack caching + superinstrucciones + GC.
6	VM v3 Direct Threading	`vm_jit.rs`	⚡	VM educativa para referencia y benchmarks.

Documentación

📖