Loxel - A Modern Programming Language

At a glance

Language Features

Expression-Oriented

Everything is an expression. if, match, try, and blocks all return values.

Optional Static Typing

TypeScript-style annotations with full inference. Union, intersection, nullable, and generic types.

Multilingual Keywords

Write in English, Spanish, French, German, Portuguese, Japanese, or Chinese.

Rich Operators

Pipeline |>, Elvis ?:, nullish ??, optional chaining ?., ranges, and more.

Async / Await

First-class concurrency with threads, channels, and async I/O powered by Boost.ASIO.

Pattern Matching

Powerful match expressions with guards, ranges, destructuring, and exhaustive checking.

AI Training & Inference

A pure-Loxel deep-learning stack — no PyTorch. QLoRA fine-tuning on a 4-bit base plus fused-kernel KV-cache generation, proven on SmolLM2-360M.

Explore Full Language Reference →

Code Examples

See Loxel in Action

expressions.lox
// Everything is an expression that returns a value
let max = if (a > b) a else b;

let category = match (age) {
    case in 0..13 => "child",
    case in 13..18 => "teen",
    case _ => "adult"
};

let result = {
    let x = compute();
    let y = process(x);
    x + y  // last expression returned
};

// Ternary and null coalescing
let status = age >= 18 ? "adult" : "minor";
let name = user?.name ?? "Anonymous";

operators.lox
// Pipeline operator: compose left to right
let result = raw_input |> parse |> validate |> transform;

// Elvis operator: default if null
let name = user.name ?: "Anonymous";

// Nullish coalescing
let config = options.timeout ?? 5000;

// Optional chaining
let city = user?.address?.city;
let first = items?.[0];

// Ranges
for (i in 0..10) { print(i); }
let teens = people.filter(p => p.age in 13..20);

// Spread operator
let merged = [...defaults, ...overrides];
let copy = { ...original, status: "updated" };

// Ternary
let label = count == 1 ? "item" : "items";

types_and_pipelines.lox
// Stub definitions
class Request {
    def init(path: String, method: String) {
        self.path = path;
        self.method = method;
    }
}

class User {
    def init(id: Number, name: String) {
        self.id   = id;
        self.name = name;
    }
}

class Error {
    def init(message: String) {
        self.message = message;
    }
}

class Db {
    def get(id: Number): User? {
        return if (id > 0) User(id, "Alice") else nil;
    }
}

let db          = Db();
let raw_request = Request("/home", "GET");
let items       = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

def parse(req: Request): Request { return req; }
def validate(req: Request): Request { return req; }
def handle(req: Request): String { return "200 OK: " + req.path; }

// Optional static typing with inference
type Handler = (request: Request) => String;
let routes: Map<String, Handler> = {};

// Union types and nullable shorthand
def find(id: Number): User | Error {
    let user: User? = db.get(id);
    return user ?? Error("Not found");
}

// Pipeline operator for functional composition
let response = raw_request
    |> parse
    |> validate
    |> handle;

// Comprehensions
let squares = [x * x for x in 1..11];
let evens = items.filter((x) => x % 2 == 0);

// Output
print(`Pipeline: ${response}`);

print("Squares:");
for (s in squares) { print(s); }

print("Evens:");
for (e in evens) { print(e); }

let found    = find(1);
let notFound = find(-1);
print(`find(1):  ${found.name}`);
print(`find(-1): ${notFound.message}`);

concurrency.lox
namespace webserver;
import { parse } from "./http/request";
import { handle } from "./http/router";

// Worker threads pull from a bounded channel
def worker_loop(queue, id: Number): Nil {
    while (true) {
        let client = Channel.receive(queue);
        if (client == nil) { return; }

        let response = TcpSocket.receive_sync(client, 8192)
            |> parse
            |> handle;

        TcpSocket.send_sync(client, response);
        TcpSocket.close(client);
    }
}

// Spawn a pool of workers
def create_pool(queue, count: Number): Array {
    return [Thread.spawn(() => worker_loop(queue, i))
            for i in 0..count];
}

// Main: async accept loop distributes to workers
async def main(): Nil {
    let queue = Channel(100);
    let workers = create_pool(queue, 4);
    let server = TcpServer(8080);

    while (true) {
        let client = await TcpServer.accept(server);
        Channel.send(queue, client);
    }
}

classes.lox
// Classes with self, interfaces, and generics
class Stack<T> {
    def init(let items: Array<T> = []) {
        // self.items auto-assigned via property promotion
    }

