RISK

Introduction to Risk

Risk is a systems-level programming language with a static type system, explicit memory management, and a rather convenient set of built-in functions (I hope it is). It suits domains where predictable performance, precise resource control, and low-level memory access are important constraints.

Risk source files use the .risk extension (Yeah, kinda lazy when it comes to finding names, you will soon understand why). I designed the language so that every variable's type is known at compile time and every allocation is visible in the source code, meaning there is no hidden garbage collector and implicit boxing. :) At the same time, Risk comes with a "rather convenient" (again) standard library covering I/O, string manipulation, file access, math, randomness, and timing.

Primitive Types

Risk's type system has a set of well-defined platform-independent width primitive types covering integers, floats, booleans, characters, strings, and raw memory primitives.

Integer Types

Risk provides signed and unsigned integers in 8, 16, 32, and 64-bit widths. The default integer type is i32. Unsigned variants are available at all widths and are named with a u prefix. Integer literals can be written in decimal, hexadecimal (0x prefix), or binary (0b prefix).

// Variable declarations with explicit integer types
a: i32 = -42;
b: u8  = 255;
c: i64 = 9259034215553;
d: u32 = 0xFF;     // hexadecimal literal
e: u8  = 0b011;    // binary literal

Floating-Point Types

Risk supports IEEE 754 single-precision (f32) and double-precision (f64) floating-point numbers. The default float type is f64. The special values INF and NAN are recognized as built-in literals for positive infinity and not-a-number respectively.

pi:  f64 = 3.141592;
e:   f32 = 2.7;
inf: f32 = INF;     // positive infinity
nan: f64 = NAN;     // not-a-number

Boolean

The bool type holds exactly two values: true or false. Boolean expressions can be formed using the comparison and logical operators and are the condition type required by all control flow constructs.

t:      bool = true;
f:      bool = false;
result: bool = (10 > 5) && !f;  // true

Character

The char type holds a single Unicode scalar value and is always 4 bytes wide, allowing the full Unicode range to be represented without multi-char sequences. Character literals are enclosed in single quotes. Standard escape sequences such as '\n', '\t', and '\\' are supported.

c:       char = 'A';
dollar:  char = '$';
newline: char = '\n';

String

The string type represents a sequence of characters enclosed in double quotes. Strings in Risk are owned values — they carry their own storage and do not require the programmer to manage a separate buffer manually for typical use.

s: string = "Hello World!";

Pointers

Pointers in Risk are declared with the ptr<T> generic syntax. They hold the raw memory address of a value of type T. The address-of operator & takes the address of a variable, and the dereference operator * reads or writes through the pointer.

Constness can be applied to either the pointer itself, the data it points to, or both, following a straightforward read-right-to-left rule:

• ptr<T> — mutable pointer to mutable data
• ptr<const T> — mutable pointer to immutable data (cannot write through)
• const ptr<T> — immutable pointer (cannot be reseated) to mutable data
• const ptr<const T> — fully immutable: neither the pointer nor the data may change

x:          i32            = 42;
ptrX:       ptr<i32>       = &x;
*ptrX = 5; // dereference and write

y:          const i32       = 14;
ptrY:       ptr<const i32> = &y;
// *ptrY = 10;  WRONG — cannot write through a pointer-to-const

constPtrX:  const ptr<i32>       = &x;
// constPtrX can modify what it points to, but cannot be reseated

constPtrY:  const ptr<const i32> = &y;
// fully immutable — neither pointer nor data may change

References

References, declared with ref<T>, are non-nullable aliases to an existing variable. Unlike pointers, a reference cannot be declared without immediately binding it to a referend, and it cannot hold a null value. Reading a reference yields the referred value directly; writing through a reference modifies the original variable.

a:    i8        = 5;
// refA: ref<i8>;        WRONG — references must be immediately bound
// refA: ref<i8> = null; WRONG — references cannot be null

