Ling — The Omniglot Systems Language

Ling is a polyglot scripting language whose keywords and builtins are available in 16+ human languages simultaneously — Chinese, Thai, Korean, Japanese, English, Arabic, Hebrew, Russian, and more — in the same source file.

# All four in one file:
令 启 = 执 { 印("你好") }          # Chinese
令 เริ่ม = ดำเนินการ { พิมพ์("สวัสดี") }  # Thai
bind start = do { print("Hello") }   # English
바인드 시작 = 수행 { 인쇄("안녕") }      # Korean

Core features

• Polyglot keywords — write loops in Chinese, functions in Thai, variables in English
• 3D software renderer — vector geometry (vtex_*) and pixel textures (tex_*)
• 4D spatial audio — pentatonic synthesis with positional mixing
• FFT analysis — frequency bands from any audio source
• Cross-platform — native Windows/macOS/Linux and WebGL2 WASM

Crates

Quick navigation

• Syntax reference
• Vector geometry builtins
• Multilingual keyword table
• All builtin aliases

Ling — Showcase

Ling is the omniglot creative-systems language: you write the same program in English, 中文, 日本語, 한국어, or ไทย — keywords, builtins, even file names — and it runs identically. One small native binary gives you a 3D/4D holographic renderer, vector fonts, a UI toolkit, a music studio (decode · BPM/key · GM synth · MIDI · karaoke), spatial audio, post-quantum crypto, and a physics lab — no engine install, no package soup.

# the same program, four ways — all run:
bind start = do { open_window(800, 600)  draw_disc(400.0, 300.0, 120.0)  present() }
绑定 开始 = 做 { 开窗(800.0, 600.0)  画实心圆(400.0, 300.0, 120.0)  显() }
バインド 開始 = 実行 { ウィンドウ開く(800,600)  塗りつぶし円(400,300,120)  表示() }
ผูก เริ่ม = ทำ { เปิดหน้าต่าง(800,600)  วาดวงกลมทึบ(400,300,120)  แสดงผล() }

lingfu normalize <lang> rewrites any Ling project into a single language — so a team can each read the code in their own tongue and commit a normalized form.

What makes Ling unique

• Polyglot by design — five human languages are first-class, not comments or i18n strings. Every keyword and ~hundreds of builtins have native aliases; the lexer/parser accept any mix.
• Batteries welded in — graphics, vector fonts, UI, music, MIDI, spatial audio, crypto, physics and AI tensors ship in the one toolchain. First pixel in ~5 lines.
• 3D and 4D / holographic — a depth-sorted software renderer with a cel/holographic shader, 4D camera projection, and vector-texture primitives (vtex_*).
• Resolution-independent vector fonts — TrueType outlines cached as .ling glyph files and rendered (stroke or fill) crisp in 2D/3D/4D, in every script (灵 · ABC · あ · 가 · ก).
• A real music layer — load WAV/FLAC/OGG/MP3, extract BPM & musical key, synthesize any GM-style instrument from a .ling patch, read MIDI, build rhythm games & karaoke.
• Post-quantum crypto built in — hashes, AEAD, signatures, ML-KEM/X25519 hybrids, Shamir, Schnorr/VRF — usable from a script in one call.
• Physics from a script — rigid + angular dynamics, deformable soft-body meshes, and a fast immiscible water/oil liquid sim that maps onto plane/sphere/cylinder/cone/dome.
• Tiny & native — one binary, software-rendered (no GPU driver required), runs headless for CI frame-capture; also targets WASM.

How Ling compares

Legend: ● built-in · ◐ partial / via add-on · ○ not a goal.

Comparisons are about what ships in the box. Mature engines like Unity/Godot/Bevy have far deeper 3D pipelines, tooling and ecosystems — Ling’s angle is breadth-in-one-binary plus the things no one else has: truly multilingual source, 4D/holographic vector rendering, built-in music analysis + GM synth, and post-quantum crypto.

See it run

cargo run --bin ling -- examples/physics/liquid_marble.ling

See the full reference (in 5 languages) at https://docs.ling-lang.org.

Installation

From crates.io

cargo install ling-lang

From source

git clone https://github.com/taellinglin/ling
cd ling
cargo build --release
# binary at target/release/ling

Requirements

• Rust 1.75+
• On Linux: libasound2-dev (for audio)
• On macOS/Windows: no extra dependencies

Run a script

ling examples/basics/thai_hello_world.ling

Hello World

Ling supports any Unicode identifier. All built-in keywords work in every supported language simultaneously in the same source file.

English

bind start = do {
    print("Hello, World!")
}

Chinese 中文

令 启 = 执 {
    印("你好，世界！")
}

Thai ภาษาไทย

ผูก เริ่ม = ทำ {
    พิมพ์("สวัสดีชาวโลก")
}

Korean 한국어

바인드 시작 = 실행 {
    print("안녕하세요, 세계!")
}

Mixed (all valid simultaneously)

令 启 = 执 {
    若 true {
        印("Hello from 中文!")
    }
    bind x = 42
    println(x)
}

Your First 3D Room

A minimal windowed scene with a floor grid and a spinning chakra mandala.

令 PI = 3.14159265

