One wayto say it.

A small, closed language for application intent, written by people and by agents, verified by the toolchain.

Explore Topaz

Language manual, tools, and project story.

Learn the language, choose a build target, or see how Topaz has evolved and where it is going next.

Language manual

Grammar, types, control flow, modules, the standard library, runtime behavior, and worked examples.

Read the manual →02

Tools and targets

CLI, direct execution, Rust, Python, web targets, WASM, packages, and current support.

Explore the tools →03

History & roadmap

The v5 release history, current roadmap, and Topaz Classic.

See the project story →

Run this program today and get the output shown here.

TOPAZ

function clean(words: Array<string>) -> Array<string> {
    return filter(words, (w: string) => w != "")
}

function shout(words: Array<string>) -> Array<string> {
    return map(words, (w: string) => w + "!")
}

let line = ["one", "", "way", "", "to", "say", "it"]
    |> clean
    |> shout
print("{line}")

output

[one!, way!, to!, say!, it!]

A Small, Closed Surface

One way to say it. The language decides policy, so you don’t have to.

Unicode-First Identity

Domain words stay in your language: 한글, Кириллица, emoji are first-class.

Agent-Ready by Design

A small spec, machine-checkable profiles, docs verified against the parser.

Templates with Intent

sql, sh, and path templates preserve literal and interpolation structure.

Executable Specification

Readable enough to review and precise enough to run.

Topaz is a compact, Unicode-first language for application intent. People and code generators use the same syntax, and the toolchain can run it directly or produce Rust, Python, and web artifacts.

Read the philosophy →

The code is the hero.

TOPAZ

function discount(customer: { tier: string, years: int }) -> float {
    return match customer {
        case { tier: "vip", years } if years > 5 => 0.3
        case { tier: "vip" } => 0.2
        case { years } if years > 1 => 0.1
        case _ => 0.0
    }
}

print("{discount({ tier: "vip", years: 7 })}")
print("{discount({ tier: "new", years: 0 })}")

output

0.3
0.0

TOPAZ

let result = concurrent {
    answer: 6 * 7
    status: "ready"
}

defer print("cleaned up")
print("{result.answer} {result.status}")

output

42 ready
cleaned up

TOPAZ

function fibonacci(n: int) -> int {
    return match n {
        case 0 => 0
        case 1 => 1
        case _ => fibonacci(n - 1) + fibonacci(n - 2)
    }
}

let series = map(0..<10, fibonacci)
print("{series}")

output

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

TOPAZ

function clean(words: Array<string>) -> Array<string> {
    return filter(words, (w: string) => w != "")
}

function shout(words: Array<string>) -> Array<string> {
    return map(words, (w: string) => w + "!")
}

let line = ["one", "", "way", "", "to", "say", "it"]
    |> clean
    |> shout
print("{line}")

output

[one!, way!, to!, say!, it!]

Any tongue. Same code.

한국어

TOPAZ

function 인사하기(이름: string) -> string {
    return "안녕하세요, {이름}님!"
}

print(인사하기("토파즈"))

output

안녕하세요, 토파즈님!

English

TOPAZ

function greet(name: string) -> string {
    return "Hello, {name}!"
}

print(greet("Topaz"))

output

Hello, Topaz!

Русский

TOPAZ

function привет(имя: string) -> string {
    return "Привет, {имя}!"
}

print(привет("Топаз"))

output

Привет, Топаз!

What works today →

You write the intent. The compiler emits Rust and Python.

Parser

Available — 69 examples checked

Module resolver

Available — multi-file units

Interpreter

Available — every program on this page runs

Rust backend

Available — emits Rust and builds native programs

Python backend

Available — emits Python with runtime support

User enums

Available — nominal closed sums with exhaustive match

Get Started Try the playground