Library / SDK
Stiffstream/sobjectizer avatar
Stiffstream/sobjectizer

sobjectizer: three concurrency models in one C++ framework, single-threaded by default

An implementation of Actor, Publish-Subscribe, and CSP models in one rather small C++ framework. With performance, quality, and stability proved by years in the production.

630 stars60 forksC++NOASSERTION

At a glance

What is it?
SObjectizer implements the actor, publish-subscribe and CSP-like models in one small cross-platform C++ framework, and it argues in its own README that comparing it to taskflow or HPX is useless because the two solve different problems. The design fact that matters most to a reader is that agents share one work thread until you pass a dispatcher.
Who is it for?
Use SObjectizer if you are writing a C++ service with many independent tasks that need to interact, and you want the actor, pub/sub and channel styles in one dependency. Do not reach for it to make one computation faster across cores, since the README is explicit that is a different problem.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • Stiffstream/sobjectizer630 ★ · +3
Star history
Repository2026-09-222026-11-15
Stiffstream/sobjectizer627630

3 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Agents share one work thread until you pass a dispatcher

The single most important fact about the framework is stated in the middle of the Ping-Pong example: all agents in that code are working on the same work thread.

The README then answers the question it just raised. Binding them to different work threads is simple, and you do it by using an appropriate dispatcher, which is passed when the cooperation is introduced:

