Rebus is a .NET message bus that refuses to be clever
:bus: Simple and lean service bus implementation for .NET
At a glance
- What is it?
- The Rebus core library keeps its dependency list at one package and its configuration to a fluent chain, on the theory that routing belongs in application code rather than in the bus. Useful to know what that theory costs before you adopt it.
- Who is it for?
- Choose Rebus when your services already follow smart endpoints and dumb pipes, when you want the transport to be a configuration choice rather than an architectural commitment, and when one dependency in your graph is worth more to you than a richer out of the box.
- 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 last received commits 4 days ago.
- 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.
Star history
- rebus-org/Rebus2,676 ★ · +7
| Repository | 2026-10-04 | 2026-11-15 |
|---|---|---|
| rebus-org/Rebus | 2.7k | 2.7k |
7 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
A message bus without smarts, by definition
Rebus is positioned by what it refuses to be. Its README quotes the ThoughtWorks technology radar entry from 2010, "message bus without smarts", and pairs it with the smart endpoints, dumb pipes principle from Martin Fowler's microservices article. The bus moves bytes and names, and the decisions stay in the code that sends and receives.
The aims list is a short contract. A simple and intuitive configuration story. A few well-selected options. No doodleware. As few dependencies as possible, currently only JSON.NET. A broad reach, targeting .NET Standard 2.0 and therefore .NET Framework 4.6.1, .NET Core 2 and .NET 5 onwards. Integration with external dependencies through small dedicated projects. And, listed without irony, the best error messages in the world.
Two things follow from that contract. There is no built-in retry policy, dead-letter convention or delivery guarantee to learn, because those would be opinions. And the breadth of transports you see in tutorials comes from elsewhere entirely, since this repository is Rebus core and the queue technologies sit in separate integration libraries under the same organisation.
Everything revolves around RebusBus and one Start call
The starting point in the README is deliberately bare. You construct a RebusBus, tell it how many worker threads to run, use it for the lifetime of the application and dispose it on the way out:
var bus = new RebusBus(...);
bus.Start(1); //< 1 worker thread
// use the bus for the duration of the application lifetime
// remember to dispose the bus when your application exits
bus.Dispose();The `...` is where the work hides. The README describes it as a bunch of dependencies that vary depending on how you want to send and receive messages, which is the honest summary of a library whose design goal is that the configuration is the API. `bus.Start(1)` is the part worth noticing: concurrency is a number you pass in, so a single-threaded consumer is the documented first step rather than an accident.
Nothing here needs a container. If you would rather not hand-wire dependencies, the next section is the supported path.
Configure.With chains a logger, a transport and a routing rule
The configuration API hands the whole setup to one fluent expression:
Configure.With(someContainerAdapter)
.Logging(l => l.Serilog())
.Transport(t => t.UseMsmq("myInputQueue"))
.Routing(r => r.TypeBased().MapAssemblyOf<SomeMessageType>("anotherInputQueue"))
.Start();Read left to right, that is container adapter, logging, transport, routing, start. The transport is a lambda, so MSMQ in this example is a choice rather than a commitment, and swapping it means swapping that one call for another library. Routing is a lambda too, and TypeBased derives the destination from the message type.
The adapter is either the built-in one or a bridge to your container:
var someContainerAdapter = new AdapterForMyFavoriteIocContainer(myFavoriteIocContainer);What Start gives you is an IBus registered as a singleton in that container, with the container itself used to resolve message handlers. The bus therefore expects your handlers to be resolvable, which is the one coupling in a library that otherwise refuses to make assumptions.
MapAssemblyNamespaceOf exists for the shared assembly case
The second configuration example addresses a specific problem rather than a general one. When the assembly holding your message types is shared with unrelated code, mapping every type in it sends every type to the same queue. The README's answer is to map a namespace instead:
Configure.With(someContainerAdapter)
.(...)
.Routing(r => r.TypeBased().MapAssemblyNamespaceOf<SomeMessageType>("namespaceInputQueue"))
.(...);The placeholder ellipses stand in for the logging and transport calls from the previous example, and the trailing container disposal comments follow the same pattern. TypeBased still applies: the namespace becomes the queue name.
This is the clearest evidence of how the library thinks. A general-purpose messaging library would offer a convention or an attribute; Rebus offers a second mapping method and leaves the choice to you. The tree also contains a project called ClassLibraryWithCustomName, which nothing in the README explains, though a library built to prove that namespace mapping survives an assembly whose name does not match its namespace is the obvious guess.
One dependency, and transports that live somewhere else
The dependency claim is specific: as few as possible, currently only JSON.NET, which the README links to the JamesNK/Newtonsoft.Json repository. For a library that serialises every message body and needs to survive transport-specific wire formats, that is a deliberate constraint rather than an accident of a young project, and it dates the design: JSON.NET is the serialiser a .NET service bus reached for by default.
Everything else is separated out. The README calls this integration with external dependencies via small dedicated projects and points at the many integration libraries under the rebus-org organisation. A queue technology, a logging sink, an IoC container and a transport retry strategy are each a package you choose separately, which is what keeps the core's graph small and also what makes Rebus an assembly of decisions rather than one install.
That trade has a cost worth naming. Serilog appears in the configuration example, so logging is not optional in practice, it just is not a dependency of the core. The same pattern applies to MSMQ in the transport example.
Two solutions, two supported major versions
The repository root carries Rebus7.sln, Rebus8.sln and Rebus7.sln.DotSettings, so the library is built and tested against two major versions of .NET at the same time, with the older one keeping its own Rider settings file. Alongside them sit Rebus/, Rebus.Tests/ and Rebus.Tests.Contracts/, plus scripts/, tools/, artwork/ and appveyor.yml at the root.
The test badge in the README points at an AppVeyor project, which matches that appveyor.yml. CHANGELOG.md and CONTRIBUTING.md sit at the root as well, and the GitHub releases page is empty: there are no published GitHub releases for this repository, so the changelog file and the NuGet package history are the version record a reader can actually reach.
This is also where the commercial boundary sits. The README distinguishes this core repository from the many integration libraries, then points at Rebus Pro for support and tooling. Licensing is stated as free as in beer and speech and expected to stay that way, while support, tooling and anything else commercial live in the paid add-on.
The licence link points at a branch called batches
The licence section names The MIT License and tells you to see LICENSE.md, which is present at the repository root. The project's licence metadata, meanwhile, names no licence at all, so the two sources do not fill the same field and it is worth reading LICENSE.md yourself rather than trusting either.
There is a smaller oddity in the link itself. The MIT reference at the bottom of the README resolves to raw.githubusercontent.com/rebus-org/Rebus/batches/LICENSE.md, which reads the file from a branch named batches rather than from the default branch master. The file you land on today may not be the file the README was written against.
The NuGet badges have a similar problem. Latest stable and Current prerelease are two separate badge lines that both point at the identical nuget.org/packages/Rebus address, so the page itself cannot tell you which version is the prerelease one. The last push to the repository was on 2026-09-17, and the substantive documentation lives off the repository, in the GitHub wiki and the maintainer's blog rather than in the tree.
Editorial conclusion
Choose Rebus when your services already follow smart endpoints and dumb pipes, when you want the transport to be a configuration choice rather than an architectural commitment, and when one dependency in your graph is worth more to you than a richer out of the box. Do not choose it expecting routing cleverness, because TypeBased routing hands you the message type and nothing more, and the integration libraries for each transport live in separate repositories you have to pick and maintain yourself. Verify first which of Rebus7.sln or Rebus8.sln matches your runtime, and read LICENSE.md directly, since the README names the MIT License and links LICENSE.md while the repository's own licence metadata names no licence at all.
Frequently asked questions
What is Rebus used for?
It is a lean service bus implementation for .NET, described as a message bus without smarts for asynchronous communication between microservices that follow the smart endpoints, dumb pipes principle. The bus moves messages and the routing decisions stay in application code.
What does Rebus depend on?
The README states as few dependencies as possible, currently only JSON.NET, which it links to the JamesNK/Newtonsoft.Json repository. Everything else, including transports, logging sinks and IoC container adapters, is integrated through separate projects.
How do you configure and start Rebus?
Either construct a RebusBus directly, call bus.Start(1) for a single worker thread and dispose it at shutdown, or use the fluent configuration API, where Configure.With(someContainerAdapter) is followed by Logging, Transport and Routing calls and Start, which registers the IBus as a singleton in the container.
Is Rebus free to use?
The README says Rebus is free as in beer and speech and will stay that way, and it names a commercial add-on, Rebus Pro, for support and tooling. The licence section names The MIT License and points at LICENSE.md, while the project's own licence metadata names no licence at all.
Official sources
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.
[](https://hysenlabs.com/projects/rebus-org-rebus)Star history chart for your README
[](https://hysenlabs.com/projects/rebus-org-rebus)Was this useful?