refA: ref<i8> = a;
println(refA); // prints 5 — the actual value of a
refA = 77;     // writes through reference; a is now 77

Compound Types

Arrays

Risk provides two distinct array kinds: a compile-time-fixed static array and a heap-allocated dynamic array. Both use the Array<T> syntax, differentiated by whether a size argument is supplied.

Static Array — Array<T, N>

A static array has a fixed element count N that must be known at compile time. The array's memory is sized exactly to hold N elements of type T and cannot grow or shrink at runtime. Push and pop operations are not available. Accessing an out-of-bounds index is a compile-time or runtime error.

// arr: Array<i32, 5> = [];  WRONG — static arrays must be fully initialized
arr: Array<i32, 5> = [1, 2, 3, 4, 5];
// arr.push(6);              WRONG — no push on static arrays

len:  i32 = length(arr); // 5
arr[0] = 5;               // index-based write
// println(arr[5]);          WRONG — out-of-bounds access

Dynamic Array — Array<T>

A dynamic array is a heap-allocated, growable contiguous buffer. It starts empty and can be extended or reduced at runtime through a set of methods. Elements are accessed by index the same way as static arrays.

v: Array<i32> = [];

v.push(6);
v.push(1); v.push(2); v.push(3);
v.push_front(0);     // inserts 0 at the front
v.insert(2, 12);    // inserts 12 at index 2
v.pop();            // removes last element
v.pop_front();      // removes first element
v.remove_at(2);    // removes element at index 2

len: i32 = length(v);
println(v[0]);

HashMap — Hashmap<Ta, Tb>

A Hashmap<Ta, Tb> maps keys of type Ta to values of type Tb using a hash table. It is declared with an empty brace literal {} and entries are read and written using bracket-index syntax identical to array access.

score: Hashmap<string, i32> = {};
score["alice"] = 100;
println(score["alice"]); // 100

Control Flow

Block Expressions

Any pair of braces { } introduces a new scope in Risk. Variables declared inside a block are destroyed when the block exits. Blocks can appear anywhere a statement is valid — including as the bodies of functions, loops, and branches, or as standalone scope delimiters for lifetime management.

func main() -> i32 {
    // outer scope
    {
        // inner scope — variables here do not leak out
    }
    return 0;
}

If/ else if /else

Conditional branching uses the familiar if / else if / else chain. The condition is a boolean expression enclosed in parentheses. Each branch body is wrapped in braces. Multiple else if clauses can be chained before an optional else fallthrough.

x: i32 = 16;
if(x > 0) {
    println("positive");
} else if(x < 0) {
    println("negative");
} else {
    println("zero");
}

Switch Statement

The switch statement dispatches on an integer or comparable value. Each case label is followed by a braced body. A break at the end of each case prevents fall-through to the next. A default case catches all values not matched by an explicit label.

switch(val) {
    case 1 { println(1); break; }
    case 2 { println(2); break; }
    case 3 { println(3); break; }
    default { println("unhandled"); }
}

For Loop

The for loop uses a C-style three-clause header: initializer, condition, and post-iteration expression. The loop variable is scoped to the loop body. break exits the loop immediately; continue skips to the next iteration.

for(i: i32 = 0; i < 5; i++) {
    if (i == 4) break;     // exits loop
    if (i == 2) continue;  // skips iteration
    println(i);
}

While Loop

The while loop evaluates a boolean condition before each iteration and repeats the body for as long as it holds true.

while(i < 10) {
    // body
}

Functions

Declaration & Definition

In Risk, functions are declared and defined in a single step using the func keyword. There is no separate forward-declaration or prototype step. The return type follows a -> arrow after the parameter list. Functions with no meaningful return value use void.

// SYNTAX: func name(param: Type, ...) -> ReturnType { body }

func add(a: i32, b: i32) -> i32 {
    return a + b;
}

res: i32 = add(5, 2); // 7

Function Pointers

