Adaptive
As load rises, priority decides what runs next - urgent work goes first, while aging keeps everything else moving up the queue so it isn't forgotten.
About Thryve
Run the work that matters first
Thryve is a high-performance, open-source task-execution engine written in Rust, built for systems where work has to be prioritized, run concurrently, and observed as it happens. Teams that build on it thrive - that's the whole idea behind the name.
What Thryve does
Real systems rarely struggle because a single task is slow. They struggle to decide what runs first when everything is urgent, to stay loosely coupled as they grow, and to catch the moment something goes wrong. Those are the problems Thryve is built around.
Work is submitted with priorities to a managed pool of workers that run it concurrently; priority bounds and aging keep urgent work first while making sure nothing is starved. An event-driven observer system lets components react to what happens without being wired directly together, and a plugin architecture lets teams add or replace capabilities at runtime - without modifying the core. When something is clearly wrong - an event addressed to an observer that was never loaded, say - Thryve halts rather than continuing in a bad state.
Transparent
Thryve would rather stop than hide a problem. A misnamed observer, a bad configuration, or work that can't proceed surfaces right away - so it reaches developers early instead of failing silently.
Efficient
Written in Rust and built to run work concurrently - no garbage collector, low overhead by design.
How the engine is organized
At the center is the Engine - a main loop that receives tasks from external sources, processes notifications from observers, collects results from executions, and coordinates pause, resume, and shutdown. Around it sit three pillars - task execution, the observer system, and the plugin architecture - plus an FFI layer for other languages, TOML configuration, and optional graph visualization of task and notification topology.
Open at the core
Thryve is free and open source under the GNU AGPL-3.0. You can read it, run it, modify it, and build on it - we think the best infrastructure earns trust by being open. The AGPL simply asks that if you distribute Thryve or offer it over a network, you share your corresponding source under the same terms.
For teams whose products can't meet that - a proprietary application, a closed-source service - a commercial license grants the same engine without the source-disclosure requirement, on terms scoped to how you deploy it. That's the entire reason this site exists: to make the licensing clear and the next step simple.
The organism behind the name
In 2010, researchers led by Atsushi Tero laid oat flakes over a map of greater Tokyo and let Physarum polycephalum - a single-celled slime mold with no brain and no central controller - find its way between them. In roughly a day, it grew a nutrient network that mirrored the real rail system: resilient, efficient, self-healing. What's remarkable isn't the result but the method - thousands of simple parts, each following local rules, producing a near-optimal whole. That's the behavior Thryve is modeled on.