Simplest possible, usable systems language

Tig is a minimalistic systems programming language. 🦁🦁🦁

Note: see demo/ folder for some non trivial examples of Tig being used.

• Zero-Boilerplate Async — Write concurrent code with zero setup! No manual async_init() or async_shutdown() needed. Runtime initializes automatically on first async call.
• Async Functions — Simple async syntax: async fn void worker: i32 x { printi(x) } and call with worker(42)
• Thread Pool Management — Built-in thread pool with automatic resource management and cleanup
• Smart Compilation — Runtime automatically linked only when async functions are used (zero overhead for sync programs)
• Clean Output — No debug noise, just your program output
• Stdlib Module — use "stdlib/async.tc" for async functionality
• Ownership Transfer — @ operator for transferring ownership of resources between async tasks
• Select Statements — Wait on multiple async operations with select
• Queue & Stack Types — Built-in concurrent data structures with queue<i32> and stack<i32> (still buggy)
• Pin Keyword — Keep variables alive across async boundaries with pin

Make the first mainstream systems langauge from Mexico. Explore the bare minimum of what a systems language must have to be usable, modern and ergonomic

• 15 keywords — if, loop, break, defer, ret, strun, fn, use, pub, pin, match, else, enum, async, select
• Zero-Boilerplate Async — Automatic runtime initialization, no manual setup needed
• Async Functions — Simple concurrent programming with async fn
• Concurrent Data Structures — Built-in queue<T> and stack<T> types
• Ownership Transfer — @ operator for safe resource transfer
• Select Statements — Multi-operation waiting with select
• Pin Keyword — Keep variables alive across async boundaries
• No hidden magic — no GC, no type inference, no shadowing, no aliasing
• Raw pointers (->) and fat pointers (=>) with built-in slicing
• Manual memory — alloc() / free() with defer for cleanup
• Packed structs — no padding, predictable layout
• C FFI — extern "C" for direct interop
• Rust-style errors — colored diagnostics with source lines and carets
• One-step compile — tightc source.tc -c app transpiles and compiles in one command
• Inline imports — @use "lib.tc" inlines another .tc file at compile time
• CLI args — i32 fn main: =>->i8 args { ... } for command-line tools

Why it was made: I wanted a simple systems language with less keywords than Go, without GC and without heavy runtime overhead. Backend: For now it is C11 Core Ideal: Tig has to be able to fit in a single man's head. Small but powerful.

• Pony
• Nim
• Go
• C
• Rust

Everything that can be built with libraries has to be built with libraries. The core language is small. Explicit is better than implicit, but exceptions can be made... Flexibility over rigidity. Anything C can run, we run: Anywhere C has ran, we will run

Clone the repo and build the compiler:

# Build the compiler
make # requires make

# Compile stdlib headers in the stdlib folder (only needed once)
./tigc stdlib/io.tc -o stdlib/io.h

# One-step: transpile + compile to binary
./tigc samples/fizzbuzz.tc -c fizzbuzz
./fizzbuzz

# Or two-step: transpile to C, then compile yourself
./tigc samples/fizzbuzz.tc -o fizzbuzz.c
gcc fizzbuzz.c -std=c11 -o fizzbuzz

Tig is a source-to-source compiler (transpiler) written in ~4156 lines of C. It reads .tc files and outputs portable C11.

source.tc → [Lexer] → [Parser] → [AST] → [Emitter] → output.c → gcc/clang → binary

1. Lexer (lexer.c) — Tokenizes source into identifiers, literals, keywords, and symbols. Tracks line/col for error reporting.
2. Parser (parser.c) — Builds an AST from tokens. Handles operator precedence, scope-level pin enforcement, and @use file inlining (recursive parse + splice).
3. Emitter (emitter.c) — Walks the AST and outputs C11. Most constructs are 1:1 with targeted transforms:

There is no optimizer, no IR, no type inference pass, and no code generation beyond string concatenation of C. The output is always readable, debuggable C that you can inspect with tightc source.tc -o source.c.

• CLI tools — parse args, process files, call system APIs
• Embedded / bare-metal — no runtime, no allocator required, predictable memory layout (packed structs)
• Game engine internals — manual memory, no GC pauses, direct pointer control
• Learning compilers — small enough to read in an afternoon, real enough to produce working binaries
• C codebases that want better ergonomics — fat pointers, defer, slicing, without leaving the C ecosystem

use "stdlib/io.tc"

fn void main: {
    print("hello, world")
}

i32 x = 10
f64 pi = 3.14
u8 byte

Uninitialized variables default to 0.

fn i32 add: i32 a, i32 b {
    ret a + b
}

Functions can declare variadic arguments with ...:

extern "C" {
    i32 fn printf: ->i8 fmt, ... {}
}

Note: ... in function calls is implicit - you don't need to write it when calling varargs functions.

Both a struct and a union, this way we dont need two keywords for structs and unions Now we have a spectrum.

[struct]—[strun]—[union]

Use & to create a union element inside the strun.

For a normal struct:

strun Point{
  i32 x,
  i32 y
}

For a Union:

strun Data{
  &i32 data
  &str ip
}

For a strun:

strun hybrid{
  i32 x
  i32 y
  &i32 z
  &f32 w
}

z and w share the same memory location.

• Anonymous padding You can padd memory inside struns with anonymous types Example:

strun hybrid{
  &i32 x
  &i32 y
  i32 // anonymous padding
  &i32 z
  &f32 w
}

This groups x and y together, and z and w together.

i32 x = 42
->i32 ptr = @x          // raw pointer (address-of)
->ptr = 99              // dereference