令 启 = 执 {
    open_fullscreen("My First Room")
    set_ambient(0.15)

    令 帧 = 0

    循 window_is_open() {
        fill(0, 0, 8)           # deep-blue background

        令 ry = 帧 * 0.0006
        set_camera(cos(ry), sin(ry), 1.0, 0.0)
        set_camera_pos(sin(ry) * 6.0, 1.0, cos(ry) * 6.0)
        set_zdist(2.0)

        # Floor grid
        vtex_grid(0, -3, 0,  1,0,0,  0,0,1,  8, 8,  1.0, 1.0,  帧*0.0001, 1.57)

        # Spinning mandala
        vtex_chakra(0, 0, 0,  1,0,0,  0,1,0,  2.5, 8,  帧*0.0005, 3.50)
        vtex_lotus( 0, 0, 0,  1,0,0,  0,1,0,  0.6, 2.2, 8,  帧*0.0004, 2.10)

        display()
        令 帧 = 帧 + 1
    }
}

Save as room.ling and run:

ling room.ling

Press Escape or close the window to exit.

Syntax Reference

Ling is an expression-oriented language with a clean, minimal syntax. Every keyword below has equivalents in all supported lexicons — see Keyword Aliases for the full table.

Binding (variable declaration)

令 x = 42
令 name = "Ling"
令 flag = true

Re-binding shadows the previous binding in the same scope:

令 i = 0
令 i = i + 1   # i is now 1

Functions

函 add(a, b) {
    返 a + b
}

Functions are values and can be stored in bindings:

令 square = 函 (n) { 返 n * n }
令 result = square(7)   # 49

Do blocks (执)

A 执 block evaluates all statements and returns the value of the last one. The entry point of every Ling program is 令 启 = 执 { ... }.

令 启 = 执 {
    令 x = 10
    令 y = 20
    印(x + y)
}

Conditionals

若 x > 0 {
    印("positive")
}

若 x > 0 {
    印("positive")
} 否则 {
    印("non-positive")
}

While loops

令 i = 0
循 i < 10 {
    印(i)
    令 i = i + 1
}

Note: Ling has no unary minus operator. Write 0 - x instead of -x.

Lists

令 lst = list_new()
令 lst = list_push(lst, 42)
令 lst = list_push(lst, "hello")
令 n   = list_len(lst)         # 2
令 v   = list_get(lst, 0)      # 42

Comments

# This is a comment
令 x = 1   # inline comment

Arithmetic and comparison

令 sum  = a + b
令 diff = a - b
令 prod = a * b
令 quot = a / b
令 rem  = a % b
令 eq   = a == b
令 neq  = a != b
令 lt   = a < b
令 lte  = a <= b
令 gt   = a > b
令 gte  = a >= b

Built-in math functions

sin(x)   cos(x)   tan(x)
asin(x)  acos(x)  atan2(y, x)
sqrt(x)  abs(x)   floor(x)   ceil(x)
log(x)   exp(x)   pow(x, y)

Core Builtins Reference

All builtins support multilingual names — see Builtin Aliases for the full international lookup table.

Every alias listed in the 5-language tables below is accepted by the interpreter, the lexer/parser, and the lingfu normalize command, so an English program normalized to any of these languages runs unchanged. The interpreter accepts the union of every alias, so you can mix languages in one file.

Output · Core

Math

All math args and results are f64. Angles are in radians.

Cells marked — have no native alias in that language yet (English still works everywhere). Filling these is tracked in TODO.md.

Lists

Strings

Type checks

Window & display

See Window & Camera reference.

Vector geometry

See vtex reference.

Pixel textures

See tex reference.

Audio

See Audio reference.

Cryptography & Physics

ling-crypto (Blake3, SHA-3, AES-GCM-256, XChaCha20, Ed25519, X25519, Shamir, Schnorr, VRF …) and ling-physics (vectors, rigid bodies, forces, hyperbolic geometry) are exposed as Rust crate APIs, not yet as .ling builtins — call them from Rust, or via a host that embeds the interpreter. Coverage is verified by the crate test suites (crates/ling-crypto/tests, crates/ling-physics/tests). Wiring them in as multilingual builtins is tracked in TODO.md.

FFT (native only, no-op on WASM)

3-D Primitive Shapes

The shape builtins are Ling’s “Inkscape for 3-D” — a library of parametric solids (boxes, spheres, dice, cogs, gyros…) that render as lit filled triangles, wireframe, or both. Every shape shares one uniform call signature, so once you know one you know them all.

name(cx,cy,cz,  sx,sy,sz,  rx,ry,rz,  mode,  e0, e1, e2)

The current pen colour (set_color / สีดินสอ / 设色 …) drives both the fill lighting (cel-shaded against the active lights) and the wireframe colour. Shapes are depth-sorted with the rest of the scene and flushed on present().

Camera note: like all 3-D draws, shapes are projected through the camera set with set_camera(...). Keep the camera at the origin and place shapes in front at positive Z (the same convention the room demos use).

Quick start

bind start = do {
    open_fullscreen("shapes")
    set_ambient(0.25)
    add_light(4, 4, 8, 4.0, 255, 240, 220)

    bind FR = 0
    while window_is_open() {
        fill(4, 5, 12)
        set_camera(1, 0, 1, 0)
        bind a = FR * 0.02

        set_color(230, 120, 90)
        cube(-2, 0, 9,  0.8,0.8,0.8,  a, a*0.7, 0,  0)        # filled cube

        set_color(120, 200, 255)
        icosahedron(0, 0, 9,  0.9,0.9,0.9,  a, a, 0,  2)      # d20, fill+wire

        set_color(190, 190, 200)
        gear(2, 0, 9,  0.8,0.3,0.8,  1.57, a*2, 0,  0,  14, 0.3)  # spinning cog

        present()
        bind FR = FR + 1
    }
}

Draw modes

Rendering & lighting modes (holographic cel)

Shape fills use an anime / holographic cel model by default: surfaces are lit with smooth (averaged) vertex normals, the lit colour is interpolated across each triangle, then posterised per pixel into crisp luminance bands. The result is smooth shading with no faceted triangle edges, but clean toon bands that curve over the surface — plus coloured lights, coloured shadows, and a Fresnel rim glow.

