Hello World: Introducing Lux

I’ve been thinking about this for a while.

I’m a creative coder. I make visuals, I build installations, and there’s nothing I love more than connecting nodes and tweaking parameters until something looks right. It’s the kind of work where you lose track of time because the feedback loop is so tight, change a number, see the result, change it again, and suddenly it’s 3am and you’ve made something beautiful that didn’t exist four hours ago.

But I also want to find things fast, manage things fast, stay in flow. The developer/artist workflow is my biggest driver. The creative part is connecting nodes and seeing results, everything else (searching for the right node, organising a patch, undoing a mistake) should be instant and invisible.

And every time I sit down to do this work, I’m fighting the tools.

The platform problem

One of my biggest frustrations is that I’m truly a cross-platform creative coder. I select and jump hardware based on what I want to achieve, a Linux box for an installation, a Mac for a studio project, Windows for a client who needs it. But the tools don’t follow me. They pick a platform and that’s where they live.

This is honestly why I ended up rolling my own bespoke systems more and more. I want a unified, performant experience across all of them, Linux, macOS, and Windows. Same project, same performance, same workflow. No compromises, no “well on this platform you can’t do X.”

The tool problem

TouchDesigner is incredible. The operator system, the way TOPs flow into each other, the GLSL integration, it’s a masterpiece of design. But it’s Windows-first. I’m on Linux. The macOS version exists but it’s limited. And there’s no Linux version at all. So I’m either dual-booting or running a VM, and neither of those is “just sit down and create.”

vvvv is brilliant in a different way. The Spread concept, where one wire carries many values and every node processes them automatically, genuinely changed how I think about data. But vvvv needs .NET, it’s mostly Windows, and while vvvv gamma is making progress on cross-platform, it’s not there yet.

openFrameworks taught me C++ and gave me total control. Cinder was the same story with a nicer API. Processing got me started. All of them are code-first, which is powerful but slow for the kind of iterative visual work I do. When I want to try 50 variations of a particle system, writing code for each one isn’t the answer. A node graph is.

And most recently, I’ve been rolling my own bespoke systems from scratch. Custom renderers, custom node graphs, custom everything. It works, but I’m spending more time building tools than making art. That’s backwards.

Over the years I’ve used vvvv, openFrameworks, TouchDesigner, Cinder, Processing, and none of them have been the tool. The one that does everything I need without compromise. Every tool teaches you something. Every tool leaves you wanting.

And every creative coder I know has the same story: love the paradigm, frustrated by the limitations.

So I’m building my own

It’s called Lux.

The name is simple. Light. Visuals. That’s what this is about.

What I want from it

I’ve been writing down what the ideal creative coding tool looks like for me. Not features for features’ sake, the things that actually matter when you’re in the flow:

Runs on my machine. Linux, macOS, Windows. Not “sort of works on macOS.” Not “Linux support is experimental.” Actually runs, first-class, on every platform. I shouldn’t have to choose my operating system based on my creative tool.

Doesn’t drop frames. No garbage collector deciding to pause mid-render. No “oh the GC kicked in and your installation stuttered in front of 500 people.” Predictable performance, every frame. This is non-negotiable for installations and anything real-time.

Feels modern. Vulkan, Metal, DX12, not legacy OpenGL. GPU-first rendering, not GPU-bolted-on-as-an-afterthought. The GPU should be doing the heavy lifting from the start, not as an optimization you add later.

Lets me extend it. When I need a custom node, and I always need a custom node, I don’t want to fork the whole project or write a C++ plugin with 200 lines of boilerplate. I want a plugin system that’s simple, safe, and doesn’t require me to match the exact compiler version the host was built with.

Thinks in Spreads. If you’ve used vvvv, you know what I’m talking about. One wire carrying a thousand values. Every node downstream processing them automatically, per element. Shorter spreads wrapping around longer ones. No loops. No array management. Just data flowing through wires. It changes how you think about visual programming, and once you’ve experienced it, you can’t go back.

Node graph, not code. I love writing code. I do it every day. But for creative visual work, a node graph is the right interface. The spatial layout IS the program. You can see data flowing. You can trace a problem by following wires. You can reorganize by dragging, not refactoring. Code is for the engine underneath, the user-facing tool should be visual.

What I hope Lux becomes

Honestly? I want Lux to be the tool I wish existed when I started doing this work.

A place where you connect a noise generator to some circles and suddenly there’s something alive on screen. Where you can go from “I have an idea” to “I can see it” in minutes, not hours. Where the tool gets out of your way and lets you create.

I want it to be the thing where a designer who’s never written code can build an interactive installation. Where an artist can experiment with generative systems without learning C++. Where a creative coder can prototype ideas at the speed of thought instead of the speed of compilation.

And I want it to run on the hardware people actually have. Not everyone has a Windows workstation with an NVIDIA GPU. Some of us are on Linux laptops. Some of us are on Mac Studios. The tool should meet you where you are.

And I want the Spreads. God, I want the Spreads. The idea that you can feed 1000 positions into a single Circle node and get 1000 circles, no for loop, no array management, just data flowing through wires, that’s the thing that made me fall in love with visual programming in the first place. Every node becomes a parallel operation. Every patch becomes a data pipeline. It’s beautiful and I want it at the core of everything.

The plan

I’m building this in Rust. Not because it’s trendy, because it solves real problems I’ve hit before. No garbage collector means no surprise frame drops. The type system catches bugs at compile time instead of at runtime. And the ecosystem is genuinely excellent for this kind of work.

The rendering stack:

• wgpu for cross-platform GPU access, it talks to Vulkan on Linux, Metal on macOS, DX12 on Windows. One codebase, every platform.
• Vello for 2D vector graphics, GPU-accelerated path rendering. Shapes, text, bezier curves, all tessellated on the GPU. Crisp at any resolution.
• egui for the editor UI, immediate mode GUI that’s fast and good enough for dev tools.

The plugin system will be WebAssembly. Write a node in Rust, C, Zig, or any language that compiles to WASM. The plugin runs sandboxed, it can’t crash the host. It’s portable, one .wasm file works on every platform. And it’s hot-reloadable, change your plugin, rebuild, and the new version loads without restarting.

I’ve written a 3000+ line spec document. Architecture diagrams. Crate boundaries. A 13-phase build plan. I might be over-planning. But I’ve built enough systems to know that the ones that survive are the ones with clear foundations.

It’s ambitious. Maybe too ambitious for one person. But every tool I use was too ambitious for the people who started it, and they built it anyway.

Also, and this is important, this is just fun for me. Building tools, solving these problems, making the thing that makes the thing. I genuinely enjoy this. That matters. The best projects are the ones where the work doesn’t feel like work.

Have to start somewhere

This blog is where I’ll document the journey. The architecture decisions and why I made them. The things that worked on the first try and the things that were Better, But Broken! Lol. The technical deep-dives for the nerds and the progress updates for everyone else.

I’m not promising a release date. I’m not promising it’ll be easy. I’m promising I’ll build it in the open and share what I learn.

If you’re a creative coder who’s been frustrated by the same things I have, or if you’re just curious what it looks like to build a visual programming environment from scratch in Rust, follow along.

First code drops next week.

Let’s go.