Rune

Creative coding in Odin — native speed, Processing-simple.

A self-contained studio for making generative art: a built-in code editor, a Processing-style canvas library, and one-key compile-and-run — backed by Odin's C-like directness and native performance.

rune website & download →

Processing and p5.js are wonderful for starting, but they hit a wall. Java and JavaScript can't keep up with the heavy stuff — millions of particles, strange attractors, real-time simulation. The moment your art gets computational, the frame rate falls off a cliff.

The native options solve the performance problem but ask a lot: openFrameworks / Cinder (C++) drag in decades of C++ complexity, and Nannou (Rust) is fast but has a steep learning curve and a heavier iteration loop.

Rune fills the gap in the middle. Odin is a modern systems language with C's directness and none of C++'s baggage or Rust's ceremony — built by a game developer, for graphics and simulation. Rune wraps it in a batteries-included studio so you don't assemble a toolchain: open the app, write setup/draw, hit Run.

It's for people who love C's simplicity, want native headroom for heavy generative work, and want a tool they can actually understand and shape.

• Built-in editor — syntax highlighting, c. autocomplete for the whole API, click-drag selection, copy/paste, undo/redo, adjustable font (Ctrl+wheel).
• One-key run — Ctrl+R compiles your sketch and launches it in its own window. Compile errors show inline in the console.
• The canvas library — a Processing-style API: shapes, HSL/HSV color, transforms, seedable random, Perlin noise, Vec2 helpers, easing, and a persistent accumulation buffer (density plots & motion trails).
• In-app reference (F1) — searchable docs for every canvas function with examples, an Odin language cheatsheet, and a keyboard-shortcuts list. Press F1 on a symbol to jump straight to it.
• Print-ready — paper-size presets (c.size_paper(.A4, 300)) and full-resolution PNG export (Ctrl+S).

package main

import c "../../canvas"
import "core:math"

t: f32

setup :: proc() {
	c.size(800, 800)
}

draw :: proc() {
	c.background(12, 12, 16)
	t += c.delta_time
	c.no_stroke()

	// a ring of pulsing circles
	cx, cy := f32(c.width)*0.5, f32(c.height)*0.5
	for i in 0..<12 {
		a := f32(i)/12 * c.TAU + t
		c.fill(c.hsl(f32(i)*30, 0.6, 0.6))
		c.circle(cx + math.cos(a)*220, cy + math.sin(a)*220, 40)
	}
}

main :: proc() {
	c.run(setup, draw)
}

Grab a build for your platform from the latest release, unpack it, and run the rune binary. Keep it next to the bundled canvas/ and sketches/ folders.

You'll need Odin on your PATH (Rune compiles your sketches with it). The builds are unsigned; on macOS clear the quarantine flag once with xattr -dr com.apple.quarantine rune. On an Intel Mac, build from source (below).

Rune needs the Odin compiler (which bundles raylib). Then:

# Windows
build.bat

# Linux / macOS
./build.sh

That builds and launches the IDE. To run a sketch directly without the IDE:

./build_sketch.sh hello      # or: build_sketch.bat hello

Rune is small and legible — ~2,700 lines of Odin across four focused packages:

canvas/   the Processing-style drawing API + the run() window loop
editor/   a pure, unit-tested text-buffer model (cursor, selection, undo, tokenizer)
runner/   compile / launch / stop a sketch process
rune/     the IDE: editor view, docs, autocomplete, theme (package main)
sketches/ your sketches (each a standalone Odin program)

There is no hot-reload magic: a sketch is just a standalone Odin program that imports canvas and calls c.run(setup, draw). The IDE compiles it with odin build and launches the resulting executable — the same edit → Run → watch loop as Processing.

Rune is v0.1 — early, but real. On the horizon:

• Pen-plotter SVG export (vector recording for physical plotting)
• More canvas: transforms stack, begin_shape/vertex paths, typography, images
• Editor: find/replace, multiple tabs, optional vim bindings
• GIF / MP4 recording

See issues for the current list, and CONTRIBUTING.md to help.

Contributions are welcome — see CONTRIBUTING.md. If you're an AI agent working on this repo, read AGENTS.md first.

zlib/libpng — do anything you like, just don't misrepresent authorship. Chosen to match the ethos of raylib and the Odin ecosystem.

Built on Odin and raylib. Inspired by Processing, p5.js, canvas-sketch, and the mathematical art of Paul Bourke. Named for the runes Odin won on Yggdrasil — the original symbols-as-code.