One wayto say it.

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

Explore Topaz

Understand Topaz, then learn, look something up, or build.

Start with what Topaz is for. Then follow the guided path, scan the syntax map when you need a quick answer, or choose a toolchain destination.

Introducing Topaz

See what Topaz is designed for, what its code looks like, and where it fits before writing your first program.

Meet Topaz →02

Learn Topaz

Start with one small program and continue step by step to a checked, tested, two-module application.

Start learning →03

Syntax at a Glance

Scan everyday syntax and jump straight to the focused manual page for each language feature.

Open the syntax map →04

Tools and targets

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

Explore the tools →

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 — 798 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