Akka.NET Bootcamp: the course code without the course

What the bootcamp teaches, in the author's own list

Akka.NET Bootcamp is a free, self-directed learning course brought to you by Petabridge, the company behind Akka.NET. The project page is at learnakka.net and the README calls it version 2.0.

The goals are listed as five numbered items, and they describe a course rather than a library.

First, how, when and why you should use Akka.NET actors for building .NET applications. Second, the basics of Akka.NET syntax and its core API constructs. Third, how to model domains and problems with actors. Fourth, how to test your Akka.NET applications. And fifth, how to integrate Akka.NET with other popular .NET technologies such as ASP.NET Core, SignalR, Microsoft.Extensions, and more.

Reading that list, the shape of the course is clear. It is not a reference for the API surface, it is a course on deciding whether actors are the right tool, then on the syntax, then on domain modelling, then on testing, and finally on fitting actors into an existing .NET application. That last goal is the one that most distinguishes this from a book about actors in the abstract.

The fourth goal is worth separating out, because testing actors is the part that practitioners most often get wrong. The unit descriptions confirm it: Unit 1 explicitly lists Akka.TestKit alongside Akka.Hosting, async and await, dependency injection, actor hierarchies, routers, and handling complex message patterns.

The repository is Apache-2.0 licensed, the primary language is C#, the default branch is master, there are no GitHub releases, and the last push was on 2026-04-13. The copyright line in the README covers 2015 to 2025.

The repository holds the code, the lessons live elsewhere

The README carries an important note that changes what this repository is.

To get the content and the written and video lessons for Akka.NET Bootcamp, you need to sign up at the linked page, and the note ends with the sentence that matters: this repository only contains the source code.

There is a second route, which the README offers in a friendly tone. If you really do not want to receive Akka.NET Bootcamp by email, you can read the lessons online at the bootcamp lessons URL.

So the split is this. The lessons, written and video, are the course, and they are behind a sign-up or a web page. The repository is the code those lessons refer to, and it is open.

For a self-directed course, the code is arguably the more useful half to have open, because a completed solution is a reference you can diff against your own attempt, and a starter project is a starting point. But it is still a repository of solutions rather than a repository of teaching, and the README is honest about that rather than pretending otherwise.

Petabridge is the company behind Akka.NET and sells Akka.NET training, support and consulting, along with tooling such as Phobos, plus free utilities such as Petabridge.Cmd, a CLI for managing Akka.NET applications. So the free course is a funnel to the commercial business, which is a perfectly respectable arrangement and also means the shape of the repository follows from it.

Two units, and a starter plus a completed version of each

The bootcamp is divided into progressive units, each building on the previous, and the current list has two entries.

Unit 0 is Hello World, described as your first Akka.NET application. Unit 1 is AkkaWordCounterv2, which is where the bulk of the teaching lives, and its topic list is Akka.Hosting, Akka.TestKit, async and await, dependency injection, actor hierarchies, routers, and handling complex message patterns.

That Unit 1 list is a compact map of modern Akka.NET practice. Akka.Hosting is how a .NET application hosts an actor system in the current generation of the library, as opposed to the older ActorSystem creation pattern. Akka.TestKit is the testing harness. The rest is the vocabulary of a real actor application: hierarchies, routers, and the message patterns that are harder than a request and a reply.

The instruction for how to use the code is that you should fork or clone the repository, and that each Unit should contain a starter, if necessary, and a completed version of the lesson for you to run. The phrase if necessary is doing some work, so in at least one unit the starter is not provided, which suggests a unit that is a continuation rather than a fresh exercise.

The name AkkaWordCounterv2 is also a hint. The v2 suffix implies an earlier version of the same exercise, and it suggests the exercise has been rewritten, probably to follow the Akka.Hosting pattern rather than the previous setup.

The v1 lessons are still available, in a `legacy-v1` branch of the same repository, which is the migration path for anyone who started the older course.

The toolchain is pinned, and the requirements are two lines

