        ▄▄▄▄▄▄▄▄▄▄▄▄
     ▄██▀░░░░░░░░░░░▀██▄
   ▄█▀░░░░░░░░░░░░░░░░░▀█▄
  █▀░░▄▄              ▄▄░▀█
  █░▄▀  ▀▄          ▄▀  ▀▄░█
 █░█ ●   █    ▄▄    █   ● █░█
 █░█▄   ▄▀   █▓▓█   ▀▄   ▄█░█
 █░░▀▀▀▀     ▀▓▓▀     ▀▀▀▀░░█
  ▀█░░░░░░▀▀ ▀▀▀▀ ▀▀░░░░░░█▀
   ▀█▄░░░░░░░░░░░░░░░░░▄█▀
 ▄▓▓▓▓▀██▄▄▄▄▄▄▄▄▄▄▄▄██▀▓▓▓▓▄

The AI-First Language

Skuf compiles to native code via C, ships with UglyBoot, and keeps syntax minimal so LLMs can read, write, and reason about your code with fewer tokens and less ambiguity.

See Why Skuf

$ make build && skuf run main.skf

Why Skuf

Designed from the ground up so AI writes better code, faster.

{ }

Minimal Token Footprint

No curly braces, no semicolons, no `function` keyword. Every construct is short and unambiguous. LLMs spend fewer tokens parsing and generating Skuf than equivalent C, Go, or Java.

One Way to Do Things

Skuf avoids synonyms and syntactic sugar that create branching choices for a model. One loop, one branch, one way to declare a function. Less ambiguity = higher-quality AI code on the first try.

[ ]

Flat Learning Surface

The entire grammar fits in a single context window. An AI agent can internalize the full language spec without retrieval — no documentation lookups needed.

>>>

Native Performance

Compiles .skf to C, then to a native binary. No VM, no garbage collector pauses. Your code runs as fast as hand-written C.

@ai

AI-Native Features

@ai annotations, require/ensure contracts, |> pipe operator, structured JSON errors, --explain and --spec output designed for agent consumption.

⇄

Dual Format (.skf / .unskf)

Compact .skf for AI agents, human-readable .unskf for developers. Same code, two views. ~50-60% token reduction in compact form.

Clean, Minimal Syntax

Everything an LLM needs, nothing it doesn't.

Hello World

mod main

fn main():
  >> "Hello from Skuf!"

Contracts (require / ensure)

#Safely divide two integers
fn safe_divide(a, b) -> int:
  req b != 0
  r := a / b
  ens r * b == a
  ~ r

Pipe Operator

result := 5 |> double |> add_one |> square

HTTP Server (UglyBoot)

use uglyboot.http
use uglyboot.log

mod main

fn main():
  app := http.app()

  app.get("/", |_|:
    log.info("hello_hit", { p: "/" })
    res.text(200, "Hello, world!")
  )

  http.listen(app, 8080)

Sum Types

type Result[T]:
  Ok(T)
  Err(string)

type Shape:
  Circle(radius)
  Rect(width, height)

Built-in Tests

tst "addition":
  !! add(1, 2) == 3
  !! add(0, 0) == 0

tst "factorial":
  !! factorial(5) == 120

Two Formats, One Language

Write compact .skf for AI, read verbose .unskf for humans.

.skfAI-optimized (compact)

fn add(a, b) -> int:
  ~ a + b

fn greet(name) -> string:
  ~ "Hello, " + name

.unskfHuman-readable (verbose)

function add(a: int, b: int) -> int:
  return a + b

function greet(name: string) -> string:
  return "Hello, " + name

~50-60% token reduction in .skf vs .unskf

Batteries Included

A complete toolchain that speaks AI natively.

skuf build

Compile .skf to native binary via C

skuf run

One-step build and execute

skuf explain

Plain-English code description

skuf spec

Token-efficient module spec for LLM prompts

skuf test

Run built-in tests

skuf unskf

Convert to human-readable format

--json-errors

Structured errors AI agents can parse without regex

UglyBoot

Built-in HTTP server framework

Structured Errors for AI Agents

No regex parsing needed. AI agents fix issues in one shot.

[
  {
    "file": "src/main.skf",
    "line": 7,
    "col": 3,
    "code": "E0110",
    "msg": "expected expression",
    "hint": "res"
  }
]

Start building with Skuf

Build the compiler, write your first program, and let AI handle the rest.

# Build the compiler
make build

# Write your first program
cat > src/main.skf << 'EOF'
mod main

fn main():
  >> "Hello from Skuf!"
EOF

# Compile and run
skuf run src/main.skf