set_shade_mode(2)            # holographic cel (default)
set_cel_bands(4)             # 4 bands
set_shadow_color(28,36,90)   # cool indigo shadows
set_rim(0.7, 120,220,255)    # cyan holographic edge

• Mode 0 (flat): legacy per-face cel — every triangle one flat band (faceted).
• Mode 1 (cel): smooth bands, no rim/sheen — clean toon.
• Mode 2 (holo): smooth bands + Fresnel rim + a subtle normal-gradient sheen.

Lighting comes from add_light(x,y,z, intensity, r,g,b) (each light contributes its own colour) and set_ambient(level). The lighting math lives in the ling-graphics crate (ling_graphics::shading).

Round & swept solids

cube · box — 立方体 · 方块 · 정육면체 · ลูกบาศก์ (box: 方块/箱/상자/กล่อง)

Axis-aligned box. Non-uniform sx,sy,sz make any rectangular block.

cube(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode)

sphere — 球体 · 球 · 구 · ทรงกลม

UV sphere. Scale axes independently for an ellipsoid.

sphere(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  segments=16, rings=12)

icosphere — 二十面球 · アイコ球 · 아이코구체 · ทรงกลมเหลี่ยม

Geodesic sphere from a subdivided icosahedron (more even than a UV sphere).

icosphere(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  subdivisions=1)   # 0..4

dome — 穹顶 · ドーム · 돔 · โดม

Hemisphere with a closing base — useful for cupolas and skies.

dome(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  segments=24, rings=8)

cylinder — 圆柱 · 円柱 · 원기둥 · ทรงกระบอก

Capped tube (height runs along local Y, scaled by sy).

cylinder(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  segments=24)

cone — 圆锥 · 円錐 · 원뿔 · กรวย

Capped cone, apex at +Y.

cone(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  segments=24)

capsule — 胶囊 · カプセル · 캡슐 · แคปซูล

Cylinder with hemispherical caps (a “pill”).

capsule(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  segments=16, rings=6)

torus · ring — 圆环 · トーラス · 토러스 · ทอรัส

Donut. tube is the tube radius as a fraction of the outer radius.

torus(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  segments=32, sides=12, tube=0.35)

Prisms & pyramids

pyramid — 金字塔 · ピラミッド · 피라미드 · พีระมิด

N-sided pyramid. sides=4 is the classic square pyramid.

pyramid(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  sides=4)

prism — 棱柱 · 角柱 · 각기둥 · ปริซึม

N-sided prism (extruded polygon). sides=3 → triangular prism, 6 → hex column.

prism(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  sides=6)

frustum — 棱台 · 錐台 · 원뿔대 · กรวยตัด

Truncated cone/pyramid. top_ratio is the top radius as a fraction of the base (0 → cone, 1 → cylinder).

frustum(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  sides=24, top_ratio=0.5)

Dice (Platonic solids)

Perfect for dice, gems, and crystal shapes — all take no extra params.

icosahedron(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode)
d20(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode)          # same thing

Mechanical & architectural

gear · cog — 齿轮 · 歯車 · 톱니바퀴 · เฟือง

Extruded spur gear in the XZ plane. teeth count and tooth depth are configurable; thickness comes from sy.

gear(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  teeth=12, tooth=0.25)

gyro — 陀螺 · ジャイロ · 자이로 · ไจโร

Nested gimbal: rings concentric tori on alternating axes — a gyroscope / armillary.

gyro(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  rings=3)

arch — 拱门 · アーチ · 아치 · ซุ้มโค้ง

Semicircular archway (tube swept over 180°).

arch(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  segments=24, tube=0.18)

stairs — 楼梯 · 階段 · 계단 · บันได

Staircase of steps cuboid steps rising along +Y/+Z.

stairs(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  steps=5)

Curves & surfaces

helix — 螺旋线 · らせん · 나선 · เกลียว

Tube swept along a helix around Y.

helix(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  turns=3, tube=0.15, sides=8)

spring — 弹簧 · ばね · 스프링 · สปริง

A tighter, thinner helix (coil). Same params as helix.

spring(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  turns=6, tube=0.12, sides=8)

star_prism · star — 星柱 · 별기둥 · แท่งดาว

An N-point star cross-section extruded along Y.

star_prism(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  points=5, inner_ratio=0.5)

capsule_chain · chain — 胶囊链 · カプセル鎖 · 캡슐체인 · โซ่แคปซูล

A row of count capsule beads along X — a chain / caterpillar.

capsule_chain(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  count=3)

mobius — 莫比乌斯 · メビウス · 뫼비우스 · เมอบีอุส

A half-twisted Möbius band.

mobius(cx,cy,cz, sx,sy,sz, rx,ry,rz, mode,  segments=60, width=0.3)

Tips

• Flat disc / plate: cylinder with a small sy (e.g. 0.05).
• Ellipsoid: sphere with unequal sx,sy,sz.
• Obelisk: frustum with a small top_ratio and tall sy.
• Animate by feeding the frame counter into rx,ry,rz each frame.
• Outlined solid: use mode = 2 and a bright pen colour for a crisp cel-look with ink edges.

All shape names are available in every Ling language; see Builtin Aliases by Language.

Vector Geometry Builtins (vtex_*)

All vtex_* functions draw line-based 3D geometry onto a plane defined by:

• Centre (cx, cy, cz) — world-space anchor point
• U tangent (ux, uy, uz) — “right” direction in the plane
• V tangent (vx, vy, vz) — “up” direction in the plane

