LUNARIS
v0.1 pre-release
Minimal core, infinite possibilities
Lunaris is a multimedia engine with a microkernel plugin architecture. Build a video editor, DAW, animation suite, or something entirely new by composing plugins.
Free · Open Source · Built in Rust · Windows · macOS · Linux
Platform-first
Lunaris is a multimedia platform, not a finished product.
Think VSCode for creative software. Install or write plugins to assemble the exact workflow you need: timelines, MIDI, simulation kernels, or a brand new domain entirely. The minimal core stays stable so plugins can evolve quickly.
Built in Rust
Microkernel core (~400 LOC) keeps the runtime predictable.
Extensible
Add, remove, or swap plugins without forks or rewrites.
Composable
Plugins expose APIs so other plugins can call into them directly.
What you can build
Add plugins and Lunaris becomes the tool you need.
Start from the minimal kernel, then mix and match plugins for your use case.
Video editor
Add timeline, codecs, color tools, and export plugins to assemble a modern editor that you control end-to-end.
- Timeline & sequencing
- GPU accelerated codecs
- Color grading nodes
DAW / audio workstation
Compose MIDI, DSP, and synth plugins to craft a DAW tailored to your workflow without the bloat.
- MIDI routing
- Audio graph
- FX + instrument racks
Motion graphics suite
Mix animation canvas, rigs, and simulation plugins for procedural motion design and VFX work.
- Animation canvas
- Rigging layers
- Simulation kernels
Your own tool
Prototype experimental creative software by composing only the primitives you need. Lunaris stays out of the way.
- Custom UI
- Domain specific ops
- Shared plugin APIs
How it works
A microkernel with plugins that define every capability.
The Lunaris core only boots the engine, schedules jobs, and exposes GPU/device access. Everything else—UI, tools, codecs, physics—lives in plugins so you can swap implementations or keep experimental forks side-by-side.
Microkernel core
Roughly 400 lines that handle GPU init (wgpu), ECS, scheduling, and messaging. Everything else is a plugin.
Plugins define behavior
UI, codecs, tools, storage, and workflows live in plugins. Replace or fork them without touching the core.
Compose like VSCode
Each plugin exports APIs that other plugins call directly. Compose them just like VSCode extensions or Emacs lisp.
Static linking for speed
Plugins are Rust crates linked statically, so you keep type safety and zero-cost abstractions.
use lunaris::prelude::*;
pub struct TimelinePlugin;
impl Plugin for TimelinePlugin {
fn register(&self, registry: &mut PluginRegistry) {
registry.register_tool("timeline", TimelineTool::new());
registry.register_codec("h264", H264Codec::new());
}
fn name(&self) -> &str {
"Timeline Plugin"
}
fn version(&self) -> &str {
"0.1.0"
}
fn description(&self) -> &str {
"Provides timeline and codec support for video editing."
}
}
For developers
Built for systems programmers who care about extensibility.
Write plugins in Rust with type-safe APIs and no virtual machine.
Call other plugins directly—no black-box IPC or fragile scripting layers.
Drop to native when needed: Metal, Vulkan, DX12 via wgpu boundaries.
Ship cross-platform builds (Windows, macOS, Linux) from one codebase.
Get started
Choose your entry point.
For power users
Download Lunaris bundled with the video editor stack and start editing with a transparent pipeline.
For plugin developers
Follow the ten-minute tutorial to write your first plugin and compose it with the existing stack.