Tauraro

Compiled · Statically Typed · Python Syntax · C Performance · Bilingual

Documentation  ·  Examples  ·  Releases  ·  Issues

---

What Is Tauraro?

Tauraro is a compiled, statically-typed language with Python-style indentation syntax. It compiles to C and then to native machine code via GCC or Clang — giving you Python's readability with performance close to hand-written C.

It is also the first programming language with full bilingual keyword support — every keyword has both an English and a Hausa equivalent. Programs can be written in either language, or mixed freely.

def greet(name: str) -> str:
    return f"Hello, {name}!"

def main():
    print(greet("world"))

---

Installation

Download the latest binary from the Releases page:

Platform	File
Windows (x64)	tauraroc-windows-x64.zip
Linux (x64)	tauraroc-linux-x64.tar.gz
macOS (x64/arm64)	tauraroc-macos.tar.gz

Extract and place tauraroc (or tauraroc.exe on Windows) somewhere on your PATH.

Requirement: GCC or Clang must be installed. Tauraro compiles to C and uses the system C compiler to produce the final binary.

Verify your installation:

tauraroc --version
# tauraroc v0.0.3

---

Quick Start

hello.tr

def main():
    print("Hello, world!")

tauraroc --run hello.tr

---

Language Features

Feature	Description
Classes	Method dispatch, inheritance (extends), interfaces, operator overloading
Enums	Tagged unions with pattern matching
Generics	Monomorphized at compile time — no boxing
F-strings	f"result = {value}" — zero overhead
Ownership	Automatic memory management, no GC
Error handling	Result[T,E], throws, ? operator
Concurrency	spawn, task_group:, await_all, Thread.spawn, Chan[T], Mutex[T], Atomic[T]
Data race safety	Sendable interface enforced at compile time on all spawn/thread boundaries
Unsafe	unsafe:, Pointer[T], inline asm()
GPU	gpu: blocks → OpenMP parallel loops
FFI	extern "C" for calling C libraries
Closures	First-class anonymous functions with capture
Bilingual	English + Hausa keywords, mix freely

---

CLI Reference

tauraroc <file.tr> [options]

  --version         Print compiler version and exit
  --run             Compile and immediately execute
  --check           Semantic analysis only, no output
  --emit c          Print generated C code
  --emit ast        Print AST and stop
  --verbose         Show all pipeline phases
  -o <path>         Output executable path
  -O0/-O1/-O2/-O3  Optimization level (default: -O2)
  -Os               Optimize for size
  -fopenmp          Enable OpenMP for gpu: blocks
  -I <dir>          Add module search path

---

Bilingual Keywords

Every keyword has an English and Hausa equivalent:

English	Hausa	Meaning
def	aiki	define function
class	aji	define class
struct	tsari	define struct
if	idan	conditional
elif	koidan	else-if
else	sai	else
for	ga	for loop
while	yayinda	while loop
return	dawo	return
break	tsaya	break
continue	ci_gaba	continue
match	duba	pattern match
case	hali	match arm
try	gwada	try block
except	kama	except handler
finally	karshe	finally block
raise	jefa	raise exception
async	ba_jira	async function
await	jira	await expression
import	shigo	import module
from	daga	from import
as	kamar	alias
in	a_cikin	membership / loop
true	gaskiya	boolean true
false	karya	boolean false
none	babu	null / none
and	da	logical and
or	ko	logical or
not	ba	logical not
print	buga	print to stdout

---

Example Program

class Counter:
    pub total: i64

extend Counter:
    pub def init(n: i64) -> Counter:
        mut c = Counter()
        c.total = n
        return c

    pub def add(self, n: i64) -> void:
        self.total = self.total + n

    pub def show(self) -> void:
        print(f"total = {self.total}")

def main():
    mut c = Counter.init(0)
    for i in range(10):
        c.add(i)
    c.show()    # total = 45

---

Compiler Pipeline

.tr source
    │
    ▼
  Lexer          tokenize source text
    │
    ▼
  Parser         build AST
    │
    ▼
  Sema           type-check, resolve names
    │
    ▼
  HIR            typed intermediate representation
    │
    ▼
  C Codegen      emit C source
    │
    ▼
  GCC / Clang    compile to native binary
    │
    ▼
  Executable

All stages are written in Tauraro itself — the compiler is fully self-hosted.

---

Performance

Benchmarks run on Linux x86_64 with gcc -O3 (C), rustc -C opt-level=3 -C target-cpu=native (Rust), and tauraroc -O3 (Tauraro → C → gcc -O3 -march=native -funroll-loops). Wall-clock seconds, lower is better.

Benchmark	C (s)	Rust (s)	Tauraro (s)	Tau/C	Tau/Rust
Fibonacci 1B	0.313	0.311	0.311	0.99×	1.00×
Float Multiply 1B	0.933	0.934	0.934	1.00×	1.00×
XOR Shift PRNG 1B	1.866	1.867	1.870	1.00×	1.00×
Newton Sqrt 1B	6.063	6.046	6.053	1.00×	1.00×
Mandelbrot 800×800	0.442	0.441	0.428	0.97×	0.97×
N-Body 10M	0.286	0.284	0.289	1.01×	1.02×
Sieve 50M	0.172	0.182	0.265	1.54×	1.46×
Matrix Multiply 400×400	0.015	0.012	0.033	2.20×	2.75×

Tauraro runs at C/Rust parity on the scalar compute kernels (within ~3%), and stays leaner than Rust on memory across the board. Sieve and MatMul are still slower (cache/aliasing-bound). Full results, including peak memory, in benchmarks/README.md.

---

Documentation

The full language reference lives in docs/lang/:

#	Topic
01	Introduction & CLI
02	Variables & Types
03	Operators
04	Control Flow
05	Functions & Closures
06	Strings & F-Strings
07	Collections
08	Classes & Extend
09	Enums
10	Interfaces
11	Generics
12	Error Handling
13	Memory & Ownership
14	Unsafe & Pointers
15	Modules
16	Concurrency
17	Extern & FFI
18	GPU & Inline Assembly
19	Compiler Error Reference
20	Advanced Patterns
21	Operator Overloading

---

License

Tauraro is dual-licensed under your choice of:

• MIT License — see LICENSE-MIT
• Apache License, Version 2.0 — see LICENSE-APACHE

You may use, distribute, and modify Tauraro under the terms of either license.

_{Built with ❤️ — Python syntax · C performance · Hausa soul}