Start with the output
Little experiments, real runtime
Shaders, clocks, synths, games, MIDI, small tools, WebAssembly sketches. A small script can quickly become something you can touch, hear or remix.
Open-source MIT core. Early-stage. Built by a solo developer.
Budo is a small runtime for creative coding, multimedia tools, shaders, audio experiments and quick
prototypes. Drop in a main.js, main.lua or WebAssembly file, run one binary,
and see pixels move. It runs on Desktop, Web and Android.
Start with the output
Shaders, clocks, synths, games, MIDI, small tools, WebAssembly sketches. A small script can quickly become something you can touch, hear or remix.
What Budo is
Budo exists for the moment when you have a visual idea, a shader sketch, a synth toy, a tiny editor, a teaching demo or a weird prototype, and you want to run it now.
It gives you one binary, an immediate-mode API and a handful of native systems that usually require a pile of setup: Skia drawing, GL shaders, audio, MIDI, SQLite, files, networking and optional ONNX inference. JavaScript, Lua and WebAssembly are first-class entry points.
It is intentionally small and hackable. The project is early-stage, actively maintained, and built by a solo developer who cares about keeping the runtime understandable.
The whole loop
No package manager ceremony. No bundler. No generated project forest. A folder with a script is enough.
function frame(t) {
const w = sys.window.getWidth();
const h = sys.window.getHeight();
const pulse = 40 + Math.sin(t * 0.006) * 18;
sys.canvas.clear('#111216');
sys.canvas.setFillColor('#f7a84c');
sys.canvas.drawCircle(w * 0.5, h * 0.5, pulse);
sys.canvas.setFillColor('#9b8aff');
sys.canvas.drawText('change me', 32, 56, 28);
sys.animation.requestFrame(frame);
}
sys.animation.requestFrame(frame);budo run sketch --watch
The same project can also be exported for the web with web-export
or served locally with web-serve.
Why it feels different
Budo focuses on a particular kind of work: drawing, sound, tools, play and fast iteration.
Canvas-style drawing, animation frames and input are exposed directly through sys.
The mental model is closer to Processing than to a frontend framework.
Skia, GLSL shaders, meshes, audio playback, synth primitives, MIDI, SQLite and files live next to each other. Small apps can still touch serious native systems.
Use JavaScript or TypeScript when you want quick scripting, Lua when you want tiny expressive code, and WebAssembly when you want a lower-level path.
Desktop is the natural home. Web export exists for sharing. Android support exists because experiments are more fun when they can run on real devices.
AI-assisted coding
Budo ships with budo-llm.md, a compact markdown file that documents the API,
runtime rules and common traps for coding assistants.
That matters. When the API surface is small and the context fits in one file, assistants are much less likely to invent browser APIs, Node APIs or imaginary engine calls. They can generate a working sketch, then you can edit it like normal code.
The goal is practical: fewer hallucinated APIs, less scaffolding, more time spent on the thing you wanted to make.
Generate the assistant context locally with budo budo-llm.md.
Open core, clear boundaries
The part that runs your app is open. You can inspect it, modify it, fork it, learn from it and build on it without vendor lock-in.
The core runtime is MIT licensed. Transparency is part of the design, especially while the project is young.
The Android APK/AAB packager is paid tooling. It helps fund development and removes the most annoying Android Studio and Gradle work from small projects.
The packager generates Android build artifacts. You still own signing choices, testing and Play Console submission.
Under the hood
Budo is built on battle-tested pieces: Skia for 2D/GPU rendering, SDL2 for windowing and input, QuickJS for JavaScript, Lua 5.4 for scripting, Wasmtime for WebAssembly, SQLite for persistence, ONNX Runtime for on-device ML, Emscripten for the web build, and the Android NDK for native mobile runtime.
Current state
Budo is usable today, and still early. APIs may evolve while the runtime finds its cleanest shape.
Feedback is welcome, especially from people building visual sketches, audio toys, shader studies, tiny tools, teaching demos and AI-generated prototypes. Sharp bug reports and small contributions are genuinely useful at this stage.
The roadmap is deliberately practical: better docs, more examples, steadier platform builds, tighter LLM context, improved packaging and a runtime that stays pleasant to hack on.
Try it locally
A self-contained runtime for quick experiments. Pick a build, open the docs, and start with a small script.
curl -fsSL https://budo.dev/install.sh | bash
Linux CLI installer. No root, no shell profile edits. Installs to ~/.local/bin/budo.
Feedback welcome
Send a note for Android packaging, bug reports, demo ideas, contributions, or just to show what you made.