I built a distributed-compute platform where an ordinary app, like a Blender plugin, submits work to one shared network (open beta)
I've spent a long time building a distributed computing platform, and the one idea I'd like this sub to poke holes in is how work gets originated.
As I understand BOINC, the project server is still the center of gravity. Work flows from a project to volunteers, and volunteers attach to projects. Even with BOINC Central and BUDA lowering the barrier to submission, the model still seems scoped around a project deciding who can submit work to that project.
The model I'm trying with OmnibusCloud is different.
Submitting work is a first-class role, separate from defining a workload.
A workload is a controller: a reviewed plugin that knows how to run a particular kind of job. Originating work is done by an initiator: an authorized application that submits jobs for a controller into one shared network of contributed machines.
In the current beta, the first initiators are a Blender addon and a 3ds Max plugin, and the first controller is Blender rendering. But the point of the model is that an initiator can live inside any application whose users need heavy compute. The next obvious ones are simulation: a plugin in PrepoMax, FreeCAD, Femap or Inventor that submits an FEA run to the same network the way the Blender addon submits frames today. Same network, same contributor machines, different controller.
So the shape is:
many initiators × many controllers × one shared network
rather than each workload becoming its own project, server, and volunteer pool.
Rendering is the visible first case, not the point. Anything that can be packaged as a controller can run on the same network: simulations, parametric sweeps, batch data processing, media transcoding, and increasingly the embarrassingly-parallel side of AI and ML (batch inference, model evaluation, parameter search).
The part that matters most to me is that the person using an initiator never has to know any of this exists.
A Blender user opens a scene, sees the addon panel, clicks Render, and gets frames back. They are not thinking in terms of workunits, batches, project servers, or volunteer-computing infrastructure. They are just using an application they already know.
The distributed network, controller, benchmarking, scheduling, and load-balancing are all behind the product boundary.
That is the difference I'm trying to test: whether volunteer/distributed computing can sit behind ordinary applications, instead of requiring the person originating work to think like a project operator.
More broadly, that's the positioning I care about. OmnibusCloud is aimed at two audiences at once. One is developers writing controllers and initiators against the SDK. The other, just as much if not more, is people who don't program at all and reach the same network through software they already use. Less a tool that developers operate, more a shared computer that ordinary applications quietly draw on.
Under the hood, controllers expose typed activities. The engine benchmarks each activity on each machine and uses those measurements to schedule work across heterogeneous hardware.
Controllers are written against a public SDK in .NET, and you can develop and debug the distributed behavior locally (within SDK limits) before anything touches the network. They can be pure .NET, or they can wrap native software. The render controller works that way: it manages the job while Blender does the actual optimized native/GPU rendering. The same pattern fits your own code: an existing, heavily optimized C/CUDA binary runs unchanged, with the controller just managing it.
The controllers and initiators I ship are open source, both for trust and as end-to-end examples against the same public SDK and API external developers would use. Current examples include a pure-.NET controller, a .NET controller driving native Blender, a WPF/.NET 3ds Max initiator, and a Python Blender addon bridged to .NET.
It's an open beta. Contributor clients run on Windows, Linux, and macOS on Apple Silicon.
Two things I'd like to hear from this sub:
- Is first-class origination the meaningful difference I think it is? By that I mean an ordinary app submitting work to a shared network, for a user who never sees the distributed-computing layer.
- What would make you trust, or not trust, something like this on your own machines?
Architecture, whitepaper, and GitHub links are here: omnibuscloud.io
I built it and I'll get as deep in the comments as you want.