Lines are depth-sorted and drawn on top of the pixel buffer when present() / แสดงผล() / 显() / 表示() / 표시() is called.

Performance tip: vtex calls are fast (pure line rasterisation). Prefer them over tex_* for real-time use — a tex_mandelbrot on a 1920×1080 window is ~2 million pixel ops per call; a vtex_rings with 32 segments is ~32 line ops.

Common plane orientations

# Horizontal plane (floor / ceiling): U=right, V=forward
1,0,0,  0,0,1

# Vertical front-facing plane (wall / mandala disc): U=right, V=up
1,0,0,  0,1,0

# Vertical side-facing plane (left/right wall): U=forward, V=up
0,0,1,  0,1,0

Primitives

vtex_grid · ลายตาราง · 纹格 · 格子模様 · 격자무늬

Rectilinear grid.

vtex_grid(cx,cy,cz, ux,uy,uz, vx,vy,vz,  cols, rows, cell_w, cell_h,  fr, hue)

vtex_rings · ลายวงซ้อน · 纹环 · 同心円 · 동심원

Concentric N-sided polygon rings with optional twist.

vtex_rings(cx,cy,cz, ux,uy,uz, vx,vy,vz,  n_rings, n_sides, max_r, twist,  fr, hue)

vtex_star · ลายดาว · 纹星 · 星模様 · 별무늬

Alternating outer/inner star polygon.

vtex_star(cx,cy,cz, ux,uy,uz, vx,vy,vz,  n_points, r_outer, r_inner, rot_speed,  fr, hue)

vtex_spiral · ลายเกลียว · 纹螺 · 螺旋 · 나선

Archimedean spiral.

vtex_spiral(cx,cy,cz, ux,uy,uz, vx,vy,vz,  n_turns, max_r, n_steps,  fr, hue)

vtex_flower · ลายดอก · 纹花 · 花模様 · 꽃무늬

Flower of Life: centre circle plus 6 surrounding circles.

vtex_flower(cx,cy,cz, ux,uy,uz, vx,vy,vz,  radius, n_sides,  fr, hue)

vtex_lotus · ลายดอกบัว · 纹莲 · 蓮模様 · 연꽃무늬

Radial kite-petal lotus.

vtex_lotus(cx,cy,cz, ux,uy,uz, vx,vy,vz,  r_inner, r_outer, n_petals,  fr, hue)

vtex_chakra · ลายจักร · 纹轮 · 輪模様 · 바퀴무늬

Dhamma wheel: outer rim + inner hub + N spokes + tick marks.

vtex_chakra(cx,cy,cz, ux,uy,uz, vx,vy,vz,  r, n_spokes,  fr, hue)

vtex_yantra · ลายยันต์ · 纹咒 · 護符模様 · 부적무늬

Nested interlocked triangle pairs (Sri Yantra style) with bhupura gate square.

vtex_yantra(cx,cy,cz, ux,uy,uz, vx,vy,vz,  n_layers, max_r,  fr, hue)

vtex_spiked_cog · ฟันเฟืองหนาม · 纹棘轮 · 歯車模様 · 톱니바퀴

Mechanical gear with triangular spike teeth, inner body ring, hub, and spokes.

vtex_spiked_cog(cx,cy,cz, ux,uy,uz, vx,vy,vz,
                n_teeth, r_body, r_spike, r_hub, n_spokes,
                fr, hue)

# Example: ornate gold dharma gear
vtex_spiked_cog(0, 0, 8,  1,0,0,  0,1,0,  18, 1.6, 2.0, 0.28, 9,  FR * 0.0004, 1.57)

vtex_torii · ประตูโทริอิ · 纹鸟居 · 鳥居 · 도리이

Japanese torii gate silhouette: two pillars, straight nuki crossbar, curved kasagi top beam.

vtex_torii(cx,cy,cz, ux,uy,uz, vx,vy,vz,  width, height,  fr, hue)

# Gate on the far wall, crimson
vtex_torii(0, 0, 16,  1,0,0,  0,1,0,  6.0, 5.0,  FR * 0.0001, 2.1)

vtex_pagoda · เจดีย์ · 纹塔 · 塔 · 탑

Multi-tiered pagoda silhouette with upturned eaves and spire finial.

vtex_pagoda(cx,cy,cz, ux,uy,uz, vx,vy,vz,
            n_tiers, base_w, tier_h, taper, eave_out,
            fr, hue)

# 5-tier gold pagoda on back wall
vtex_pagoda(0, 0, 16,  1,0,0,  0,1,0,  5, 2.2, 1.0, 0.72, 0.28,  FR * 0.0001, 1.57)

vtex_halftone · ลายจุด · 纹半调 · 網点模様 · 망점

Cross-hatch dithered fill.

vtex_halftone(cx,cy,cz, ux,uy,uz, vx,vy,vz,  cols, rows, cell_w, cell_h, density,  fr, hue)

vtex_tessellated · ลายตาข่าย · 纹镶嵌 · 網目模様 · 격자망

Animated triangle mesh fill (sine-displaced vertices).

vtex_tessellated(cx,cy,cz, ux,uy,uz, vx,vy,vz,  cols, rows, cell, amplitude, freq,  fr, hue)

vtex_hyperbolic_uv · ลายไฮเพอร์โบลิก · 纹曲面 · 双曲線 · 쌍곡선

Poincaré-disc hyperbolic tiling (concentric circles + geodesic rays).

vtex_hyperbolic_uv(cx,cy,cz, ux,uy,uz, vx,vy,vz,  max_r, n_circles, n_rays,  fr, hue)

vtex_letter_rain · ลายอักษรไหล · 纹字雨 · 文字雨 · 글자비

