A modern systems language that
transpiles to C11.

A systems language that compiles to C11. Optionals, generics, and compile-time metaprogramming are first-class, with no runtime to carry. Error unions are next on the roadmap.

Install Tinoc Read the docs Star on GitHub 
#import std.io;

fn main() void {
    var name str = "Prathmesh";
    const lang = "Tinoc";

    io.println("{s} is creator of {s} Programming Language!", name, lang);
}
● typing main.tnc — watch it transpile
Philosophy

Five principles guide the design.

Tinoc respects C and its ecosystem. These principles shape every design decision.

01

Meaningful

Code states its intent. Names, syntax, and structure say what they mean.

02

Accurate

Types capture the contract. Sizes, optionals, and errors are explicit and checked.

03

Robust

Compile-time checks for the cases C leaves to chance: overflow, nulls, and errors.

04

Maximum Performance

Transpiles to C11 with no runtime. What you write is what the machine runs.

05

Simple

A small, composable core. One way to read a loop, one way to make a type.

Why Tinoc

C-level control with better defaults.

Each feature addresses a known weakness of C while keeping its performance and control.

Transpiles to C11

Your .tnc files compile to portable C11 with one small runtime header. It runs anywhere a C11 compiler is available.

Explicit types

i8 → i128, u8 → u128, f32/f64/f128, str, slices, optionals, and generics.

Concise syntax

if, while, switch, and for without parentheses. |i| capture bindings. orelse and ? for safe unwraps.

Compile-time metaprogramming

#import resolves modules at comptime, #run executes code during compilation, #partial tracks enum switch coverage.

Modules & C interop

#import with pub visibility, real C headers via #importc, and hand-declared extern "C" fn.

Built in the open

v0.1.0 is out and installable. Developed in public on GitHub; syntax, compiler, and docs are public from day one, and contributors are welcome.

A taste of Tinoc

Small syntax, real structure.

A struct with methods, a generic Pair:T, and a range for. Each construct is small, and all of it transpiles to plain C11.

  • Methods take self ^Point. Mutation is explicit, never hidden.
  • Generics are written :T and :(K, V).
  • Loops capture with |i|, a binding rather than a closure.
Explore the language
pair.tnc
#import std.io;

struct Point {
    x f32;
    y f32;

    fn translate(self ^Point, dx f32, dy f32) void {
        self^.x += dx;
        self^.y += dy;
    }
}

struct Pair:T {
    first T;
    second T;

    fn swap(self ^Pair:T) void {
        var tmp T = self^.first;
        self^.first = self^.second;
        self^.second = tmp;
    }
}

fn main() void {
    var p Point = Point { .x = 1.0, .y = 2.0 };
    p.translate(0.5, 1.5);

    var pair Pair:i32 = Pair:i32 { .first = 10, .second = 20 };
    pair.swap();
    io.println("{any}", pair);
}
Type system

Types you can trust.

Fixed-width integers, floats, strings, slices, optionals, and heap collections. Sizes and layouts are explicit.

i8 … i128signed integers
u8 … u128unsigned integers
f32 · f64 · f128floating point
bool · charboolean · codepoint
strlength-aware string
[N]T · []Tarrays · slices
^Tpointers
?Toptionals
!T · E!Terror unions — planned
vec:Tdynamic arrays
map:(K,V)hash maps
set:Thash sets

Dive into the full type reference →

Documentation

Start with the basics.

The language reference lives next to the compiler in the repository.

var / constvariables & constants fn main() voidfunctions & generics i32, str, ?T, !Tthe type system ?T · orelse · x?safe unwraps struct Pointstructs & methods enum Directionenums & unions if / switch / forcontrol flow #import · modulemodules & C interop
Language support

What works end-to-end today.

The compiler ships a feature at a time. This table tracks what the current release supports, straight from the repository.

FeatureStatusNotes
var / const (incl. static)ShippedExplicit or inferred types; const-mutability enforced
fn functionsShippedForward calls, argument/return type checking, missing-return checks
struct + methodsShippedFields, struct literals, instance/static methods, by-value copy
enum + methodsShippedFieldless variants and tagged unions with payloads; exhaustive switch
switchShippedEnum variants, integer/char literals, _ default, pattern binding
PointersShipped^T, &x, x^, self^.x → self->x
Control flowShippedif / else, while, for 0..10 |i|, break, continue
Literals & operatorsShippedAll bases, _ separators, arithmetic/comparison/logical/bitwise; content-based str ==/!=
C interopShipped#importc "header.h" and extern "C" fn
Modules & #importShippedmodule keyword, pub visibility, all import forms, cycle detection, merged C output
GenericsShippedfn foo:T, struct Pair:T, alias Opt:T = ?T; — monomorphized per type-argument set
union + methodsShippedC-style shared-memory fields, instance/static methods, generic unions
Arrays / slicesShipped[N]T, [_]T, []T, [N:x]T sentinel arrays, implicit array → slice
OptionalsShipped?T, null, orelse, x?, == null / != null
Error unionsPlanned!T, catch — on the roadmap
Standard library (std.io, …)PlannedUser modules are in; the std library ships when the language matures

Full details in the language reference and the changelog.

Status

v0.1.0 is released.

The first public release shipped on August 5, 2026. Prebuilt binaries for macOS, Linux, and Windows are available through the installers, and the compiler, syntax, and tooling keep evolving in public.

Install Tinoc Read the changelog

  1. Compiler core

    Lexing, parsing, semantic analysis, and C11 emission — done and released.

  2. Language features

    Modules, generics, optionals, arrays, slices, enums, and unions ship in v0.1.0.

  3. Releases & installers

    v0.1.0 binaries for macOS, Linux, and Windows; package-manager installs come later.

  4. On the roadmap

    Error unions (!T / catch) and the standard library (std.io, std.math, std.collections).

Join the community

Help build the language.

Follow the repository, join the Discord, and take part in design discussions. Every issue and pull request helps.

Join the Discord Explore the community GitHub org