Libre de herencia.
El siguiente capítulo en programación de sistemas.

Lyx no es solo otro lenguaje. Binarios nativos Linux x86_64, Linux ARM64 — sin libc, y Windows x64 sin enlazador, puro syscalls y WinAPI.

Inicio Rápido

Comienza con Lyx en minutos.

TERMINAL 
# Construir compilador
make build

# Compilar y ejecutar programa Linux
./lyxc examples/hello.lyx -o hello
./hello

# Compilación cruzada para Windows
./lyxc examples/hello.lyx -o hello.exe --target=win64

# Debug flags
./lyxc examples/hello.lyx --emit-asm      # Emitir IR como pseudo-ensamblador
./lyxc examples/hello.lyx --dump-relocs   # Mostrar realocaciones y símbolos
./lyxc examples/hello.lyx --no-opt         # Desactivar optimizaciones IR

Salida:

Hello Lyx

Sin LibC.
Sin compromisos.

Mientras otros lenguajes dependen de enormes bibliotecas estándar, Lyx habla directamente con el núcleo Linux y la API de Windows. Compilación cruzada incluida.

  • ✓
    Compilación Cruzada Linux x86_64 + ARM64 + Windows x64
  • ✓
    Comunicación Directa Syscall/WinAPI
  • ✓
    Sistema de Módulos Completo con std-Library
  • ✓
    Huella Binaria Mínima (desde 4KB)
Tamaño Binario Complejidad
Otros (enlazado dinámicamente) ~800 KB
Lyx (nativo estático) 4-42 KB

Compilación Cruzada

Una base de código, seis plataformas. Lyx soporta compilación cruzada para Linux, Windows, macOS y ESP32.

🐧

Linux x86_64

Binario ELF64 con SysV ABI. Syscalls directos para máximo rendimiento.

./lyxc app.lyx -o app
🍎

Linux ARM64

Raspberry Pi, Apple Silicon Linux, Cloud Servers

./lyxc app.lyx -o app --target=arm64
🪟

Windows x64

Binario PE32+ con convención de llamadas Windows x64. Shadow space + IAT.

./lyxc app.lyx -o app.exe --target=win64
🍎

macOS x86_64

Intel Macs, Mach-O binary with BSD syscalls

./lyxc app.lyx -o app --target=macosx64
🍎

macOS ARM64

Apple Silicon Macs, M1/M2/M3 chips

./lyxc app.lyx -o app --target=macos-arm64
📟

ESP32

Xtensa microcontroller, GPIO, UART, built-in syscalls

./lyxc app.lyx -o app.elf --target=esp32
Objetivo Formato Convención de Llamadas Interfaz SO Status
linux ELF64 SysV ABI (RDI, RSI, RDX, RCX, R8, R9) Syscalls Stable
arm64 ELF64 AAPCS64 (X0-X7) Syscalls Stable
win64 PE32+ Windows x64 (RCX, RDX, R8, R9 + Shadow Space) kernel32.dll Stable
macosx64 Mach-O SysV ABI BSD Syscalls Stable
macos-arm64 Mach-O AAPCS64 BSD Syscalls Stable
esp32 ELF32 Xtensa (A2-A7) GPIO, UART Experimental

Nota: El parámetro --target es opcional. El compilador selecciona automáticamente el SO host como objetivo. El parámetro --arch también es opcional — la arquitectura se infiere automáticamente del objetivo.

Architecture Parameter: --arch

You can also explicitly specify the architecture using --arch:

./lyxc app.lyx -o app --target=macosx64 --arch=x86_64
./lyxc app.lyx -o app --target=macos-arm64 --arch=arm64
./lyxc app.lyx -o app --target=esp32 --arch=xtensa
--arch=x86_64
64-bit x86 (Intel/AMD)
--arch=arm64
64-bit ARM (Apple Silicon)
--arch=xtensa
Xtensa (ESP32)

Probar binarios ARM64 en x86_64:

# Instalar QEMU
sudo apt install qemu-user-static

# Ejecutar binario ARM64
qemu-aarch64-static ./program