Falling-glyph rain (Matrix-style, using simplified stroke glyphs).

vtex_letter_rain(cx,cy,cz, ux,uy,uz, vx,vy,vz,  n_cols, n_visible, col_w, row_h, speed,  fr, hue)

Colour system

All vtex functions use the cycle(phase) colour formula:

R = sin(phase)         * 127 + 128
G = sin(phase + 2.094) * 127 + 128   # 120° offset
B = sin(phase + 4.189) * 127 + 128   # 240° offset

Useful hue anchor values for cultural palettes:

Pixel Texture Builtins (tex_*)

tex_* functions write RGBA pixels directly to the framebuffer before the depth queue is flushed. They are drawn underneath all vtex_* geometry.

Performance warning: Each tex_* call iterates over every pixel in the destination rectangle. A full-screen 1920×1080 call costs ~2 million iterations. For smooth 60fps, keep tex_* calls to a small off-centre region or reduce window resolution.

All functions share the signature prefix:

tex_*(dst_x, dst_y, width, height,  ...params,  palette)

Palette names: "rainbow" · "fire" · "ocean" · "psychedelic" · "neon" · "forest"

tex_checkerboard · ลายตารางหมากรุก

tex_checkerboard(x, y, w, h,  tiles,  r1,g1,b1,  r2,g2,b2)

Two-colour checker pattern. tiles = number of tiles across the width.

tex_gradient · ลายไล่สี

tex_gradient(x, y, w, h,  angle_deg,  r1,g1,b1,  r2,g2,b2)

Linear gradient at angle_deg degrees.

tex_noise · ลายนอยส์

tex_noise(x, y, w, h,  scale, octaves, seed, palette)

Fractal Brownian Motion noise.

tex_mandelbrot · ลายแมนเดลบรอต

tex_mandelbrot(x, y, w, h,  zoom, cx, cy, max_iter, palette)

tex_julia · ลายจูเลีย

tex_julia(x, y, w, h,  c_re, c_im, max_iter, palette)

Julia set with complex parameter c = c_re + i·c_im.

tex_voronoi · ลายโวโรนอย

tex_voronoi(x, y, w, h,  cells, seed, palette)

tex_ripple · ลายระลอก

tex_ripple(x, y, w, h,  freq, cx, cy, time, palette)

Concentric ripple emanating from (cx, cy) in normalised [0,1] coords.

tex_spiral · ลายเกลียวหมุน

tex_spiral(x, y, w, h,  freq, n_bands, time, palette)

tex_halftone · ลายฮาล์ฟโทน

tex_halftone(x, y, w, h,  dot_size, time, palette)

tex_freq_map · ลายความถี่

tex_freq_map(x, y, w, h,  time, speed, palette)

Audio-reactive frequency bar display. Reads from the last fft_bands() call. Call fft_push(samples) then fft_bands(n) each frame to keep it animated.

Palette reference

Audio Builtins

Audio builtins are available on native targets. On WASM they are no-ops.

Every builtin below is callable in all five languages — the aliases are accepted by the interpreter and produced by lingfu normalize.

Multilingual names

Tone synthesis

# audio_tone(slot, x, y, z, w,  freq_hz, amplitude, lfo_rate, lfo_depth)
audio_tone(0,  0.0, 0.0, 8.0,  1.5,   261.63, 0.08, 0.10, 0.008)

Volume

audio_volume(0.5)         # master volume
audio_bgm_volume(0.4)     # background music volume

Background music

audio_bgm("path/to/file.wav", 0.5)   # load and play WAV BGM

Listener position

# Must be called each frame to update 3D audio perspective
audio_listener(cos(ry), sin(ry), cos(rx), sin(rx))

Pentatonic reference

Common frequencies for East Asian pentatonic scales:

FFT analysis

# Push mono samples to the rolling FFT window
令 smp = list_new()
令 k = 0
循 k < 64 {
    令 smp = list_push(smp, sin(k * 0.1))
    令 k = k + 1
}
fft_push(smp)

# Get 32 log-spaced frequency bands (values 0..1)
令 bands = fft_bands(32)

# Beat detection
若 fft_beat() {
    印("beat!")
}
令 ratio = fft_beat_ratio()   # 1.0 = at threshold
令 rms   = fft_rms()
令 freq  = fft_dominant_freq()

Builtins — Music & Spatial Audio

ling-music is a full music layer (separate from the SFX-oriented ling-audio): decode any common format, analyse tempo & key, synthesize GM-style instruments from .ling patches, read MIDI, and build rhythm games & karaoke. ling-audio adds positional one-shots, sample playback/loops, and master FX.

Playback & analysis

music_load("song.wav") → id (WAV/FLAC/OGG/MP3/AAC) · music_play(id) / music_pause / music_stop / music_seek(sec) / music_pos() / music_volume(v) / music_duration(id) · music_bpm(id) · music_key(id) → e.g. "A minor" · music_onsets(id) · music_beat_grid(id) · music_fft(id, nbands) → spectrum at the current position (drives reactive visuals).

Synthesis (GM-capable, from .ling patches)

music_patch("instruments/rhodes_ep.ling") → inst · music_note(inst, "C4", dur, vel) · music_note_on(inst, pitch, vel) / music_note_off(inst, pitch). A patch is a small modular FM/subtractive voice (operators + ADSR + filter + LFO) able to approximate any GM family.

MIDI · rhythm · karaoke