A function pointer stores the address of a function with a specific signature and can be called indirectly through the pointer variable. The type of a function pointer is written as func(ParamTypes...) -> ReturnType. Function pointers can be passed as arguments to other functions, enabling higher-order patterns without closures.

func times2(x: i32) -> i32 {
    return x * 2;
}

func applyFn(f: func(i32) -> i32, v: i32) -> i32 {
    return f(v);
}

fp: func(i32) -> i32 = times2;

println(fp(5));              // 10
println(applyFn(times2, 5)); // 10

Type Aliases

The typealias keyword creates a named synonym for any type, including function pointer types. Aliases are interchangeable with the types they alias and are particularly useful for giving long function-pointer signatures readable names.

typealias CallbackI8ToStr = func(i8) -> string;

x: CallbackI8ToStr = someValidFunc; // cleaner than the full signature

typealias str = string;

y: str;     // valid
z: string; // also valid — aliases are purely syntactic

Lambda / Closure Functions

Risk supports anonymous function literals (lambdas). A lambda is defined inline with a capture clause ((...) for capturing the environment) followed by a parameter list in brackets and a braced body. Lambdas can be stored in function-pointer variables and called by name.

// No-parameter lambda
greet: func() -> void = (...)[]{
    println("Hello World!!!");
};
greet();

// Lambda with parameters
add: func(i32, i32) -> i32 = (...)[a: i32, b: i32] {
    return a + b;
};
res: i32 = add(1, 2); // 3

Structures

Block Structures

In Risk, a block is a composite data type that groups a contiguous list of named fields, each of which can be a primitive, another block, or even a function pointer. Blocks are analogous to structs in C. Fields can have optional default values that are used when the field is not explicitly provided during initialization.

Block Declaration

/* SYNTAX:
   block Name {
       fieldName: Type;
       fieldName: Type = defaultValue;
   } */

block Person {
    name:        string;
    age:         i32;
    dateOfBirth: Date;             // nested block
    print:       func(p: Person) -> void; // function pointer field
    male:        bool;
    occupation:  string = "Student"; // default value
}

Field Assignment — Three Styles

Risk supports three distinct ways to initialize a block instance, suited to different use cases:

1. Manual field assignment — Declare the variable first, then set each field individually using dot notation. Fields with default values are already populated; only fields you care about need to be touched.

u1: User;
u1.age    = 30;
u1.name   = "Sponge bob";
u1.active = false;

2. Named field assignment — Initialize specific fields by name in a brace literal. Any field not mentioned keeps its declared default value. This is the most explicit and readable style when only a subset of fields differs from defaults.

u2: User = {name = "Bob"};            // age and active use defaults
u3: User = {age = 21, name = "Robot"}; // active uses default

3. Positional field assignment — Provide all field values in the exact order they were declared. This is the most compact style but requires knowing the declaration order precisely.

block User {
    age:    i32    = 18;
    name:   string;
    active: bool   = true;
}

u4: User = {21, "Root", false}; // VALID — matches declaration order
// u4: User = {21, false, "Root"}; // BAD — wrong order

Opts (Enumerations)

An opts declaration defines a named set of mutually exclusive symbolic constants, each backed by an integer value. The name "opts" reflects their purpose: they describe the available options that a variable of that type can take — a more intuitive framing than the traditional "enumeration". Each variant is referenced by the type name followed by a dot, yielding the underlying integer value. This makes opts suitable for state machines, status codes, direction flags, and anywhere a value must belong to a closed, well-named set.

Variant values can be assigned explicitly. If a variant has no explicit value, it automatically takes the value of the previous variant plus one, beginning from the last explicitly set value. This allows sparse or semantically grouped numbering without listing every value manually.

// Basic opts with explicit values
opts Color {
    Red    = 0,
    Green  = 1,
    Blue   = 2,
    Yellow = 3
}