cpp
env.introduce_coop(
   so_5::disp::active_obj::make_dispatcher(env).binder(),

The example in full passes an active-object dispatcher binder into the call that introduces a cooperation, then creates the agents from that cooperation and hands one agent the other's direct mailbox.

So the default is one thread per cooperation, and parallelism is opt-in per dispatcher rather than automatic with agent count. That is a deliberate shape: an actor framework that gave every agent its own thread by default would make the simple case expensive, and the framework's stated goal is reducing the complexity of concurrent applications rather than maximising throughput.

The practical consequence is that the threading question is answered in one place in your code, and you can defer it until you know which agents actually need their own thread.

One header, one namespace, and the agent retires itself

The API surface in the examples is small enough to take in one reading, and it is consistent.

There is a single umbrella header, `so_5/all.hpp`, and everything lives in the `so_5` namespace. The base class for an actor is `agent_t`. Startup goes through `launch`, which takes a lambda over an `environment_t`, and agents are registered into something the README calls a cooperation, either through a registration call or by asking the environment to make one.

Two idioms are worth calling out because they appear in every example.

The first is that an agent retires itself. The HelloWorld actor prints and then calls a deregistration function with a name that says normally, which is how an actor with no further work removes itself from its cooperation rather than being torn down from outside.

The second is how messages arrive. A handler takes a parameter typed as a handle wrapping the message type, then reads its fields through an arrow. An agent takes a context object and constructs its base from it by moving, and it registers handlers by subscribing itself to an event.

Mailboxes are first-class and addressable: the Ping-Pong example stores one as a member and receives another agent's direct mailbox through a setter.

Pub/sub is a property of the mailbox, not a second API

The third model is described in one sentence, which is the most economical thing in the README.

SObjectizer supports the publish-subscribe model through multi-producer, multi-consumer message boxes, and a message sent to such a box is received by all subscribers of that message type.

That is the whole design decision. Fan-out is not a separate subscription mechanism bolted alongside the actor API; it is what you get when you choose a mailbox of that kind instead of a directed one. The same handle type carries a message either way, and the same agent handler signature receives it either way.

The consequence is that switching an interaction from point-to-point to broadcast is a change to how a mailbox is obtained rather than a rewrite of the agents on either side.

The CSP-like channels are the third style, and the README's table of contents lists two examples for them: one CSP-style ping-pong, and another with a select-like statement borrowed from Go's syntax.

The README argues against the comparison it keeps receiving

There is a section titled as a claim about what this is not like, and it opens by saying the comparison is useless.

The tools named are Intel Threading Building Blocks, taskflow and HPX. The argument is that all of them are for parallel computing, where the goal is reducing computation time by using several cores, and the example given is re-encoding a video: an hour on one core, fifteen minutes on four.

SObjectizer is placed in concurrent computing instead, where the goal is simplifying many different tasks at once, and where a single core may be enough.

The README then concedes the part that makes the argument honest: parallel and concurrent computing use the same mechanisms and primitives underneath, such as threads, mutexes and atomics, and differ only from the high-level point of view.

The application shapes it suggests for the framework follow from that split: a multithreaded proxy server, an automatic control system, a message broker, a database server.

Sixteen years of version five, on ideas from the mid-1990s

The maturity claims are dated, which is unusual and useful.

The design ideas were put forward between 1995 and 2000. The framework itself has been developed since 2002. The current major line, version five, has been continuously evolved since 2010.

Stability is argued the same way: the framework was used for business-critical applications from the beginning and some of them are still in production, with breaking changes described as rare and approached very carefully.

The release history is consistent with that. The three most recent tags are v5.8.5.1, v5.8.6 and v5.8.6.1, a four-part scheme where the last element sits inside the minor slot, and the two newest are about seven weeks apart. The last push was on 2026-09-22 and the repository is not archived.

Cross-platform support is listed as Windows, Linux, FreeBSD, macOS and Android. FreeBSD in that list is the one that distinguishes it from most actor frameworks, and the build section documents Android through both the Android NDK and CrystaX NDK, plus vcpkg and Conan as dependency managers.

Metadata records no licence, the README says BSD-3-CLAUSE

There is a licence discrepancy worth resolving before you depend on this.

Repository metadata records the licence as NOASSERTION, which means the platform did not classify it. The README's own bullet says SObjectizer is distributed under the BSD-3-CLAUSE licence and that it can be used in the development of proprietary commercial software for free. A `LICENSE` file sits at the root of the listed tree.

So the terms are stated in the documentation, stated again in the file, and undetected by the tooling that other projects rely on for automated compliance checks. If you are scanning dependencies, this one will not appear as having a licence.

The homepage is also a vendor product page rather than a project site, which is consistent with the description crediting years in production and with the README pointing readers to the project's own wiki for further reading rather than to a documentation site.

The source tree also keeps Mercurial artefacts, which the next section covers.

Mercurial ignore and tag files survive in a GitHub repository

The listed repository root holds eleven entries, and two of them are not Git files.

There is a `.hgignore` and a `.hgtags` alongside `.gitignore` and `.gitattributes`. Those are Mercurial's ignore and tag files, which means at some point this project was developed under Mercurial and the switch to Git left both sets in place.

Read next to the maturity claims, it fits a project whose history genuinely spans that period. It also has a small practical cost: a Mercurial checkout of this tree would honour the ignore rules that were written for the other system, and a contributor cleaning up dead files has to know that the pair is intentional rather than a slip.

The three directories are `android/`, `dev/` and `doxygen/`. The Doxygen directory is worth noting against the README's own advice, because the documentation is split between generated API reference in the repository and prose in the project's wiki.

One more gap is visible in the table of contents rather than the body: there is a Limitations section, and the excerpt available here does not say what it contains. For a framework whose pitch includes stability, that is the section a reader should find first.

Editorial conclusion

Use SObjectizer if you are writing a C++ service with many independent tasks that need to interact, and you want the actor, pub/sub and channel styles in one dependency. Do not reach for it to make one computation faster across cores, since the README is explicit that is a different problem. Before building, check the licence file yourself because repository metadata does not detect it, confirm you can meet the C++-17 floor for the 5.8 line, and read the Limitations section, which the table of contents lists without summarising.

Frequently asked questions

What is SObjectizer?

It is a cross-platform open source C++ actor framework that also supports the publish-subscribe model and CSP-like channels, with the stated goal of simplifying the development of concurrent and multithreaded applications. The README positions it as distinct from parallel computing tools, since its aim is doing many different tasks at once rather than making one computation finish sooner across cores.

How do I make SObjectizer agents run on different threads?

By supplying an appropriate dispatcher. The Ping-Pong example notes that its agents all run on the same work thread by default, and the fix passes `so_5::disp::active_obj::make_dispatcher(env).binder()` into the call that introduces a cooperation, creating the agents from that cooperation and connecting them with `so_direct_mbox()`.

What licence is SObjectizer under?

The README states BSD-3-CLAUSE and says it can be used in the development of proprietary commercial software for free, with a LICENSE file at the root. Repository metadata, however, records the licence as NOASSERTION, so automated licence detection will not report it.

Which platforms and build tools does SObjectizer support?

Windows, Linux, FreeBSD, macOS and Android, with SObjectizer-5.8 requiring C++-17. The README documents building via CMake, building for Android with either the Android NDK or CrystaX NDK, and consuming the library through vcpkg or Conan. The current line is version five, evolved since 2010.

Official sources

  1. Issues
  2. Project website
  3. README
  4. Releases
  5. Stiffstream/sobjectizer on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/stiffstream-sobjectizer.svg)](https://hysenlabs.com/projects/stiffstream-sobjectizer)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/stiffstream-sobjectizer.svg)](https://hysenlabs.com/projects/stiffstream-sobjectizer)

Was this useful?