music_midi_load("song.mid") → id · music_midi_notes(id) → [time,midi,…] · music_midi_bars(id) → [time,midi,dur,…] (karaoke note bars) · music_midi_count(id). music_judge(delta_ms) → grade · music_grade_name(g). music_lrc("song.lrc") / music_lyric(id,t). music_mic_pitch() → Hz (sung pitch) · music_note_name(hz) · music_hz(midi) · music_pitch_score(hz, target_hz).

Spatial audio (ling-audio)

audio_tone(idx,x,y,z,w,freq,amp,lfo_rate,lfo_depth) (continuous, 3D/4D) · audio_sfx(x,y,z,w,freq,amp,dur,wave) (positional one-shot) · audio_sample_load(path) / audio_sample_play(id,x,y,z,w,vol,loop) / audio_sample_stop(v) · audio_listener(cry,sry,crx,srx) (match the camera) · audio_volume(v) · master FX: audio_fx_delay(time,fb,mix) · audio_fx_reverb(mix) · audio_fx_lowpass(cutoff) (1.0 = open, lower = muffled/underwater).

See examples/music/{synth_jam,rhythm_game,karaoke_hero,hallway_runner}.ling. Full implemented-vs-missing list: docs/AUDIO_MUSIC_TODO.md.

Builtins — Vector Fonts

Ling renders real TrueType/OpenType fonts as resolution-independent vectors. The first time a glyph is used its outline is extracted and cached as cache/fonts/<font>/<codepoint>.ling (curves preserved), then rendered crisp — stroked or filled, with anti-aliasing — at any size and in 2D or 3D/4D.

Any script is covered: Latin, 中文, 日本語, 한국어, ไทย all render from the right font (e.g. Noto Sans SC covers Latin + CJK + Thai).

bind f = font_load("assets/fonts/Exo2.ttf", 600.0)
set_color(0, 230, 255)
font_text_fill(f, 40.0, 30.0, 36.0, "LING 灵")
font_text_3d(f, 0.0,0.0,0.0,  1.0,0.0,0.0,  0.0,-1.0,0.0, 0.6, "3D TEXT")

Related: project_3d(x,y,z) → [sx,sy,depth] and draw_poly([x0,y0,…]) (filled 2-D polygon, blend-aware) let you place filled vector shapes onto projected 3-D points.

Builtins — UI Toolkit

A vector, theme-coloured immediate-mode widget library (HUD, meters, interface controls, game UI, plus a few faux-3D widgets). All widgets are drawn each frame; interactive ones read the mouse and return their state. Set the palette once with ui_theme; every widget takes an optional trailing r,g,b to override its main colour.

ui_theme(0,210,255,  60,255,180,  40,60,95,  255,90,90,  190,235,255,  10,16,24)

HUD / sci-fi overlays

ui_radar(cx,cy,r,sweep) · ui_compass(x,y,w,h,heading) · ui_reticle(cx,cy,r,spread) · ui_target(x,y,w,h,lock) · ui_panel(x,y,w,h,bevel) · ui_scanlines(x,y,w,h,density)

Meters & gauges

ui_bar(x,y,w,h,value,max) · ui_segbar(…,segs) · ui_gauge(cx,cy,r,value,max) · ui_ring(cx,cy,r,value,max) · ui_vu(x,y,w,h,levels_list) · ui_spark(x,y,w,h,values_list) · ui_battery(x,y,w,h,value,max)

Interface controls (interactive — return state)

ui_button(x,y,w,h) → 1 when clicked · ui_toggle(x,y,w,h,state) → new state · ui_slider(x,y,w,value,min,max) → new value · ui_checkbox(x,y,size,checked) → new checked · ui_tabs(x,y,w,h,count,active) → active index · ui_progress(x,y,w,h,frac) · ui_tooltip(x,y,w,h) · ui_stepper(x,y,w,h,value,step) → new value

Game UI

ui_healthbar(x,y,w,h,hp,max,pulse) · ui_cooldown(cx,cy,r,frac) · ui_counter(x,y,dw,dh,value,digits) (7-segment) · ui_minimap(x,y,w,h) · ui_dpad(cx,cy,r) → direction · ui_slotgrid(x,y,cols,rows,cell,sel) · ui_vignette(intensity, r,g,b)

Faux-3D in 2D space

ui_gauge3d(cx,cy,r,value,spin) · ui_panel3d(x,y,w,h,depth) · ui_radar3d(cx,cy,r,tilt,sweep)

Interface sounds

ui_sound("click"|"hover"|"confirm"|"error"|"toggle"|"tick") · audio_blip(freq,dur,wave,amp)

See examples/ui/hud_showcase.ling.

Builtins — Physics

Ling exposes the ling-physics engine to scripts: rigid bodies with angular dynamics, deformable soft bodies, and a fast 2-D immiscible liquid simulation that maps onto 3-D surfaces. Every builtin has aliases in all five languages (see Builtin Aliases by Language).

Coordinate note: in the renderer +y points down, so “gravity” is a positive y value.

Soft bodies (deformable / bouncy)

A spring-mass sphere that squashes and stretches on impact.

bind ball = soft_ball(0.0, 0.0-2.5, 0.0, 1.2)
while window_is_open() {
    soft_step(ball, 0.016, 9.0)
    soft_contain(ball, 0.0-4.0,0.0-4.0,0.0-4.0, 4.0,4.0,4.0, 0.55)
    bind ns = soft_nodes(ball)            # draw the squashing mesh
    # … render nodes …
}

See examples/physics/bouncy_ball.ling.

Rigid bodies + angular dynamics

A shared rigid-body world with torque, spin, inertia and a spin-inducing floor bounce, so bodies tumble and roll.

See examples/physics/tumbling.ling (cubes rotated by rb_rot).

Liquid simulation (water + oil)

