Show HN: Tight C, a systems language with 10 keywords

Simplest possible, usable systems language

Tight-C is a minimal systems programming language that compiles to C. It has 10 keywords, no garbage collector, no inference, no OOP — just explicit, predictable code with C-level power.** 10 keywords**—if

,loop

,break

,defer

,ret

,struct

,fn

,use

,pub

,pinNo hidden magic— no GC, no type inference, no shadowing, no aliasing** Raw pointers**(->

) andfat pointers(=>

) with built-in slicingManual memory—alloc()

/free()

withdefer

for cleanupPacked structs— no padding, predictable layout** C FFI**—extern "C"

for direct interopCompiles to C11— readable output, use any C toolchain

make

./tcc stdlib/io.tc -o stdlib/io.h

./tcc samples/fizzbuzz.tc -o fizzbuzz.c

gcc fizzbuzz.c -std=c11 -o fizzbuzz
./fizzbuzz
use "stdlib/io.tc"

void fn main: {
    print("hello, world")
}
i32 x = 10
f64 pi = 3.14
u8 byte

Uninitialized variables default to 0

.

i32 fn add: i32 a, i32 b {
    ret a + b
}
struct Point {
    i32 x,
    i32 y
}

Point p
p.x = 10
php
i32 x = 42
->i32 ptr = @x       // address-of
->ptr = 99           // dereference

=>i32 slice = arr[1:4]  // fat pointer (slice)
i32 len = slice.len      // built-in length
if (x > 0) { ... }

loop { ... break }

loop if (i < 10) { ... }
php
->i32 arr = alloc(i32, 100)
defer { free(arr) }
php
extern "C" {
    i32 fn printf: ->i8 fmt, ... {}
}

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

| Function | Description |
|---|---|
`print(s)` |
Print string + newline |
`printn(s)` |
Print string, no newline |
`printi(n)` |
Print i64 + newline |
`printin(n)` |
Print i64, no newline |
`readi()` |
Read i64 from stdin |
`readc()` |
Read single char from stdin |**stdlib/str.tc** — Strings

| Function | Description |
|---|---|
`slen(s)` |
String length |
`seq(a, b)` |
String equality (returns 1 if equal) |
`scpy(dest, src)` |
Copy string |
`scat(dest, src)` |
Concatenate strings |
`sneq(a, b, n)` |
Compare first n bytes |
`sfind(s, c)` |
Find first char occurrence |
`sfindlast(s, c)` |
Find last char occurrence |
`shas(haystack, needle)` |
Find substring |**stdlib/math.tc** — Math

| Function | Description |
|---|---|
`iabs(x)` |
Absolute value (integer) |
`min(a, b)` |
Minimum of two integers |
`max(a, b)` |
Maximum of two integers |
`clamp(x, lo, hi)` |
Clamp value to range |
`sqrt64(x)` |
Square root (f64) |
`pow64(base, exp)` |
Power (f64) |
`fabs64(x)` |
Absolute value (f64) |
`sin` , `cos` , `tan` |
Trig functions (extern C) |
`log` , `log2` , `log10` |
Logarithms (extern C) |**stdlib/mem.tc** — Memory

| Function | Description |
|---|---|
`zero(ptr, n)` |
Zero out n bytes |
`copy(dest, src, n)` |
Copy n bytes (overlap safe) |
`memeq(a, b, n)` |
Compare n bytes (1 if equal) |
`fill(ptr, val, n)` |
Fill n bytes with value |**stdlib/conv.tc** — Conversions

| Function | Description |
|---|---|
`stoi(s)` |
String to i64 |
`stoib(s, base)` |
String to i64 with base |
`stof(s)` |
String to f64 |
`itos(n, buf, size)` |
i64 to string (into buffer) |
`ftos(n, buf, size)` |
f64 to string (into buffer) |

Requires `gcc`

and `make`

.

make # Build tcc make clean # Remove build artifacts

Everything that can be built in the stdlib has to.

Tight-C bets that C's power doesn't require C's complexity. Strip away the historical baggage and you get a language a single person can implement, understand fully, and still write real systems code in.

Built by @alonsovm44