// Semantically grouped status codes
opts Status {
    Pending    = 100,
    InProgress = 200,
    Completed  = 300,
    Failed     = 400
}

// Auto-increment: East=1, South=2, West=3
opts Direction {
    North = 0,
    East,
    South,
    West
}

// Usage — opts resolve to their underlying integer
c: i32 = Color.Red;  // 0
println(c);

Operators

Arithmetic

Increment / Decrement

Both prefix and postfix forms of ++ and -- are supported. The postfix form returns the value before modification; the prefix form modifies the variable first and returns the new value.

x: i32 = 10;
println(x++); // prints 10, x becomes 11
println(++x); // x becomes 12, prints 12
println(x--); // prints 12, x becomes 11
println(--x); // x becomes 10, prints 10

Comparison

Logical

Logical operators act on bool values and produce a bool result. && and || are short-circuit evaluating — the right operand is only evaluated if needed.

A: bool = true;
B: bool = false;

A && B  // AND  → false
A || B  // OR   → true
!A      // NOT  → false

Bitwise

Compound bitwise-assignment operators are supported: &=, |=, ^=, <<=, >>=.

a: u8 = 0b11001010; // 202
b: u8 = 0b10100101; // 165

a &= b; // bitwise AND-assign
a |= b; // bitwise OR-assign
a ^= b; // bitwise XOR-assign

Casting

Safe Cast — as T and cast<T>

The as keyword and the cast<T> function both perform explicit, well-defined numeric conversions. If the value being cast does not fit in the target type, truncation occurs — the operation completes without a runtime panic or exception. This makes the programmer explicitly responsible for ensuring values are in range.

x: i64 = 1000;
y: i32 = x as i32;       // safe cast — truncates if value overflows
z: f64 = cast<f64>(x);   // integer to float

Unsafe Cast — unsafe_cast<T>

unsafe_cast<T> reinterprets the raw bit pattern of a value as a completely different type without any conversion arithmetic. The bit width of source and target must match. This is the equivalent of C's type-punning via a union and bypasses all type safety guarantees. It is intended for low-level work such as inspecting the IEEE 754 representation of a float, or interfacing with hardware registers.

x: char = 'A';
b: i32  = unsafe_cast<i32>(x);
println(b); // prints 65 (ASCII value of 'A')

The register Keyword

Memory-mapped I/O registers are declared by specifying the hardware address in parentheses after the type. This binds the variable name directly to that physical address, so any read or write to the variable goes straight to the hardware peripheral — no indirection required. Bitwise operators are the standard way to manipulate individual bits within a register.

// SYNTAX: name: register<T>(address) = value;

PORTA: register<u8>(0x05);
PORTA |= (1 << 0x5); // set bit 5 of PORTA

Modules & Imports

Risk has a straightforward module system: one file, one module. If you've written some code in another .risk file, you pull it in with import. No package manifests, no magic resolution — just a path.

Basic Import

To import another file, use import followed by the file path in double quotes. All public symbols from that file become available in the current scope, qualified by the file's base name.

import "file.risk";     // import a local file
import "utils/math.risk"; // subdirectories work too

Aliased Import

You can bind an import to a shorter alias using as. After that, every symbol from that file is accessed through the alias. This keeps call sites clean and avoids name collisions when pulling in multiple files.

import "file.risk" as f;

f.functionA();          // call functionA from file.risk
x: i32 = f.compute(10); // use any exported symbol through the alias

Standard Library Imports

The built-in standard library functions (I/O, math, strings, etc.) are available without any import — they're just there. However, Risk will eventually support installable standard library packages using the @ prefix syntax, for example:

import @"tui/tui.risk";            // future: named standard library package
import @"tui/tui.risk" as tui;    // aliased, so you call tui.draw(...) etc.

Summary

Built-in Functions & Standard Library

Risk ships a standard library of built-in functions organized into functional groups. All built-ins are available without any import statement.

I/O

Type Conversion