Two immiscible density fields advected by one incompressible velocity grid. The fluids only blend at their interface, so the physics decides where the blue (water) and amber (oil) colours mix. Built for speed; wrap makes it seamless for mapping onto curved surfaces.

bind liq = liquid_new(84.0, 84.0)
liquid_splat(liq, 42.0, 25.0, 1.0, 1.0, 3.0)   # oil
liquid_splat(liq, 42.0, 58.0, 0.0, 1.0, 3.0)   # water
while window_is_open() {
    liquid_gravity(liq, sin(time_now())*55.0, cos(time_now())*55.0)
    liquid_step(liq, 0.016)
    set_camera(cos(time_now()*0.3), sin(time_now()*0.3), cos(0.4), sin(0.4))
    liquid_draw_surface(liq, 1.0, 0.0,0.0,0.0, 2.2, 3.2)   # onto a sphere
    present()
}

See examples/physics/liquid_marble.ling.

Builtins — Animation (Anima)

Anima is Ling’s unified animation system (the ling-animation crate). Its guiding idea: one rig, any target, any temperament. Every animated thing — a 2-D vtexture, a 3-D mesh, a particle field, or a bag of scalar parameters — is a rig of abstract joints, driven by composable drivers, and deformed onto its target by a binding.

What makes Anima different is the temperament axis: a per-chain scalar from organic (灵) to mechanical (机) that selects and cross-fades the solver — muscle, breath, jiggle, and IK on one end; exact gear, cam, and linkage coupling on the other. A robot can have organic hydraulic sag; a creature can have a mechanical jaw.

The scalar drivers below are available today as builtins. They are pure functions — call them every frame with the current time (and any state you keep) to drive a scale, a position, a rotation, or a vtex parameter. Each is available in all five languages.

Organic drivers (灵)

Easing curve names (for tween_ease)

linear, step, quad_in/out/in_out, cubic_in/out/in_out (smooth), sine_in/out/in_out, expo_in/out/in_out, elastic_in/out (elastic), back_in/out/in_out (overshoot), bounce_in/out (bounce).

Mechanical drivers (机)

Multilingual names

