A small, closed language for application intent, written by people and agents, verified by the toolchain.
Explore Topaz
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.
See what Topaz is designed for, what its code looks like, and where it fits before writing your first program.
Meet Topaz →02Start with one small program and continue step by step to a checked, tested, two-module application.
Start learning →03Scan everyday syntax and jump straight to the focused manual page for each language feature.
Open the syntax map →04CLI, direct execution, Rust, Python, web targets, WASM, packages, and current support.
Explore the tools →Run this program today and get the output shown here.
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}")[one!, way!, to!, say!, it!]
Run the file you just wrote. The same file builds a native binary, a Python bundle or a web package, and the choice is a flag on one command.
Every ordinary idea has one canonical form, and the language holds that line. A file a person wrote and a file a generator wrote come out the same shape.
Recoverable failure travels as a Result and expected absence travels as an Option. Cleanup runs on every exit path, and the checker names the case your match left out.
Identifiers are Unicode from the lexer up and nothing rewrites them behind your back. 사용자 is an ordinary variable, and the module resolver rejects names that invite confusion.
The surface stays small because the small surface is the product. The same compact grammar is what a person reads and what a generator writes.
A specification for humans and executable code for computers.
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 →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 })}")0.3 0.0
let result = concurrent {
answer: 6 * 7
status: "ready"
}
defer print("cleaned up")
print("{result.answer} {result.status}")42 ready cleaned up
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}")[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
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}")[one!, way!, to!, say!, it!]
function 인사하기(이름: string) -> string {
return "안녕하세요, {이름}님!"
}
print(인사하기("토파즈"))안녕하세요, 토파즈님!
function greet(name: string) -> string {
return "Hello, {name}!"
}
print(greet("Topaz"))Hello, Topaz!
function привет(имя: string) -> string {
return "Привет, {имя}!"
}
print(привет("Топаз"))Привет, Топаз!