Tungsten — Pseudocode that runs. Public preview version 2026.07.04

A Touch of Class

Define a class with +, a method with ->, and output with <<.

Arity after the slash defines anonymous arguments.

Instance variables are assigned in the constructor with @. The ro suffix makes them read-only.

The prime notation (x') refers to the same-named property on the argument: x - x' means "my x minus their x."

Δx compacts it further.

point.w

1+ Point
2  -> new(@x, @y, @z) ro
3
4  -> distance/1
5    dx = x - x'
6    dy = y - y'
7    dz = z - z'
8
9    (dx.sq + dy.sq + dz.sq).sqrt
10
11  # or, if you prefer
12  -> distance/1
13    √(Δx² + Δy² + Δz²)
14
15<< Point(3, 4, 0).distance(Point(0, 0, 0))   # => 5
            

Blocks are Basic

A block is just -> followed by an expression, inside it free vars like item bind in lexical order to block params.

Block passthrough: pass a trailing block to a method that doesn't take one, and the block iterates the method's result. bag.items -> s += item loops over the return value of #items.

blocks.w

1# blocks bind `item` implicitly
2squares = [1, 2, 3].map -> item ** 2
3evens   = (1..10).select -> item % 2 == 0
4
5<< squares        # => [1, 4, 9]
6<< evens.sum      # => 30
7
8# block passthrough: a trailing block on a
9# no-block method iterates its result
10+ Bag
11  -> items
12    [10, 20, 30]
13
14s = 0
15Bag.new.items -> s += item   # s => 60
16
17# even `n.times` is just passthrough on an Int
18u = 0
19(-5).abs -> u += 1   # runs 5 times
            

`case` and `recase` were in a boat

Dispatch with case/when. When an arm needs to re-enter the decision with a new value, recase expr re-dispatches the enclosing case.

Because symbols and small strings are interned at compile time, a case over them compiles to a real LLVM switch.

dispatch.w

1-> classify(n)
2  case n
3  when 0
4    "zero"
5  when 1
6    "one"
7  else
8    recase n % 2   # re-dispatch the case
9
10<< classify(0)    # => zero
11<< classify(7)    # => one
12<< classify(42)   # => zero
            

Generics are Monomorphized

With Complex<f64> the compiler stamps out a specialized class with native f64 arithmetic.

Constraints are declared with with T in (…).

Used for Complex, Quaternion, and larger algebras up to 256 dimensions.

complex.w

1z = Complex<f64>.new([~3.0, ~4.0])
2
3<< z.abs           # => 5
4<< z.arg           # => 0.92729…
5
6# (1+i)(2+3i) = -1+5i — multiply is rotation
7a = Complex<f64>.new([~1.0, ~1.0])
8b = Complex<f64>.new([~2.0, ~3.0])
9p = a * b
10<< p.real          # => -1
11<< p.imag          # => 5
12
13# powers via Hypercomplex#**
14<< (z ** 2).real   # => -7
15
16# and it keeps going: Quaternion<f32>,
17# Octonion, Sedenion … up to 256 dimensions
            

A Kernel of Truth

Annotate a function with @gpu fn and the compiler lowers it to Metal Shading Language while the rest of the file compiles to native code through LLVM.

Types are ascribed with ## f32[] hints. Inside the kernel, gpu.thread_position_in_grid and friends map straight onto Metal's execution model — and simdgroup 8×8 cooperative matrices are available for tiled matmuls.

This example is the project's smoke test: it compiles, dispatches on-device, and reads back [2, 3, 4].

kernel.w

1use core/metal
2
3## f32[]: x
4## f32[]: y
5## i32: n
6@gpu fn add_one(x, y, n)
7  i = gpu.thread_position_in_grid.x ## i32
8  if i < n
9    y[i] = x[i] + ~1.0
10
11# host side — same file
12device   = metal_device()
13pipeline = metal_pipeline(library, "add_one")
14metal_dispatch1(queue, pipeline, input, output, n_buf, 3)
            

Attention, End to End

A Tensor owns one shared allocation with three faces: a CPU array, a Metal buffer, and tensor views when the platform supports them — zero copies between them.

.linear runs bf16 matmuls on the Metal backend; .matmul, views, broadcasting, reductions, and .softmax compose into transformer math. This is the library's capstone test: single-head self-attention, on-device, attention rows summing to 1 within 5×10⁻⁸.

attention.w

1use core/tensor
2device = metal_device()
3
4x  = Tensor.zeros(device, Tensor.bf16, [64, 32])
5wq = Tensor.zeros(device, Tensor.bf16, [32, 32])
6wk = Tensor.zeros(device, Tensor.bf16, [32, 32])
7wv = Tensor.zeros(device, Tensor.bf16, [32, 32])
8
9# Q,K,V projections — Metal backend
10q = x.linear(wq)
11k = x.linear(wk)
12v = x.linear(wv)
13
14# scores = Q·K^T / √d — transpose view is free
15scores = q.matmul(k.transpose).scale(~0.1767767)  # 1/√32
16attn   = scores.softmax(1)
17out    = attn.matmul(v)
18
19# max |row_sum(attn) - 1| = 4.66e-08 -> PASS
            

Floating Point You Can Reason About

Three compile-time math modes: strict, precise (the default), and fast. Precise mode contracts a direct a*b + c into one FMA — but refuses to contract a*b − c*d, so determinants and cross products of equal terms stay exactly zero.

Override the ambient mode lexically with @strictmath / @fastmath blocks, even inside a method body. And fma(a, b, c) guarantees a single-rounding fused multiply-add in every mode.

fma.w

1# precise (default): a*b - c*d never contracts,
2# so this determinant is 0.0 — not 1.19e-16
3det = x1 * y2 - x2 * y1
4
5# scoped overrides — even as a method body
6+ Geo
7  -> det(@a, @b, @c, @d)
8    @strictmath ->
9      @a * @d - @b * @c
10
11@fastmath ->
12  total = f1 * g1 + ~1.0
13
14# explicit single-rounding FMA, any mode
15err = fma(x, y, ~0.0 - x * y)
            

Money That Makes Sense

Tungsten treats currency as a first-class type. No floating-point rounding errors. No string formatting gymnastics. Just write the dollar sign and go.

Percentages work intuitively — price - 15% calculates the discount. Chain operations freely: price - 15% + 8.25% applies a discount then adds tax.

Mix dollars and cents naturally. Tungsten handles the conversion and precision automatically.

pricing.w

1price = $499.99
2
3<< price - 15%           # => ≈$424.99
4<< price - 15% + 8.25%   # => ≈$460.05
5
6<< $3.50 - 25¢           # => $3.25
7<< 20% - 15%             # => 5%
8
9# Tax calculation
10subtotal = $149.99
11tax_rate = 8.875%
12
13<< subtotal + tax_rate   # => ≈$163.30
            

Physics, Natively

Attach units directly to numbers. Tungsten understands dimensional analysis — multiplying length × length gives area, volume gives volume.

Mixing incompatible dimensions raises a dimension mismatch error. No more silently adding meters to kilograms.

Constants like the speed of light carry their units through every calculation. Einstein's equation isn't a comment — it's working code.

relativity.w

1c = 299_792_458 m/s
2m = 1 kg
3
4<< e = m·c²              # => ≈8.988×10¹⁶ J
5
6<< 3 ft + 12 in           # => 4 ft
7<< 10 ft * 10 ft          # => 100 ft²
8<< 1 cm * 1 cm * 1 cm    # => 1 cm³
9
10<< 2 m + 2 lbs             # => error: dimension mismatch
            

Feature	Tungsten	Python	Ruby
Output	`<< x`	`print(x)`	`puts x`
Class	`+ Point`	`class Point:`	`class Point...end`
Method	`-> distance/1`	`def distance(self, other):`	`def distance(other)...end`
Map	`list/sq`	`[x**2 for x in list]`	`list.map { it ** 2 }`
Generics	`Complex<f64>` (monomorphized)	`complex` (boxed)	`Complex` (boxed)
GPU kernel	`@gpu fn` — in the language	CUDA / Triton DSL	FFI to C
Interpolation	`"[name]"`	`f"{name}"`	`"#{name}"`
Block ending	`(dedent)`	`(dedent)`	`end`

Pseudocode
that runs.

No ends. No braces.
Just the algorithm.

Tungsten Makes Cents

Units of Measurement

Decimals by Default

Examples

A Touch of Class

Blocks are Basic

`case` and `recase` were in a boat

Generics are Monomorphized

A Kernel of Truth

Attention, End to End

Floating Point You Can Reason About

Money That Makes Sense

Physics, Natively

Less ceremony,
more clarity

Element 74: born on 7/4

Toolchain

Bit Package Manager

Specification 2026.07.04

REPL wit

Community GitHub

Start writing Tungsten

Pseudocodethat runs.

No ends. No braces.Just the algorithm.

Tungsten Makes Cents

Units of Measurement

Decimals by Default

Examples

A Touch of Class

Blocks are Basic

case and recase were in a boat

Generics are Monomorphized

A Kernel of Truth

Attention, End to End

Floating Point You Can Reason About

Money That Makes Sense

Physics, Natively

Less ceremony,more clarity

Element 74: born on 7/4

Toolchain

Bit Package Manager

Specification 2026.07.04

REPL wit

Community GitHub

Start writing Tungsten

Pseudocode
that runs.

No ends. No braces.
Just the algorithm.

`case` and `recase` were in a boat

Less ceremony,
more clarity