i32[4] arr = {1,2,3,4}
=>i32 slice = @arr       // fat pointer from array
printi(slice.len)        // built-in length
printi(slice.ptr[0])     // access elements

=>i32 sub = arr[1:3]     // slicing

->->i32 pp = @p          // pointer to pointer
=>->i32 fps = @ptrs      // fat pointer of raw pointers
->=>i32 pslice = @slice  // raw pointer to fat pointer
=>=> sslice = @slice     // fat pointer to fat pointer

strun Point{
    i32 x,
    i32 y
}

Point p = {1, 2}

fn void printP: ->Point p {
    printi(p.>x)
    printi(p.>y)

    // or this can be done too
    printi((->p).x)
    printi((->p).y)
}

if (x > 0) { ... }
else if (x < 0) { ... }
else { ... }

loop { ... break }          // infinite loop unless break

loop if (i < 10) { ... }    // conditional loop

->i32 arr = alloc(i32, 100)
defer { free(arr) }

use "stdlib/io.tc"       // link to pre-compiled .h
@use "utils.tc"          // inline .tc at compile time

i32 fn main: =>->i8 args {
    printi(args.len)         // argc
    print(args.ptr[1])       // first user argument
    ret 0
}

extern "C" {
    i32 fn printf: ->i8 fmt, ... {}
}

error[E000]: cannot assign to pinned variable 'x'
 --> samples/pin.tc:8:5
   |
 8 |     x = 11 // this should be illegal since x is pinned in this scope
   |     ^ cannot assign to pinned variable 'x'

E000
Type "tightc --error E000" for help

PS C:\Users\me\.projects\langs\tc> ./tightc --error E000
E000: Assignment to pinned variable

A variable marked with `pin` is immutable in the current scope.
You cannot reassign it with `=`, `+=`, `-=`, or any other assignment.

Bad:
    i32 x = 10
    pin x
    x = 11       // error: cannot assign to pinned variable

Fix: remove the `pin` or avoid reassigning the variable.

match (n) {
        1 = {
            print("one")
        }
        2 = {
            print("two")
        }
        3 = {
            print("three")
        }
        _ = {
            print("other")
        }
    }

use "stdlib/async.tc"
use "stdlib/io.tc"

async fn void worker: i32 x {
    printi(x)
}

fn void main: {
    // No async_init() or async_shutdown() needed!
    worker(42)  // Automatically initializes runtime
}

use "stdlib/async.tc"
use "stdlib/io.tc"

async fn void producer: queue<i32> q {
    q.push(100)
}

async fn void consumer: queue<i32> q {
    i32 value = q.pop()
    printi(value)
}

fn void main: {
    queue<i32> q = {}
    producer(q)
    consumer(q)
}

async fn void task1: { printi(1) }
async fn void task2: { printi(2) }

fn void main: {
    select {
        case task1():
            printi("Task 1 completed")
        case task2():
            printi("Task 2 completed")
    }
}

tigc <input.tc> [-o output.c] [-c binary] [-t]

Combine both: tightc app.tc -o app.c -c app keeps the .c and builds the binary.

Tig supports global hot reloading. This allows you to modify functions, structs (strun definitions), and enums, and recompile shared libraries completely on-the-fly without restarting your running application.

# 1. Compile host + hot library version 1
tigc hot.tc -H hotlib -c hot_app

# 2. Run the application
./hot_app

# 3. While running, modify any function/logic in hot.tc and rebuild the library
tigc hot.tc -H hotlib --hot

The running application will automatically detect the changes, unload the old library, load the new one, and immediately execute the new code on the next loop iteration.

Tig uses a robust Host/DLL splitting architecture to avoid Windows file locking issues and guarantee clean reloads during loops:

• Host (The Driver): The main function is compiled directly into the host executable. This ensures the main driver/application loop resides safely outside the shared library, avoiding trapped call stacks. The host manages loading/unloading and resolves stubs.
• Library (The Engine): All other functions, structs, and enums are compiled into the shared library (hotlib_N.dll on Windows / hotlib_N.so on Unix). Every function is exported automatically.
• Dynamic Reloading: When a function is called, a host stub checks the current library version, reloads if a new version is detected, and executes through function pointers.
• Automatic Cleanup: On a successful reload, the host automatically and cleanly deletes old version files to keep your workspace pristine.

use "stdlib/io.tc"

extern "C" {
    i32 fn Sleep: u32 ms {}
}

fn i32 add: i32 x, i32 y {
    ret x + y + 10
}

fn i32 main: {
    loop {
        i32 result = add(3, 4)
        printi(result)
        Sleep(2000)
    }
}

Running this prints 17 every 2 seconds. If you edit ret x + y + 10 to ret x + y + 20 and run tigc hot.tc -H hotlib --hot, the output instantly changes to 27 without restarting the app!

See the demos/HOTSWAPPING/ folder for a complete working example with documentation, including the demo output showing hot reload in action.

This feature demonstrates Tig's capability for advanced systems programming patterns, using the industry-standard approach to hot reload on Windows (versioned libraries).

tc-lang/
  compiler/
    include/     # Header files
    src/         # Compiler source (C)
  stdlib/        # Standard library (.tc)
  samples/       # Example programs
  docs/          # Language specification
  Makefile       # Build system

stdlib/io.tc — I/O

File I/O (via extern "C")

stdlib/str.tc — Strings

stdlib/math.tc — Math

stdlib/mem.tc — Memory

stdlib/conv.tc — Conversions

_{Built by @alonsovm44}