(The full table lives in lexicons/*.ling and lingfu normalize’s BUILTINS_ANIM.)

Example — a breathing, walking, geared scene

bind start = do {
    open_window("Anima")
    bind t = 0.0
    while window_is_open() {
        bind t = t + delta_time()
        fill(10, 12, 24)

        // organic 灵 — a body that breathes and a foot that walks
        bind chest = breathe(t, 0.4, 0.08)      // ~1.0 ± 0.08
        bind foot  = gait_swing(t, 1.6, 30.0)   // leg swing in pixels

        // mechanical 机 — a gear train driven by a turning shaft
        bind shaft = t * 2.0
        bind gears = gear_train(shaft, [12, 36, 12])

        present()
    }
}

For Rust authors — the crate (ling-animation)

The builtins above are the scalar layer. The crate also exposes the structural core that the runtime rig/skin builtins will build on:

• ease — EaseFunction, Lerp, tween_ease.
• track — Keyframe, Track, Timeline.
• rig — Rig, Joint, Pose, world-pose + skinning matrices.
• temperament — the Temperament (灵 ↔ 机) axis with blend, liveliness, rigidity.
• scalar — the per-frame driver math used by the builtins.
• mechanism — exact linkages (gear_train, four_bar).
• creature — procedural biped_legs, quadruped_legs, breathing_scale.

Not yet wired (roadmap)

The full rig pipeline is staged. Still to land as builtins:

• rig_load (glTF skin import), rig_joint, pose/anim_clip/anim_play/anim_tick.
• SkinBinding (3-D linear-blend skinning over a mesh), WarpBinding (2-D vtex control lattice), ParamBinding (drive vtex parameters / blendshapes).
• The driver motion graph (masked, weighted blending of clip + procedural + physics).
• GPU skinning (via ling-gpu) and driver-state snapshotting (via ling-net).

Builtins — Dialog

Cinematic, Ocarina/Majora-style dialog boxes (from ling-game): text typed out letter-by-letter, paged, auto-advancing, with colour-coded highlighting and a font of your choice. Pure-logic in ling-game; the runtime renders it.

Markup: {n}…{/} name/character · {p}…{/} place · {i}…{/} item · \n newline · || page break.

mic_open()
bind ui = font_load("assets/fonts/Exo2.ttf", 600.0)
bind line = "Hey {n}Link{/}! Take the {i}Master Sword{/} to {p}Hyrule{/} field.||Beware the night."
while window_is_open() {
    if key_pressed("space") { if dialog_active() { dialog_advance() } else { dialog_show(line, 34.0) } }
    if dialog_active() {
        dialog_step(0.016)               # world suspended while talking
        dialog_draw(50.0, 420.0, 800.0, 150.0, ui)
    } else {
        # … normal game update …
    }
    present()
}

See examples/ui/dialog_demo.ling.

Asset Conversion — ling convert

Transcode an external asset into a self-contained, importable .ling file that reconstructs it with the engine’s own builtins — preserving geometry, names, and structure. Bulk numeric data is embedded losslessly: deflate-compressed + base64 behind the blob_f32 / blob_i32 builtins by default, or plain .ling arrays with --no-compression.

ling convert model.glb                 # → model.ling   (compressed, lossless)
ling convert sfx.wav -o sfx.ling       # explicit output
ling convert logo.svg --no-compression # plain arrays (human-readable / diff-able)
lingfu convert song.mid                # lingfu forwards to ling

Flags: -o <out.ling> (default <asset>.ling) · --no-compression.

Using a converted file

ใช้ "model.ling"            # use / import the generated module
bind start = do {
    open_window(1280, 720)
    while window_is_open() {
        set_color(180, 220, 255)
        draw_<name>(0.0, 0.0, 0.0, 1.0)   # the generated draw fn
        flush_3d()
        present()
    }
}

The blob builtins decode the embedded data on import:

• blob_f32("…") → list of numbers (little-endian f32, deflate+base64).
• blob_i32("…") → list of numbers (little-endian i32) — mesh/polyline indices.

Both are lossless; --no-compression simply emits the same numbers as a literal [ … ] list instead of a blob, which is larger but human-readable.

Window & Camera Builtins

Every builtin below is callable in all five languages — the aliases listed are accepted by the interpreter and produced by lingfu normalize, so a program written (or normalized) in any language runs unchanged.

Window · 2-D drawing

See also draw_circle / draw_disc / set_blend (procedural set).

Input

Camera

Lighting

# Orient camera by yaw (ry) and pitch (rx) angles
set_camera(cos(ry), sin(ry), cos(rx), sin(rx))
set_camera_pos(x, y, z)
set_zdist(d)

Camera

# Orient camera by yaw (ry) and pitch (rx) angles
set_camera(cos(ry), sin(ry), cos(rx), sin(rx))

# Position camera in world space
set_camera_pos(x, y, z)

# Set near-plane distance (default 2.0)
set_zdist(d)

Lighting

# Remove all lights
clear_lights()

# Add a point light
# add_light(x, y, z,  r, g, b,  intensity, radius)
add_light(0, 4, 8,  1.0, 0.85, 0.3,  2.5, 16.0)

# Ambient level (0.0–1.0)
set_ambient(0.1)

Pen colour (for 2D drawing)

# Set pen colour for subsequent 2D draws
สีดินสอ(r, g, b)   # or: pen_color(r,g,b)

Typical main loop structure

令 启 = 执 {
    เปิดหน้าต่างเต็มจอ("My Scene")
    capture_mouse()
    set_ambient(0.10)

    令 帧 = 0
    循 หน้าต่างเปิดอยู่() {
        เติม(0, 0, 0)          # clear to black

        # update camera
        set_camera(cos(ry), sin(ry), cos(rx), sin(rx))
        set_camera_pos(cx, cy, cz)
        set_zdist(2.0)

        # draw geometry
        clear_lights()
        add_light(...)
        vtex_grid(...)
        vtex_rings(...)

        แสดงผล()               # flush
        令 帧 = 帧 + 1
    }
}

Glossary

A language-switchable reference for every Ling keyword, type, literal and builtin. Pick a language from the selector in the top bar — the tables and the sidebar switch to show only that language’s spelling.

• 40 keywords · 6 types · 363 builtins across 12 crates.

Builtins by crate

• ling (core runtime) — I/O, math, noise, time, colour helpers and collections — always available.
• ling-graphics — Window, 2-D/3-D drawing, camera, lighting, cel shading, vector textures, surfaces, shadows and SVG export.
• ling-ui — HUD, meters, controls, game UI widgets and vector fonts.
• ling-audio — Tone synthesis, WAV playback, microphone capture, spatial SFX, samples and FX.
• ling-music — Music decode/analysis, GM synth, rhythm grading, karaoke and MIDI.
• ling-physics — Vector maths, forces, soft bodies, rigid + angular bodies and a liquid sim.
• ling-animation — The Anima procedural-animation drivers: tweens, gaits, springs, gears and IK.
• ling-ai — Neural nets, behaviour trees and the dialog LLM.
• ling-crypto — Hashing, AEAD, signatures and the geometric / post-quantum suite.
• ling-input — Gamepad / joystick polling, sticks, triggers and rumble.
• ling-net — HTTP and WebSocket clients.
• ling-dialog — On-screen dialog boxes with typewriter text.

Keywords

Reserved words and their spelling in each language.

Types

Built-in types.

Literals & operators

Literals and operators are spelled the same in every language.

Literals

Operators

ling (core runtime)

I/O, math, noise, time, colour helpers and collections — always available.

I/O

Color helpers

Math

Noise

Color

Time

Collections

ling-graphics

Window, 2-D/3-D drawing, camera, lighting, cel shading, vector textures, surfaces, shadows and SVG export.

Window / graphics

Monitor detection + framerate

Input

3-D

Lighting

Texture patterns (vtex)

SVG export

Blending

Drawing - filled

Surfaces & shadows

2030 compositing: linear-light, OkLab gradients, z-buffer

mode: 0 filled · 1 wireframe · 2 both

render / lighting modes (holographic cel)

3D projection + filled 2D polygons

dialog + liquid rainbow + sparkle

game AI : neural net, behavior tree, dialog LLM

ling-ui

HUD, meters, controls, game UI widgets and vector fonts.

UI toolkit (HUD / meters / controls / game UI) + vector fonts

ling-audio

Tone synthesis, WAV playback, microphone capture, spatial SFX, samples and FX.

Audio

UI toolkit (HUD / meters / controls / game UI) + vector fonts

spatial audio / samples / FX / MIDI

ling-music

Music decode/analysis, GM synth, rhythm grading, karaoke and MIDI.

music toolkit (decode / analysis / GM synth / rhythm / karaoke)

spatial audio / samples / FX / MIDI

ling-physics

Vector maths, forces, soft bodies, rigid + angular bodies and a liquid sim.

Physics - vectors

Physics - forces

physics (soft bodies / rigid+angular / liquid sim)

dialog + liquid rainbow + sparkle

game AI : neural net, behavior tree, dialog LLM

ling-animation

The Anima procedural-animation drivers: tweens, gaits, springs, gears and IK.

Anima animation drivers