2026-03-09 · gizmo64k
Imagine you could access all your files and programs through nodes.
Not metaphorically. Literally. Your system clock is a node. Your file browser is a node. Your web browser is a node. And you can wire them together on an infinite canvas and watch data flow between them in real time. Without writing a single line of code.
That's IndieFlow. And today I'm sharing the first alpha preview video.
No release. Just a video.
Let me be clear upfront: there is nothing to download. No beta signup, no waitlist, no "early access for $9.99/month." This is a video. A look at what I've been building. That's it.
I've been working on this for a while now, and it's reached a point where it actually does things that are worth showing. So here it is.
The preview
The video walks through the core idea: everything on your desktop becomes a node.
Take your system clock. It's a node now. Wire its output to a bar chart. The chart updates live. Now wire that chart to a sequencer. Congratulations, your clock is making music. No code. No scripting. Just wires.
It goes further. You can generate content directly on the desktop, just connect some nodes and go. You can automate your web browser, fetch all images from a page, or just browse normally. You can create agent loops with tool calling. You can write custom nodes in Python... one file, drop it in a folder, done.
And all of it runs 100% locally. No cloud. No API keys for the core experience. No data leaving your machine. Your data, your choice.
...why?
If you've been reading this blog, you know I've been thinking about transparency, control, and who gets to decide how our tools work. IndieFlow is my answer to a specific problem: the opacity of modern software.
Right now, when you use most tools, especially AI tools, something invisible happens and results appear. When things break, you can't see why. You can't trace the flow. You can't fix it. You just... restart and hope.
IndieFlow makes everything visible. Every action is a node on the canvas. Every data flow is a wire you can follow. Every timing decision is a number on the connection. When something breaks, you find it by looking.
This isn't about dumbing things down. It's about making complexity navigable. The same way a circuit diagram doesn't make electronics simple, it makes them debuggable.
The execution model
For the technically curious: IndieFlow is trigger-driven with pull-based data.
Triggers are events. They fire and propagate through the graph. Data doesn't push itself around... it gets pulled when a node needs it. Execution order is visible on the wires themselves. There are no hidden race conditions. If two things collide, you see it on the canvas. It's a visible problem, not a mystery.
This matters because it means the graph is truth. What you see is what runs. No hidden state machines, no background threads doing things you can't trace, no "it works but nobody knows why."
Custom nodes in Python
One of the things I'm most excited about: you can extend IndieFlow by writing a single Python file.
Create a class, define your ports, implement an evaluate method, drop the file in a folder. That's the whole process. No registration in four different config files. No build step. No framework ceremony. One file. Auto-loaded. Done.
This means anyone who can write basic Python can create new nodes. And those nodes are first-class citizens... they wire up, they save, they trigger, they flow like everything else.
What's next
I'll be sharing more as development continues. The architecture is solid, the core works, and there's a growing collection of nodes that do useful things. But there's still a lot to build before this is ready for other people to use.
When it's ready, it'll be open source. The code will be yours to run, modify, and extend. Because the whole point of building something transparent is to actually be transparent about it.
For now: watch the video. If you see what I see, we'll talk soon.
/gizmo | 2026-03-09
| CREDITS |
@gizmo64k & @zebrapunk: concept, development, direction
www.indiepixel.studio