¿Por qué Lyx?

La libertad de la directeidad. En un mundo donde los lenguajes modernos a menudo arrastran runtimes enormes y dependencias complejas, Lyx vuelve a las raíces de la programación de sistemas — sin sacrificar la sintaxis moderna.

⚡

Cero Dependencias

Verdadera independencia binaria. La mayoría de los lenguajes dependen de la biblioteca estándar C o enlazadores externos. Lyx rompe con esta tradición.

  • ✓ Generación directa de ELF64 y PE32+
  • ✓ Sin enlace libc, syscalls directos
  • ✓ Single-toolchain: solo lyxc necesario
🔗

Funciones Externas

No estás aislado. Lyx soporta integración de bibliotecas externas cuando las necesitas.

  • ✓ extern fn extern fn para integración libc/libm
  • ✓ Soporte Linux .so y Windows .DLL
  • ✓ PLT/GOT para enlace dinámico
  • ✓ Varargs: printf(fmt, ...)
🔒

Seguridad a través de Tipado

Lyx no es un lenguaje de scripting flexible. Está construido para sistemas en los que puedes confiar.

  • ✓ Sin casteos implícitos — errores cortados de raíz
  • ✓ var, let, co, con clases de almacenamiento
  • ✓ Control total sobre mutabilidad
✨

Lo Mejor de Tres Mundos

Lyx combina las fortalezas de lenguajes establecidos en algo nuevo.

  • C — C — El poder de la programación de sistemas
  • Rust — Rust — Enfoques de seguridad y tipado estricto
  • Pascal — Pascal — Claridad y legibilidad de la sintaxis

Tipos de Datos

Sistema de tipos completo con tipado estricto y sin casteos implícitos.

Categoría Tipos Descripción
Entero con Signo int8 int16 int32 int64 Signed 8/16/32/64-bit integers. int = int64
Entero sin Signo uint8 uint16 uint32 uint64 Unsigned 8/16/32/64-bit integers. uint = uint64
Punto Flotante f32 f64 32-bit and 64-bit IEEE 754 floating point
Puntero pchar pchar? Non-nullable (default) and nullable pointers. pchar = null-terminated string
Booleano bool true / false
Especial void usize isize Retorno void, unsigned/isigned size_t
Arreglos array parallel Array<T> Stack-allocated and SIMD-optimized heap arrays
Map & Set Map<K,V> Set<T> Associative arrays with O(n) lookup
QBool QBool Probabilistic boolean (0.0 to 1.0)
🔄

Conversión de Tipos

Casteo explícito con el operador as.

var f: f64 := 42 as f64;
var i: int64 := 3.14 as int64;
❓

Tipos Nullable

Los tipos puntero pueden ser nullable con ?

var p: pchar? := null;
var q: pchar := p ?? "fallback";
⚡

Arreglos SIMD

parallel Array para operaciones vectorizadas.

var v: parallel Array<Int64>;
var sum := v + v; // SIMD

Casos de Uso

¿Qué puedes construir con Lyx?

🖥️

Programación de Sistemas

Acceso directo a hardware, drivers, componentes de sistema operativo. Control total sin sobrecarga de abstracción.

☁️

Cloud-Native

Imágenes de contenedor mínimas, microservicios, listo para Kubernetes. Binarios ultra-pequeños para máxima densidad.

🔌

Sistemas Embedidos

Huella mínima desde 4KB, sin runtime requerida. Perfecto para entornos restringidos.

📚

Educación

Sintaxis clara y legible inspirada en Pascal. Perfecto para aprender conceptos de programación de sistemas.

MAIN.LYX 
import std.math;

type Point = struct {
    x: int64;
    y: int64;
};

fn main(): int64 {
    // Struct literal with fields
    var p: Point := Point { x: 10, y: 20 };
    
    // Pipe operator and standard library
    let result: int64 := -42 |> Abs64();
    
    PrintInt(p.x + result);  // 52
    return 0;
}

Características Avanzadas del Lenguaje

Funciones potentes para programación de sistemas moderna

📊