General

Math

Strings — str_*

All string functions return new strings and do not modify the original.

File I/O — fio_*

Random — rand_*

Time — time_*

Array Methods

Dynamic arrays expose their operations as method-style calls on the array variable. There is no array_new function — allocate by declaring with an empty literal [] and push elements in, or declare with a literal list.

board: Array<i32> = [];
i: i32 = 0;
while (i < W * H) { board.push(0); i = i + 1; }

Additional String Functions

These functions exist in the runtime but were missing from the main strings table.

TUI & Keyboard

Functions for building full-screen terminal applications. Raw mode disables line-buffering and echo so your program receives keystrokes immediately and characters never appear on screen behind your UI. Always call tui_raw_mode_leave() before exiting, even on error, or the terminal will be left in a broken state.

Terminal Control

Keyboard Input

Key Code Table

Special key constants returned by kb_read_key():

System — sys_*

Runtime information about the host environment. All functions take no arguments except sys_env.

Memory

Low-level memory operations. These are for advanced use — most programs do not need them.

Type Cheat Sheet

Operator Precedence

Higher level numbers bind more loosely. When in doubt, use parentheses.

Examples

A collection of complete, runnable Risk programs — from a terminal UI to file utilities. Each example is self-contained and can be compiled with riskc file.risk.

TUI Explorer

A keyboard-driven terminal browser over a list of famous figures. Navigate with k/j, press Enter to read a bio, any key to go back, q to quit.

func render_browser(names: Array<string>, selected: i32, e: string) -> void {
    clrscr();
    println(e, "[1;36m", "  Figures of History", e, "[0m");
    println(e, "[2m",    "  Select a person",     e, "[0m");
    println("  ──────────────────────────────────");

    i: i32 = 0;
    n: i32 = length(names);
    while (i < n) {
        if (i == selected) {
            println(e, "[7m", "  > ", names[i], e, "[0m");
        } else {
            println("    ", names[i]);
        }
        i = i + 1;
    }
    println("");
    println(e, "[2m", "  k/j navigate   Enter open   q quit", e, "[0m");
    flush_stdout();
}

func render_viewer(name: string, bio: string, e: string) -> void {
    clrscr();
    println(e, "[1;36m", "  ", name, e, "[0m");
    println("  ──────────────────────────────────");
    println("");
    println("  ", bio);
    println("");
    println(e, "[2m", "  any key to go back...", e, "[0m");
    flush_stdout();
}

func main() -> i32 {
    names: Array<string> = [
        "Albert Einstein",
        "Alan Turing",
        "Nikola Tesla",
        "Linus Torvalds",
        "Neil deGrasse Tyson"
    ];

    bios: Array<string> = [
        "Theoretical physicist. Reshaped our understanding of space, time, and gravity.",
        "Mathematician and father of computer science. Cracked Enigma, defined computation.",
        "Inventor and electrical engineer. Gave the world alternating current.",
        "Creator of Linux. Believes in open source, version control, and strong opinions.",
        "Astrophysicist and science communicator. Makes the cosmos feel personal."
    ];

    e:        string = chr(27);
    selected: i32    = 0;
    mode:     i32    = 0;
    viewed:   i32    = 0;

    tui_raw_mode_enter();
    print(e, "[?25l");
    flush_stdout();

    running: bool = true;
    while (running) {
        if (mode == 0) {
            render_browser(names, selected, e);
            key: i32 = kb_read_key();
            n:   i32 = length(names);

            if (key == 1000 || key == 107) {        // up / k
                if (selected > 0) { selected = selected - 1; }
            } else if (key == 1001 || key == 106) {  // down / j
                if (selected < n - 1) { selected = selected + 1; }
            } else if (key == 13) {                   // Enter
                viewed = selected;
                mode   = 1;
            } else if (key == 113 || key == 27) {   // q / Esc
                running = false;
            }
        } else {
            render_viewer(names[viewed], bios[viewed], e);
            kb_read_key();
            mode = 0;
        }
    }

    print(e, "[?25h");
    tui_raw_mode_leave();
    clrscr();
    return 0;
}