    def push(item: T): Nil {
        self.items.push(item);
    }

    def pop(): T? {
        return if (self.items.length() == 0) nil
               else self.items.pop();
    }

    def peek(): T? {
        return self.items[self.items.length() - 1];
    }

    def size(): Number {
        return self.items.length();
    }
}

// Functional style with arrow functions
let numbers = [-3, -1, 0, 2, 4, 6];
let doubled = numbers
    .filter((n) => n > 0)
    .map((n) => n * 2)
    .reduce((acc, n) => acc + n, 0);

print(`Sum of 2x the Positive values: ${doubled}`);

const OnlyPositiveValues = (values) => values.filter((n) => n > 0);
const DoubleValues = (values) => values.map((n) => n * 2);
const Accumulate = (values) => values.reduce((acc, n) => acc + n, 0);

let pipeDerived = numbers |> OnlyPositiveValues |> DoubleValues |> Accumulate;
print(`Pipe derived summation: ${pipeDerived}`);

event_hooks.lox
// Event hooks intercept lifecycle events for AOP / metaprogramming

class BankAccount {
    def init(owner: String, balance: Number) {
        self.owner = owner;
        self.balance = balance;
    }

    // Fires before any method call on this object
    @onCall
    def audit(method_name, args) {
        print("[audit] " + self.owner + " -> " + method_name);
    }

    // Fires whenever a property is written
    @onPropertySet
    def validate(prop, value) {
        if (prop == "balance" && value < 0) {
            throw Error("Balance cannot go negative");
        }
    }

    // Fires once, right after init() completes
    @onInstantiate
    def setup() {
        self.tx_count = 0;
    }

    def deposit(amount: Number): Number {
        self.tx_count = self.tx_count + 1;
        self.balance = self.balance + amount;
        return self.balance;
    }
}

let acct = BankAccount("Alice", 100);
acct.deposit(50);  // prints: [audit] Alice -> deposit
                   // balance becomes 150
print(`Balance: ${acct.balance}`);

i18n_and_emoji.lox
// Loxel keywords work in 7 languages
// English
def greet(name: String) => `Hello, ${name}`;

// Spanish
funcion saludar(nombre: Cadena) => `Hola, ${nombre}`;

// Chinese Simplified
函数 问候(名字: 字符串) => `你好, ${名字}`;

// All three produce the same result
let greeting = greet("world");
let resultado = saludar("mundo");
let 消息 = 问候("世界");

// Emoji identifiers are valid too 🚀 💯 ✨
let 🚀launch = true;
let 💯score = 100;
let ✨sparkles = "amazing";

AI / Machine Learning

Train and Run Models in Pure Loxel

No PyTorch, no Python in the loop. A pure-Loxel stack — threaded f32 tensors with a fused 4-bit kernel (std::tensor), and real-model QLoRA fine-tuning plus Q4 KV-cache inference (std::llm) — proven end-to-end on SmolLM2-360M. Built for low-memory devices: the 4-bit base never leaves Q4 size in RAM, so the same pipeline targets phones.

qlora_finetune.lox
import { load_pretrained_q4, create_adapters, freeze, lora_parameters,
         lora_train_step, save_adapter, generate_cached } from "std::llm";
import { AdamW } from "std::autograd";

// Load a real GGUF model, quantized to 4-bit on load, and freeze the base
let model = load_pretrained_q4("SmolLM2-360M.gguf");
freeze(model);

// Train small LoRA adapters on top (QLoRA): only these update
let set = create_adapters(model, 8, 16, ["attn_q", "attn_v"]);  // rank 8, alpha 16
let opt = AdamW(lora_parameters(set), 1e-3);

for (step in 0..steps) {
    let loss = lora_train_step(model, set, opt, X[step], Y[step], lr);
}
save_adapter(set, "loxel_adapter.gguf");   // ~MB per-user artifact

// Generate with a Q4 KV-cache decoder (temperature + top-k). dense=nil -> low-memory fused path.
let out = generate_cached(model, prompt_ids, set, 64, 0.8, 40, eos_id, nil);

Internationalization

Write Code in Your Language

Loxel supports multilingual keywords and type names.

English

def class String

Español

funcion clase Cadena

Français

fonction classe Chaîne

Deutsch

funktion klasse Zeichenkette

Português

funcao classe Cadeia

日本語

関数 クラス 文字列

中文

函数 类 字符串

Live Server

This Page Is Served by Loxel

Workers

Queue Capacity

100

Request

GET /

Protocol

HTTP/1.1

/health /echo 📚 Documentation