Forja

Un lenguaje de programación en español con VM propia, JIT, compilador ASM (x86-64 / ARM64) y playground WASM
⎔ 3 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
🔥 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

ComponenteTecnologíaArchivo(s)
LenguajeRust (edition 2021)src/main.rs, src/lib.rs
CLI15+ comandos en español/ingléssrc/main.rs (833 líneas)
Lexer + ParserRecursive Descentsrc/lexer.rs, src/parser.rs
SemánticaType Checker + Borrow Checkersrc/semantics.rs
Bytecode40+ opcodes stack-basedsrc/bytecode.rs (1206 líneas)
Micro-opcodesExpansión + optimización de opcodessrc/uops.rs (463 líneas)
VM v1Stack-based originalsrc/vm.rs (2040 líneas)
VM v3 DTDirect Threading (u8 planos)src/vm_jit.rs (649 líneas)
VM v5 Fast 🏆NaN tagging, stack caching, producciónsrc/vm_fast.rs (3610 líneas)
JIT Nativo ⚡Generación de código x86-64 en memoriasrc/jit.rs, src/jit_engine.rs
Compilador ASMx86-64 Win/Linux, ARM64 + gcc -O2src/compiler_asm.rs (2393 líneas)
Compilador AOT.exe autónomo con bytecode incrustadosrc/aot.rs, src/selfrun.rs
OptimizadorConstant folding + Dead Code Eliminationsrc/optimizer.rs
MódulosImportación con seguridad anti path traversalsrc/module.rs
WASMwasm-bindgen → playground en navegadorcrates/forja-wasm/
REPLrustyline, variables persistentessrc/repl.rs
FormatterFormateo automático de códigosrc/formatter.rs
DiagramaHTML interactivo del ASTsrc/diagrama.rs
Extensión VSCodeTextMate grammar + snippetsvscode/forja-syntax/

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

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/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 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
Modofib(30)Bucle suma 100kvs Rust nativo
🦀 Rust nativo~0.01 μs~21.82 μs1.0x
build-asm (gcc -O2)54.94 μs51.24 μs~2.3x
run --asm (gcc -O2)54.94 μs51.24 μs~2.3x
JIT Nativo x86-64153.18 μs7.0x
🐍 Python (CPython 3.11)0.53 μs4,117 μs188.7x
run (ForjaFast v5 🏆)113.99 μs9,544 μs437.3x
run --vm jit (VM v3 JIT-DT)28.59 μs34,864 μs1,597x
run --vm vm (VM v1 Original)20.84 μs91,795 μs4,206x

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 3 VMs), assembly nativo, o ejecutarse en el navegador via WASM:

🔀 Arquitectura completa
┌─────────┐   ┌───────┐   ┌─────┐   ┌──────────────┐   ┌──────────┐   ┌─────────────┐
│ 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:

#EstrategiaMóduloVelocidadDescripción
1Assembly nativocompiler_asm.rs⚡⚡⚡⚡⚡Forja → .s + gcc -O2. Velocidad C/Rust. Multi-arquitectura.
2Transpilación a Rusttranspiler.rs⚡⚡⚡⚡⚡Forja → .rs + rustc. Código compilado nativo.
3JIT Nativo (x86-64)jit.rs⚡⚡⚡Código máquina generado en memoria. 7x más lento que Rust.
4ForjaFast (VM v5)vm_fast.rs⚡⚡VM con NaN tagging + stack caching + superinstrucciones. 4.8x vs Original.
5VM Original / JIT-DTvm.rs / vm_jit.rsVMs educativas para referencia y benchmarks.

Documentación

📖

Instalación

Compilá Forja desde el código fuente. Solo necesitás Rust.

Uso (CLI)

Todos los comandos: run, build, build-asm, transpile, repl, fmt, y más.

📝

Ejemplos

15 ejemplos comentados, desde hola mundo hasta juegos completos.

🔧

Sintaxis

Referencia completa del lenguaje: tipos, funciones, clases, módulos.

🏗️

Arquitectura

Pipeline, VM, bytecode, JIT, compilador ASM, WASM, y más.

🚫

Errores

Sistema de errores educativo con sugerencias en español.

🔄

Roadmap

Estado del proyecto y próximos pasos.

🎮

Playground

Probá Forja en el navegador con WASM. Sin instalación.