Global Variables

Declare variables at top-level for global state.

var globalCounter: int64 := 0;
let maxSize: int64 := 1024;

fn increment() {
  globalCounter := globalCounter + 1;
}
⚡

Compile-Time Constants

Use con for compile-time constants - no stack allocation.

con LIMIT: int64 := 5;
con MSG: pchar := "Loop\n";

fn main(): int64 {
  while (i < LIMIT) { ... }
}
🎲

QBool - Probabilistic Boolean

Quantum-like boolean type (0.0 to 1.0 probability).

import std.qbool;

var is_rainy: QBool := Maybe(0.7);
var will_stay_home: QBool := QBoolAnd(is_rainy, is_cold);
var decision: bool := Observe(will_stay_home);
🗺️

Maps & Sets

Associative arrays for key-value storage.

var scores: Map<int64, int64> := {1: 100, 2: 200};
scores[3] := 300;
if (1 in scores) { ... }

var ids: Set<int64> := {10, 20, 30};
🔄

Virtual Methods & VMT

OOP with polymorphism via Virtual Method Tables.

type Animal = class {
  virtual fn speak();
};

type Dog = class extends Animal {
  override fn speak() { ... }
};
📝

std.log - Logging

Built-in logging with levels: DEBUG, INFO, WARN, ERROR.

import std.log;

log_info("Starting app...");
log_warn("Low memory");
log_error("Connection failed");
🖥️

std.os - System Functions

OS-level access: process, environment, time, filesystem.

import std.os;

var pid: int64 := get_pid();
var home: pchar := env_get("HOME");
var t: int64 := time_ms();
sleep(100);
🔧

30+ Builtins

No imports needed for common operations.

PrintStr, PrintInt, PrintFloat
Random, RandomSeed
push, pop, len, free
abs, sqrt, sin, cos
StrLength, str_to_int

Arquitectura del Compilador

Del código fuente al ejecutable nativo en 8 etapas

Source (.lyx)
→
Lexer → Token-Stream
↓
Parser → AST
↓
Sema → Scopes, Types
↓
IR Lowering → 3-Address-Code
↓
IR Optimizer → CSE, DCE, Copy Prop
↓
Inlining → Function Inlining
↓
Backend → Machine Code
↓
Linux x86_64
Linux ARM64
Windows x64
macOS x86_64
macOS ARM64
ESP32
↓
Executable (no libc)
ELF64
Linux x86_64/ARM64
PE32+
Windows x64
Mach-O
macOS x86_64/ARM64
ELF32
ESP32
IR Optimizer
CSE, DCE, Copy Prop
Inlining
Function Inlining

Energy-Aware Optimization

Lyx optimizes for energy efficiency with configurable energy levels and per-function pragmas

CLI Option

--target-energy=<1-5>
1 = Minimal (battery-optimized)
2 = Low
3 = Medium (balanced, default)
4 = High
5 = Extreme (max performance)

Function Pragma

@energy(1)
fn low_power_task() { ... }

@energy(5)
fn hot_path() { ... }
Override energy level per function for mixed workloads

What gets optimized?

Loop Unrolling
1× to 8× based on level
SIMD Usage
Level 3+ enables SIMD
FPU Operations
Level 4+ enables FPU
AVX2/512
Level 5 + CPU support

Visualizador de Datos In-Situ

Inspecciona cualquier variable en tiempo de ejecución sin configuración. Salida directa a stderr.

Demo de Inspect()

Coloca Inspect() en cualquier parte de tu código para depuración instantánea.

debug.lyx 
fn main(): int64 {
    var count: int64 := 42;
    var isActive: bool := true;
    var message: pchar := "Hello, Debug!";
    
    // Inspect any variable at runtime
    Inspect(count);      // Outputs to stderr
    Inspect(isActive);
    Inspect(message);
    
    return 0;
}

Vista Previa de Salida

Así es como Inspect() muestra varios tipos:

=== count ===
Type: int64
Value: 42

=== isActive ===
Type: bool
Value: true

=== message ===
Type: pchar
Value: Hello, Debug!

