Forja
Stack tecnológico
| Componente | Tecnología | Archivo(s) |
|---|---|---|
| Lenguaje | Rust (edition 2021) | src/main.rs, src/lib.rs |
| CLI | 15+ comandos en español/inglés | src/main.rs (833 líneas) |
| Lexer + Parser | Recursive Descent | src/lexer.rs, src/parser.rs |
| Semántica | Type Checker + Borrow Checker | src/semantics.rs |
| Bytecode | 40+ opcodes stack-based | src/bytecode.rs (1206 líneas) |
| Micro-opcodes | Expansión + optimización de opcodes | src/uops.rs (463 líneas) |
| VM v1 | Stack-based original | src/vm.rs (2040 líneas) |
| VM v3 DT | Direct Threading (u8 planos) | src/vm_jit.rs (649 líneas) |
| VM v5 Fast 🏆 | NaN tagging, stack caching, producción | src/vm_fast.rs (3610 líneas) |
| JIT Nativo ⚡ | Generación de código x86-64 en memoria | src/jit.rs, src/jit_engine.rs |
| Compilador ASM | x86-64 Win/Linux, ARM64 + gcc -O2 | src/compiler_asm.rs (2393 líneas) |
| Compilador AOT | .exe autónomo con bytecode incrustado | src/aot.rs, src/selfrun.rs |
| Optimizador | Constant folding + Dead Code Elimination | src/optimizer.rs |
| Módulos | Importación con seguridad anti path traversal | src/module.rs |
| WASM | wasm-bindgen → playground en navegador | crates/forja-wasm/ |
| 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 |
| Extensión VSCode | TextMate grammar + snippets | vscode/forja-syntax/ |
Hola, Mundo
Así de simple es escribir tu primer programa en Forja:
// 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
26+ módulos de Rust puro. Sin dependencias externas para el núcleo del compilador (ni serde, ni JSON, ni runtime pesado).
3 generaciones de VM + JIT
Desde la VM original hasta la v5 con NaN tagging y stack caching. JIT nativo x86-64. Cada versión es una lección de optimización.
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.
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 ——————————————————————— // ——————— 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:
# Assembly nativo (MÁS RÁPIDO ⚡) — x86-64 o ARM64
forja build-asm examples/01_hola.fa -o programa
# Transpilar a Rust
forja transpile examples/01_hola.fa -o programa.rs
# Ejecutar en VM (4 versiones disponibles)
forja run examples/01_hola.fa
# GUI interactiva (requiere --features gui)
cargo run --features gui --bin forja -- run --native examples/204_login_final.fa
# Modo interactivo
forja repl
# Ejecutable autónomo (VM + bytecode)
forja build examples/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 100k | vs Rust nativo |
|---|---|---|---|
| 🦀 Rust nativo | ~0.01 μs | ~21.82 μs | 1.0x |
build-asm (gcc -O2) | 54.94 μs | 51.24 μs | ~2.3x ⚡ |
run --asm (gcc -O2) | 54.94 μs | 51.24 μs | ~2.3x ⚡ |
| JIT Nativo x86-64 | — | 153.18 μs | 7.0x ⚡ |
| 🐍 Python (CPython 3.11) | 0.53 μs | 4,117 μs | 188.7x |
run (ForjaFast v5 🏆) | 113.99 μs | 9,544 μs | 437.3x |
run --vm jit (VM v3 JIT-DT) | 28.59 μs | 34,864 μs | 1,597x |
run --vm vm (VM v1 Original) | 20.84 μs | 91,795 μs | 4,206x |
Empezá a escribir en 5 minutos
Esto es todo lo que necesitás saber para arrancar:
// 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 3 VMs), assembly nativo, o ejecutarse en el navegador via WASM:
┌─────────┐ ┌───────┐ ┌─────┐ ┌──────────────┐ ┌──────────┐ ┌─────────────┐
│ Source │ → │ Lexer │ → │Parser│ → │Type + Borrow │ → │Optimizer │ → │ Transpiler │ → Rust .rs
│ .fa │ │ │ │ │ │ Checker │ │(fold+DCE) │ │ │
└─────────┘ └───────┘ └─────┘ └──────────────┘ └──────────┘ └─────────────┘
════════════════════════════════════════
‖ Rutas alternativas: ‖
════════════════════════════════════════
┌──────────────────┐
│ Compilador ASM │ → .s → gcc -O2 → .exe (⚡ nativo)
│ (compiler_asm) │ x86-64 / ARM64
└──────────────────┘
┌──────────────┐ ┌──────────────────────┐
│ Bytecode Gen │ → │ 3 VMs disponibles: │
│ (bytecode) │ │ vm (v1 original) │
│ ↓ │ │ vm_jit (v3 DT) │
│ Uops │ │ vm_fast (v5 prod) 🏆│
│ (expansión) │ │ │
└──────┬───────┘ │ JIT Nativo x86-64 │
│ │ + fallback a VM │
│ └──────────────────────┘
│
┌─────▼──────┐
│ AOT + Self │ → .exe autónomo
│ Run │
└────────────┘
┌──────────────────┐
│ WASM (navegador) │ → Playground web
└──────────────────┘ 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 | JIT Nativo (x86-64) | jit.rs | ⚡⚡⚡ | Código máquina generado en memoria. 7x más lento que Rust. |
| 4 | ForjaFast (VM v5) | vm_fast.rs | ⚡⚡ | VM con NaN tagging + stack caching + superinstrucciones. 4.8x vs Original. |
| 5 | VM Original / JIT-DT | vm.rs / vm_jit.rs | ⚡ | VMs educativas para referencia y benchmarks. |