Skip to content

~/dev ❯ whoami

Dale
Hutchinson

Rust developer. I build I build programming languages, a web framework, music compilers, WebGL scenes, data platforms, language servers.

Grammars and compilers, a fullstack web framework, music that compiles to MIDI, shaders and 3D scenes, and data platforms that are honest about their numbers. Mostly Rust, mostly in the browser by way of WebAssembly.

languages
light
sound

drag to turn it · arrow keys too

RustWebAssemblyWebGL2GLSLactix-webAxumLeptosDioxusbevy_ecspesttower-lsptree-sittercpalMIDIasync-graphqlSDMXTailwindHaskellTypeScriptThree.jsGSAPONNX

// 01 · now building

Weft, a web framework woven from Rust

Pages are a small functional template language that compiles to WebAssembly. Tailwind, WebGL, shaders, charts and an accessibility tree are built in, and this whole site is written in it.

native tests, plus 59 in the browser
1,277
accessible component families
131
chart families, connected by one src prop
51
of gzipped wasm for a whole app
610KB
weft · app/page.weft
scene3d(label: "Three threads woven around a lambda", controls: "orbit") {
    camera(position: [0, 0, 7.8])
    pointLight(position: [-4, -2, 3], color: "#f2542d", intensity: 2.2)
    for t in threads {
        mesh(rotation: [t.rot, t.rot / 2, 0], spin-y: 12) {
            torusKnotGeometry(args: "1.8 0.09 360 20 2 3")
            meshPhysicalMaterial(color: t.color, metallic: 0.35, roughness: 0.25)
        }
        html(position: t.at, distance-factor: 7) { span "{t.label}" }
    }
    mesh(spin-y: -20) {
        text3d(font: "/fonts/jetbrains-mono.ttf", depth: 0.3) { "λ" }
    }
}

The threads above are torus knots in a scene3d; the badges are real DOM pinned to points in 3D.

// 02 · now

What I'm working on

Keep scrolling: the row slides across. Every card opens the project, and the earlier work is on the work page.

All 16 projects →
state count = start ?? 0
let label = if count == 1 then "time" else "times"
on inc = count <- count + 1

Card(title: "Counter", class: "max-w-sm") {
    p(class: "text-lg") "Clicked {count} {label}"
    Button(variant: "gradient", @press: inc) "Click me"
}
Fullstack web framework2026 · Active

Weft

A fullstack web framework in Rust: a small template language, native Tailwind, WebGL, charts and an accessibility tree in every render.

  • Rust
  • WebAssembly
  • WebGL2
  • GLSL
100 bpm

-- bb 1-3
@3 d1 C# d2 B# @3 E d1 D#

-- bb 4-11
{
  (d3.5/1 ~ @4 d2 C# B# E d1 D# d2 C# d3/4 F#)
  (@3 d1 G# d2 Fx B d1 A# d2 G# d3/4 A d8 G# F#)
  (@3 d4 C# D# d3/4 E d8 D# C# d4 D# G# C#)
}
Music composition compiler2026 · Research

DSCH

A compiler for an expression-oriented music DSL: concatenative on the surface, functional underneath, lowered to Standard MIDI.

  • Rust
  • pest
  • MIDI
  • tower-lsp
#[test]
fn recognise_tokens() {
    let mut cursor = Cursor::new("_exp#r");
    let mut tok = cursor.advance_token();
    assert_eq!(tok.kind, Ident);
    assert_eq!(tok.len, 4);

    assert_eq!(cursor.first(), '#');

    tok = cursor.advance_token();
    assert_eq!(tok.kind, Hash);
}
Language tooling2026 · Early days

kolang

A foundation for a family of concatenative, functional, scope-delimited languages: DSCH, and in time a general-purpose language for systems programming.

  • Rust
  • test-driven
  • nanopass
$ cargo run -p weft-cms-server -- serve
  ▸ content   ./content
  ▸ admin     http://localhost:8080/admin/
  ▸ site      http://localhost:8080/
  ✓ ready in 0.4s
Content management2026 · Active · private

weft-cms

A CMS built on Weft: secure, fast and ready out of the box, for anything from a blog to a newspaper.

  • Rust
  • Weft
  • actix-web
  • WebAssembly
# Query live ABS + RBA data
{
  consumerPriceIndex(
    start: { year: 2025, month: 1 },
    end:   { year: 2025, month: 12 })
  cashRateTarget(
    start: { year: 2025, month: 1 },
    end:   { year: 2025, month: 12 })
}
Public policy data platform2025–26 · Rebuilding in Weft

ausmetrics

Economic, environmental and social indicators from the ABS, RBA and independent research, behind one GraphQL API.

  • Rust
  • async-graphql
  • actix-web
  • Leptos
/// Lagrange interpolation
pub fn L(x: f32, points: Vec<Vec2>) -> f32 {
    points
        .iter()
        .cloned()
        .map(|pt| {
            let others = points.iter().filter(|q| q.x != pt.x);
            pt.y * others.fold(1.0, |fac, q| fac * ((x - q.x) / (pt.x - q.x)))
        })
        .sum()
}
Interpolation for DSCH2026 · Experiment

curves

A workbench for checking the interpolation behind DSCH's multi-point dynamic and duration ramps. It started with B-splines and ended up applying Lagrange interpolation.

  • Rust
  • bevy_ecs
  • WebAssembly

// 05 · contact

Say hello

Open to contract and full-time Rust work, collaborations on language tooling or graphics, and conversations about any of the above.

daletristanhutchinson@gmail.com

0 characters · at least 10 to send

to: daletristanhutchinson@gmail.com

subject: A project (via the portfolio)

…

Opens in your email app. Nothing is stored here.