Hello World

The classic starting point — print a greeting and exit.

func main() -> i32 {
    println("Hello, World!");
    return 0;
}

Spice it up with a name argument read from the user:

func main() -> i32 {
    print("Enter your name: ");
    flush_stdout();
    name: string = input();
    println("Hello, ", name, "!");
    return 0;
}

Fibonacci

Compute and print the first n Fibonacci numbers iteratively, then also show a recursive version for contrast.

// Iterative — O(n) time, O(1) space
func fib_iter(n: i32) -> void {
    a: i64 = 0;
    b: i64 = 1;
    i: i32 = 0;
    while (i < n) {
        println(a);
        tmp: i64 = a + b;
        a = b;
        b = tmp;
        i = i + 1;
    }
}

// Recursive — clean but exponential; fine for small n
func fib(n: i32) -> i64 {
    if (n <= 1) { return n; }
    return fib(n - 1) + fib(n - 2);
}

func main() -> i32 {
    println("First 10 Fibonacci numbers:");
    fib_iter(10);

    println("");
    println("fib(20) = ", fib(20));   // 6765
    return 0;
}

File I/O

Write a few lines to a file, read them back, then append a timestamp. Demonstrates fio_write, fio_bufread, and fio_append.

func main() -> i32 {
    path: string = "notes.txt";

    // Write initial content (overwrites if exists)
    ok: bool = fio_write(path, "Line one\nLine two\nLine three\n");
    if (!ok) {
        println("Error: could not write file.");
        return 1;
    }

    // Read back line by line
    lines: Array<string> = fio_bufread(path);
    i: i32 = 0;
    n: i32 = length(lines);
    while (i < n) {
        println("  [", i, "] ", lines[i]);
        i = i + 1;
    }

    // Append a timestamp
    stamp: i64    = time_now();
    entry: string = "Written at unix time: ";
    fio_append(path, entry);
    fio_append(path, to_string(stamp));
    fio_append(path, "\n");

    sz: i64 = fio_size(path);
    println("File size: ", sz, " bytes");
    return 0;
}

Terminal Snake

A fully playable Snake game in the terminal. The snake grows each time it eats food, and the game ends when it hits a wall or itself. Uses raw mode input, ANSI cursor control, and a fixed-size board represented as a flat Array<i32>.

Controls: w a s d or arrow keys. q to quit at any time.

// Board is W×H cells. Cell values: 0 = empty, 1 = snake, 2 = food.
W:         i32 = 40;
H:         i32 = 20;
MAX_SNAKE: i32 = 800;
TICK_MS:   i32 = 120;

// Move cursor to (x, y) using ANSI escape
func goto_xy(e: string, x: i32, y: i32) -> void {
    print(e, "[", toStr(y + 1), ";", toStr(x + 1), "H");
}

func draw_border(e: string) -> void {
    row: i32 = 0;
    while (row < H) {
        goto_xy(e, 0, row);
        print(e, "[90m", "|", e, "[0m");
        goto_xy(e, W + 1, row);
        print(e, "[90m", "|", e, "[0m");
        row = row + 1;
    }
    col: i32 = 0;
    while (col < W + 2) {
        goto_xy(e, col, 0);
        print(e, "[90m", "-", e, "[0m");
        goto_xy(e, col, H + 1);
        print(e, "[90m", "-", e, "[0m");
        col = col + 1;
    }
}

func draw_cell(e: string, x: i32, y: i32, kind: i32) -> void {
    goto_xy(e, x + 1, y + 1);
    if (kind == 1) {
        print(e, "[32m", "■", e, "[0m");
    }
    if (kind == 2) {
        print(e, "[31m", "●", e, "[0m");
    }
    if (kind == 0) {
        print(" ");
    }
}

