Rubix Programming Language (.ix)

   ██████╗ ██╗   ██╗██████╗ ██╗██╗  ██╗
   ██╔══██╗██║   ██║██╔══██╗██║╚██╗██╔╝
   ██████╔╝██║   ██║██████╔╝██║ ╚███╔╝ 
   ██╔══██╗██║   ██║██╔══██╗██║ ██╔██╗ 
   ██║  ██║╚██████╔╝██████╔╝██║██╔╝ ██╗
   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚═╝╚═╝  ╚═╝

struct Point {
    x: int,
    y: int
}

fn hypot_squared(p: Point): int {
    return p.x * p.x + p.y * p.y;
}

fn main() {
    print_str("Hello from Rubix!\n");

    let pt = Point { x: 3, y: 4 };
    let dist = hypot_squared(pt);
    print(dist); // Prints: 25

    let pi: float = 3.141592;
    print(pi * 2.0); // Native SSE2 float math

    return 0;
}

                       +-----------------------------------+
                       |    Rubix Source Code (.ix)        |
                       +-----------------------------------+
                                         │
                                         ▼
+---------------------------------------------------------------------------------+
|                                 rubix_compiler                                  |
|                                                                                 |
|  [Lexer (src/lexer.s)]                                                          |
|    • Tokenizer converting source buffers into structured 32-byte token records  |
|                                         │                                       |
|                                         ▼                                       |
|  [Parser (src/parser.s)]                                                        |
|    • Recursive descent parser with Pratt-style operator precedence              |
|    • Handles scopes, statements, expressions, control flow, loops & imports     |
|                                         │                                       |
|                                         ▼                                       |
|  [Symbol Table (src/symtab.s)]                                                  |
|    • Lexical block scoping (up to 64 depth) and stack offset calculation       |
|    • Variable redeclaration guards and symbol lookup                            |
|                                         │                                       |
|                                         ▼                                       |
|  [Code Generator (src/codegen.s)]                                               |
|    • Emits native x86-64 GNU assembly (.intel_syntax noprefix)                  |
|    • Generates .rodata string literals & links embedded assembly runtime        |
+---------------------------------------------------------------------------------+
                                         │
                                         ▼
                       +-----------------------------------+
                       |      x86-64 Assembly (.s)         |
                       +-----------------------------------+
                                         │  (as + ld)
                                         ▼
                       +-----------------------------------+
                       |    Universal Native Executable    |
                       |  (Direct Syscalls / No C / No VM) |
                       +-----------------------------------+
                                         │
                 ┌───────────────────────┼───────────────────────┐
                 ▼                       ▼                       ▼
           [Host: Linux]          [Host: Windows]          [Host: macOS]
           Direct Linux           Dynamic kernel32        Direct Darwin
             Syscalls            PEB Export Resolver         Syscalls

project 2.0/
├── Makefile              # Compiler build automation
├── rubixc                # User-friendly compiler & runner script
├── test.sh               # Complete 14-test verification suite
├── src/                  # 100% Pure x86-64 Assembly Source Code
│   ├── main.s            # Entry point (_start), command line parser, file pipeline
│   ├── constants.s       # Linux syscall numbers, token types, buffer capacity limits
│   ├── strings.s         # String length, compare, copy, and integer conversion routines
│   ├── io.s              # Raw kernel file I/O & Rust-style diagnostic error reporting
│   ├── lexer.s           # Tokenizer & scanner (keywords, identifiers, literals, operators)
│   ├── symtab.s          # Lexical scope stack, symbol table buffer, and stack offsets
│   ├── codegen.s         # Instruction emitters, rodata manager, and standard library runtime
│   └── parser.s          # Recursive-descent parser, operator precedence, and loop frames
└── examples/             # Test & Demonstration Programs
    ├── 01_hello.ix       # Hello World string literal output
    ├── 02_arithmetic.ix  # Expressions, operator precedence, and variables
    ├── 03_control_flow.ix# While loops, if-else chains, and reassignments
    ├── 04_functions.ix   # Multi-parameter functions and recursive Fibonacci
    ├── 05_prime_numbers.ix# Prime number sieve demonstrating nested logic
    ├── 06_arrays.ix      # Dynamic heap allocation, indexing, and array literals
    ├── 07_types_and_logic.ix # Booleans, chars, logical operators (&&, ||, !), optional types
    ├── 08_many_params.ix # Unbounded 8-parameter function caller/callee stack passing
    ├── 09_modules.ix     # Multi-file module import system
    ├── 10_safe_math.ix   # Hardware integer overflow detection trap
    ├── 11_for_loops.ix   # Complete for loops (break, continue, nesting, dynamic arrays)
    ├── 12_stdlib.ix      # Embedded stdlib (File I/O, string manipulation, math routines)
    ├── large_system_test.ix # 200-element Quicksort, 4x4 matrix multiplication, and multi-file math
    └── comprehensive_large_test.ix # Grand stress test: 1,000-element Sieve, binary search, prefix sums

let count = 10;                # Inferred 64-bit int
let flag: bool = true;         # Explicit bool
let symbol: char = 'R';        # Character literal

let x = (10 + 5) * 2 - 4 / 2;  # Precedence respected
let valid = (x > 10) && (!flag || x < 100);

for (let i = 0; i < 20; i = i + 1) {
    if (i >= 15) {
        break;      # Exits loop early
    }
    if (i % 2 == 0) {
        continue;   # Skips to step clause (i = i + 1)
    }
    print(i);       # Prints 1, 3, 5, 7, 9, 11, 13
}

# Dynamic array allocation
let size = 100;
let arr = alloc(size * 8);

for (let i = 0; i < size; i = i + 1) {
    arr[i] = i * i;
}
print(arr[9]);      # Prints 81
free(arr, size * 8);

# Array literal initialization
let primes = [2, 3, 5, 7, 11, 13, 17];
print(primes[4]);   # Prints 11

fn compute_sum(a: int, b: int, c: int, d: int, e: int, f: int, g: int, h: int): int {
    return a + b + c + d + e + f + g + h;
}

fn main(): int {
    let sum = compute_sum(1, 2, 3, 4, 5, 6, 7, 8);
    print(sum);      # Prints 36
    return 0;
}

import "examples/math_lib.ix";

fn main(): int {
    let result = compute_cube(5);
    print(result);   # Prints 125
    return 0;
}

let pi: float = 3.141592;
let rad = 2.5;

// Native SSE2 arithmetic (+, -, *, /) and mixed int-float operations
let area = pi * rad * rad;
print(area); // 19.634950 (automatically dispatches to float formatting)

// Typed function parameters and return types
fn hypot(a: float, b: float): float {
    return a * a + b * b;
}

struct Vector3 {
    x: int,
    y: int,
    z: int
}

fn main() {
    let v = Vector3 { x: 10, y: 20, z: 30 };
    print(v.x);
    v.z = v.x + v.y;
    print(v.z); // 30
    free(v, 24);
    return 0;
}

Rubix Compiler Error: Expected expression
  --> line 4
   |
 4 |     let x = ;
   | ^