The requirements section is unusually short, and both items matter.

The bootcamp is all written in .NET 9 and leverages Akka.Templates, the project templates repository for Akka.NET. So to run the bootcamp you need .NET 9 installed, and the ability to `git clone` the repository.

The Akka.Templates dependency is worth noticing. It means the code in the repository is not a hand-rolled project structure, it is the output of the template tooling, and so the project layout, the host setup and the dependency wiring follow the conventions the Akka.NET maintainers publish. A reader comparing the bootcamp against their own Akka.NET project will find the structure familiar, and a reader starting a new project will be looking at the recommended shape rather than one person's preferences.

The repository root has a `global.json`, which is the standard way to pin the .NET SDK version for a directory, and it means the build fails fast with a clear message rather than silently using a different SDK that might not compile the code. There is a `unit-0/` and a `unit-1/` directory, an `images/` directory for the README's logo and petabridge graphics, a `.github/` directory, a `LICENSE` and the `README.md`.

That is the whole tree. There is no `src/`, no test project at the root and no continuous integration configuration, which is worth noticing for a project that teaches testing: the course teaches you to test actors, and the course itself does not ship a test suite.

Getting help, and the two channels that exist

The Getting Help section names two routes.

The first is the Akka.NET Discord's `#akka-bootcamp` channel, and the README says to join it if you need help. There is a Discord badge in the README with the server invite and the member count.

The second is the official Akka.NET documentation, or the source code, and the README says you can always check those out.

So the support model is the community Discord plus the upstream documentation, with no issue tracker mentioned as a support channel and no stack overflow of course-specific answers, because there are no course-specific answers without the course.

That is a reasonable design for a free course that a company runs, and it has one implication for a reader: the community channel is the only place where the specific questions of the specific course get answered, and the people who can answer them are the ones who wrote the lessons. That works while the company maintains the course, and it is the reason the README asks you to sign up for the material and updates rather than assuming the repository alone is enough.

The Discord is also where the wider Akka.NET community is, so a question that is really about the framework rather than the course will get answered there too, by users rather than by the maintainers.

Where Akka.NET Bootcamp is the wrong choice

The first wrong case is a developer starting from zero. The lessons are the course, and they are behind a sign-up or a web page. The repository is the code without the explanations, and a solution without the exercise is a solution that teaches you less than it appears to.

The second is a team looking for a maintained reference implementation of Akka.NET. There is no test suite in the repository, there is no continuous integration configuration, there are no GitHub releases, and the last push was on 2026-04-13. The code is course material with a copyright line reading 2015 to 2025, and it is written against .NET 9 and a particular generation of the Akka.NET API. It will show you the idioms of a version, not the current state of the library.

The third is a team that has standardised on a different way of learning. This is a self-directed course with a video and written format, and if your organisation does its onboarding through paired work or an internal curriculum, the value here is mostly the starter projects.

The fourth is a project that has already decided actors are the wrong tool. Goal one of the course is explicitly about when you should and should not use Akka.NET actors, so the material has value there, but the code repository does not.

The fifth is a reader looking for the breadth of the actor model in general. The course is Akka.NET specific, and the ecosystem it teaches is a .NET library rather than the wider family of actor systems, so a reader who wants the ideas rather than the implementation will find the scope narrower than expected.

Editorial conclusion

Akka.NET Bootcamp suits a developer who has already seen the Akka.NET material and wants the runnable solutions to check their work against, or who wants the starter projects to work through the exercises without the sign-up. It does not suit someone starting from nothing, because the lessons themselves are the substance and they sit behind a sign-up, and it does not suit a team that wants a maintained reference implementation, since there is no test suite and no release history beyond tags. Before cloning, read the goals list and check that the topics you want are in Unit 1, because the course is currently two units long, and note that the code is written in .NET 9 with a global.json, so the SDK version is fixed by the repository.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. petabridge/akka-bootcamp on GitHub
4. Project website
5. README