Tipos Soportados

Inspect detecta y formatea automáticamente:

int64 int32 uint8 bool pchar f32 f64

Linter Integrado

10 reglas incorporadas te ayudan a escribir código más limpio y seguro desde el inicio.

Opciones CLI

# Activar linter (por defecto)
./lyxc program.lyx --lint
# Desactivar advertencias del linter
./lyxc program.lyx --no-lint
# Solo lintar, no compilar
./lyxc program.lyx --lint-only

Reglas de Linting

El linter integrado verifica tu código en busca de problemas comunes:

1 Unused Variables
2 Type Mismatches
3 Dead Code
4 Naming Conventions
5 Redundant Casts
6 Unsafe Operations
7 Shadowing
8 Missing Returns
9 Constant Comparisons
10 Inefficient Patterns

Optimizador IR-Level

Múltiples pasadas de optimización producen código más rápido y pequeño.

∑

Constant Folding

Evalúa expresiones constantes en tiempo de compilación.

x := 2 + 4 → x := 6
⊃

Eliminación de Subexpresiones Comunes

Elimina cálculos redundantes.

a := x + y
b := x + y
→ reuse
∅

Eliminación de Código Muerto

Elimina código inalcanzable y funciones no usadas.

if false { dead(); }
→ removed
→

Propagación de Copias

Reemplaza copias por uso directo de valores.

a := b
c := a
→ c := b
↓

Reducción de Fuerza

Reemplaza operaciones costosas por más baratas.

x * 2 → x << 1
x / 2 → x >> 1
◎

Optimizador Peephole

Optimizaciones locales: operaciones identidad, movimientos redundantes.

mov rax, rax
→ removed

Inlining de Funciones

Inlinia funciones pequeñas para reducir sobrecarga de llamadas.

fn add(a, b: int64): int64 {
return a + b;
}
// becomes:
inlined at call site

Resultado de Optimización

Código más pequeño = ejecución más rápida = menos energía

Biblioteca Estándar

Bibliotecas incorporadas completas — sin dependencias externas.

std.math
Mathematical functions
Abs64, Min64, Max64, Sqrt64, Clamp64, Sign64, Lerp64, Map64, Sin64, Cos64, Hypot64, IsEven, IsOdd, NextPowerOfTwo
std.io
I/O functions
print, PrintLn, PrintIntLn, ExitProc, Printf
std.string
String manipulation
StrLength, StrCharAt, StrFind, StrToLower, StrToUpper, StrConcat, StrReplace
std.env
Environment API
ArgCount, Arg, init
std.time
Date and time
Numerical calculations, timezone support
std.geo
Geolocation
Decimal Degrees, GeoPoint, Distance, BoundingBox
std.fs
Filesystem operations
open, read, write, close, file existence
std.crt
ANSI Terminal
Colors, cursor control
std.pack
Binary serialization
VarInt, int/float/string packing
std.regex
Regex matching
Full regex engine included
std.qbool
Probabilistic Boolean
QBool, Maybe(), Observe(), Entanglement
std.vector
2D Vector library
Vec2
std.list
Collections
StaticList8, StackInt64, QueueInt64, RingBufferVec2
std.rect
Rectangle utilities
Rect
std.color
RGBA Color utilities
Color manipulation

La simplicidad es la
forma más alta de perfección.

Característica v0.5.0

OOP — Completo

Clases con herencia, constructores, destructores. Asignación en heap con new/dispose. super para llamadas a clase base.

  • ✓ class extends para Herencia Simple
  • ✓ new ClassName(args) con constructor
  • ✓ dispose obj llama Destroy()
  • ✓ super.method() para clase base
type
Dog = class extends Animal {
breed: pchar;
fn Create(n, b: pchar) {
self.name := n;
self.breed := b;
}
fn speak() {
PrintStr("Woof!\n");
}
};

Compilación Cruzada

Linux x86_64, Linux ARM64 y Windows x64 desde una base de código. Un compilador, tres plataformas.

Sistema de Módulos

Import/Export completo con Biblioteca Estándar.