tc-lang (Tig)

Tig (the repo is tc-lang) is a minimalist systems language by Alonso VM that transpiles to portable C11. The pitch is ergonomics over C without paying for a garbage collector, type inference, or a heavy runtime — a language small enough to "fit in a single person's head", with 18 keywords. The compiler emits readable C that you hand to gcc or clang.

On the watchlist — see watchlist — because it's a pre-1.0, single-author project at around 40 stars aiming at OS-scale use.

How it works

Source-to-source, about 4,600 lines of C: lexer, parser, AST, checker, emitter, then C11 out to the system compiler. There is no optimizer, no intermediate representation, and no type inference — codegen is essentially readable-C string concatenation. All the heavy lifting is deferred to gcc/clang, which keeps the compiler itself small and auditable.

The stated bootstrap plan has two stages. Stage0 permits an AI-generated C core (the current transpiler). Stage1, the self-hosting compiler, requires handwritten code — AI-generated source is not allowed to count toward the self-host.

Distinctive syntax

Pointers come in two flavours: raw pointers written -> and fat pointers written => (a struct carrying .ptr + .len, with built-in slicing like arr[1:3]). strun unifies struct and union as a single spectrum, using & to mark shared-memory members. defer runs cleanup at scope exit. pin marks a binding scope-local immutable — enforced at parse time, emitting nothing into the generated C.

Errors are a built-in type rather than a return-value convention. An error declaration carries context parameters plus cleanup, is raised with throw, and handled by try/catch — where catch behaves like a match, including a _ wildcard. Diagnostics are Rust-style: colored output with error codes.

Concurrency has no boilerplate. An async fn auto-initializes the runtime; async functions are always void and communicate through built-in queue<T> / stack<T> channels. select waits on multiple operations, and @ transfers ownership. There's a global hot-reload mode (-H/--hot) built on a Host/DLL split: main stays in the host process while everything else compiles into a versioned hotlib_N.so/.dll reloaded through function-pointer stubs. @use "lib.tc" inlines another file at compile time, and C FFI is a "C"{ #include ... } block.

Usage

strun Point { x: i32; y: i32 }

fn main() -> i32 {
    nums => [1, 2, 3, 4]   // fat pointer / slice
    part = nums[1:3]       // built-in slicing
    defer cleanup()        // runs at scope exit
    return 0
}

Ownership transfer and channels in async code:

async fn worker(q: queue<i32>) {
    x = <- q               // receive
}

Limitations

Explicitly not memory-safe: no borrow checker, no GC, manual alloc/free. Arenas are planned but not shipped, so today memory management is entirely on the programmer — the same footgun profile as C, which it also doesn't try to hide behind a safety layer like safe-gc or the runtime checks in simplified-model-of-fil-c.

Licensing is ambiguous: the README carries an MIT badge, but GitHub detects no SPDX license file in the repo, so the actual grant is unclear until a LICENSE lands. The project's goals are stated ambitiously — "the first usable systems language from Mexico" and "make an OS with it" — against a single-author, pre-1.0 codebase.

Repo

github.com/alonsovm44/tc-lang — C, MIT (per README badge; no SPDX license file detected by GitHub), ~40 stars.

Related

• zig — a more mature C-replacement with the same no-GC, no-hidden-runtime stance, but a real type checker and comptime
• c3-lang — another minimal C evolution transpiling close to C's model
• unsigned-sizes-c3-mistake — a C3 retrospective on a specific design choice worth weighing against Tig's
• safe-gc, simplified-model-of-fil-c — the memory-safety approaches Tig deliberately skips