Bux Programming Language

Status: Bootstrap compiler (buxc, Nim) compiles .bux → C → native binary.
Self-hosted compiler (buxc2) exists as a proof-of-concept but is deprioritized in favor of language features and stdlib maturity.

Bux is a fast, compiled, strongly-typed systems programming language. Features a C backend for native code generation, raw multi-line strings, gradual ownership, async/await, generics, algebraic enums, and a package manager.

---

Quick Start

# Build the bootstrap compiler (Nim)
make build

# Create a new project
bux new hello
cd hello

# Build and run
bux run

---

Syntax Preview

Hello World

import Std::Io::PrintLine;

func Main() -> int {
    PrintLine("Hello, Bux!");
    return 0;
}

Raw Multi-line Strings

// Backtick strings: no escape processing, multi-line
func Main() -> int {
    PrintLine(`Hello \n World`);     // prints: Hello \n World (literal)
    PrintLine(`Line 1
Line 2
Line 3`);                            // multi-line, newlines preserved
    return 0;
}

Error Handling with ?

enum Result {
    Ok(int),
    Err(String)
}

func Divide(a: int, b: int) -> Result {
    if b == 0 {
        return Result_NewErr("division by zero");
    }
    return Result_NewOk(a / b);
}

func Compute() -> Result {
    let x: int = Divide(10, 2)?;  // auto-propagates Err
    let y: int = Divide(x, 5)?;
    return Result_NewOk(y);
}

Structs and Methods

struct Rectangle {
    width: int;
    height: int;
}

extend Rectangle {
    func Area(self: Rectangle) -> int {
        return self.width * self.height;
    }
}

func Main() -> int {
    let rect: Rectangle = Rectangle { width: 10, height: 5 };
    PrintInt(rect.Area());
    return 0;
}

Generics

func Max<T>(a: T, b: T) -> T {
    if a > b {
        return a;
    }
    return b;
}

func Main() -> int {
    let m: int = Max<int>(10, 20);
    PrintInt(m);
    return 0;
}

Async/Await

import Std::Io::{PrintLine, PrintInt};

async func Compute() -> int {
    PrintLine("Compute: step 1");
    bux_async_yield();
    PrintLine("Compute: step 2");
    return 42;
}

func Main() -> int {
    let h1 = spawn Compute();
    let r1: int = h1.await as int;
    PrintInt(r1);
    return 0;
}

Channels (Producer/Consumer)

import Std::Io::{PrintLine, PrintInt};
import Std::Task::{Task_Join, TaskHandle};
import Std::Channel::{Channel, Channel_New, Channel_SendInt, Channel_RecvInt, Channel_Close};

func Producer(chPtr: *Channel<int>) {
    var i: int = 1;
    while i <= 5 {
        Channel_SendInt(chPtr, i * 10);
        i = i + 1;
    }
    Channel_Close<int>(chPtr);
}

func Consumer(chPtr: *Channel<int>) {
    var total: int = 0;
    while true {
        let val: int = Channel_RecvInt(chPtr);
        if val == 0 { break; }
        total = total + val;
        PrintInt(val);
        PrintLine("");
    }
    PrintLine("Total:");
    PrintInt(total);
    PrintLine("");
}

func Main() -> int {
    let ch: Channel<int> = Channel_New<int>(3);
    let p: *void = spawn Producer(&ch);
    let c: *void = spawn Consumer(&ch);
    Task_Join(TaskHandle { handle: p });
    Task_Join(TaskHandle { handle: c });
    return 0;
}

Hash Map

import Std::Map::{Map, Map_New, Map_Set, Map_Get};

func Main() -> int {
    let m: Map = Map_New(16);
    Map_Set(&m, "answer", 42);
    PrintInt(Map_Get(&m, "answer"));
    return 0;
}

---

Features

Feature	Status
Types	Primitives, pointers, slices, tuples, structs, enums, unions
Generics	Generic functions (monomorphization)
Algebraic Enums	Enums with data (Result, Option)
Pattern Matching	match with guards
Methods	extend blocks for struct methods
Interfaces	interface + extend for trait-like behavior
Error Handling	Result<T,E>, Option<T>, and the ? operator
Standard Library	Io, Array, String, Map, Fs, Mem, Set, Path, Math, Task, Channel, Sync, Os, Time, Process
Backend	C transpiler (self-hosting + bootstrap)
Strings	Raw multi-line backtick strings (...), C-string interop
Gradual Ownership	@[Checked] + &T/&mut T borrow checking
Async/Await	async func, spawn, .await with stackful coroutines
Concurrency	Task/Channel/Sync (pthread-based), bux_async_yield/spawn
CTFE	const func — compile-time function execution
Trait Bounds	func Max<T: Comparable>(a: T, b: T) -> T
Package Manager	bux add, bux install, bux.lock, path + git deps
Tooling	bux new, bux build, bux run, bux test, bux check

---

Project Structure

bux/
├── compiler/         # Compiler source code
│   ├── bootstrap/    # Bootstrap compiler (Nim)
│   ├── selfhost/     # Self-hosting compiler source (Bux)
│   └── tests/        # Compiler unit tests (Nim)
├── library/          # Standard library
│   ├── std/          # Standard library modules (.bux)
│   │   ├── Io.bux, String.bux, Array.bux, Map.bux
│   │   ├── Fs.bux, Mem.bux, Set.bux
│   │   ├── Path.bux, Math.bux
│   │   └── Task.bux, Channel.bux
│   └── runtime/      # C runtime files (runtime.c, io.c)
├── tests/            # Language integration tests
├── examples/         # Example programs
├── tools/            # Additional tooling
├── docs/             # Documentation
├── buxs/             # Windows-compatible project root
├── README.md
├── PLAN.md           # Roadmap to self-hosting
└── Makefile

---

Build & Test

# Build bootstrap compiler (Nim → C)
make build

# Build self-hosted compiler (Bux → C → native)
make selfhost

# Run all tests
make test

# Run example programs
make test-examples

# Clean build artifacts
make clean

Windows users: Use the buxs/ directory as your project root to avoid path conflicts.

---

Documentation

• docs/LanguageRef.md — Language reference
• docs/Stdlib.md — Standard library documentation
• docs/BuildAndTest.md — Build and test guide
• PLAN.md — Roadmap to self-hosting

---

License

MIT