func spawn_food(board: Array<i32>, fx: ptr<i32>, fy: ptr<i32>) -> void {
    tries: i32 = 0;
    while (tries < 1000) {
        nx: i32 = rand_int(W);
        ny: i32 = rand_int(H);
        if (board[ny * W + nx] == 0) {
            *fx = nx;
            *fy = ny;
            board[ny * W + nx] = 2;
            return;
        }
        tries = tries + 1;
    }
}

func main() -> i32 {
    e: string = chr(27);

    // Flat board: index = y*W + x
    board: Array<i32> = [];
    i: i32 = 0;
    while (i < W * H) {
        board.push(0);
        i = i + 1;
    }

    // Ring-buffer arrays for snake body (x and y separately)
    sx: Array<i32> = [];
    sy: Array<i32> = [];
    i = 0;
    while (i < MAX_SNAKE) {
        sx.push(0);
        sy.push(0);
        i = i + 1;
    }

    head: i32 = 0;
    tail: i32 = 0;
    slen: i32 = 1;

    sx[0] = W / 2;
    sy[0] = H / 2;
    board[sy[0] * W + sx[0]] = 1;

    dx: i32 = 1;
    dy: i32 = 0;

    fx: i32 = 0;
    fy: i32 = 0;
    spawn_food(board, &fx, &fy);

    score: i32 = 0;

    tui_raw_mode_enter();
    clrscr();
    print(e, "[?25l");
    draw_border(e);
    draw_cell(e, sx[0], sy[0], 1);
    draw_cell(e, fx, fy, 2);
    flush_stdout();

    running: bool = true;
    while (running) {
        time_sleep(TICK_MS);

        key: i32 = -1;
        while (kb_hit()) {
            key = kb_read_key();
        }
        if (key == 119 || key == 1000) {
            if (dy != 1) { dx = 0; dy = -1; }
        } else if (key == 115 || key == 1001) {
            if (dy != -1) { dx = 0; dy = 1; }
        } else if (key == 97 || key == 1003) {
            if (dx != 1) { dx = -1; dy = 0; }
        } else if (key == 100 || key == 1002) {
            if (dx != -1) { dx = 1; dy = 0; }
        } else if (key == 113) {
            running = false;
        }

        nhx: i32 = sx[head] + dx;
        nhy: i32 = sy[head] + dy;

        if (nhx < 0 || nhx >= W || nhy < 0 || nhy >= H) {
            running = false;
        } else if (board[nhy * W + nhx] == 1) {
            running = false;
        } else {
            ate: bool = (board[nhy * W + nhx] == 2);

            head = (head + 1) % MAX_SNAKE;
            sx[head] = nhx;
            sy[head] = nhy;
            board[nhy * W + nhx] = 1;
            draw_cell(e, nhx, nhy, 1);

            if (ate) {
                score = score + 1;
                slen  = slen + 1;
                spawn_food(board, &fx, &fy);
                draw_cell(e, fx, fy, 2);
            } else {
                tx: i32 = sx[tail];
                ty: i32 = sy[tail];
                board[ty * W + tx] = 0;
                draw_cell(e, tx, ty, 0);
                tail = (tail + 1) % MAX_SNAKE;
            }

            goto_xy(e, 0, H + 2);
            print(e, "[2m", "  score: ", e, "[0m", e, "[1m", toStr(score), e, "[0m");
            flush_stdout();
        }
    }

    goto_xy(e, W / 2 - 5, H / 2);
    print(e, "[1;31m", "  GAME OVER  ", e, "[0m");
    goto_xy(e, W / 2 - 6, H / 2 + 1);
    print(e, "[2m", "  final score: ", e, "[0m", toStr(score));
    goto_xy(e, 0, H + 4);
    flush_stdout();

    print(e, "[?25h");
    tui_raw_mode_leave();
    return 0;
}