Catching Up with Recent Wolverine Releases

Wolverine has had a very frequent release cadence the past couple months as community contributions, requests from JasperFx Software clients, and yes, sigh, bug reports have flowed in. Right now I think I can justifiably claim that Wolverine is innovating much faster than any of the other comparable tools in the .NET ecosystem.

Some folks clearly don’t like that level of change of course, and I’ve always had to field some only criticism for our frequency of releases. I don’t think that continues forever of course.

I thought that now would be a good time to write a little bit about the new features and improvements just because so much of it happened over the holiday season. Starting somewhat arbitrarily with the first of December to now…

Inferred Message Grouping in Wolverine 5.5

A massively important new feature in Wolverine 5 was our “Partitioned Sequential Messaging” that seeks to effectively head off problems with concurrent message processing by segregating message processing by some kind of business entity identity. Long story short, this feature can almost completely eliminate issues with concurrent access to data without eliminating parallel processing across unrelated messages.

In Wolverine 5.5 we added the now obvious capability to let Wolverine automatically infer the messaging group id for messages handled by a Saga (the saga identity) or with the Aggregate Handler Workflow (the stream id of the primary event stream being altered in the handler):

// Telling Wolverine how to assign a GroupId to a message, that we'll use
// to predictably sort into "slots" in the processing
opts.MessagePartitioning
        
    // This tells Wolverine to use the Saga identity as the group id for any message
    // that impacts a Saga or the stream id of any command that is part of the "aggregate handler workflow"
    // integration with Marten
    .UseInferredMessageGrouping()
    
    .PublishToPartitionedLocalMessaging("letters", 4, topology =>
    {
        topology.MessagesImplementing<ILetterMessage>();
        topology.MaxDegreeOfParallelism = PartitionSlots.Five;
        
        topology.ConfigureQueues(queue =>
        {
            queue.BufferedInMemory();
        });
    });

“Classic” .NET Domain Events with EF Core in Wolverine 5.6

Wolverine is attracting a lot of new users lately who might honestly only have been originally interested because of other tool’s recent licensing changes, and those users tend to come with a more typical .NET approach to application architecture than Wolverine’s idiomatic vertical slice architecture approach. These new users are also a lot more likely to be using EF Core than Marten, so we’ve had to invest more in EF Core integration.

Wolverine 5.6 brought an ability to cleanly and effectively utilize a traditional .NET approach for “Domain Event” publishing through EF Core to Wolverine’s messaging.

I wrote about that at the time in “Classic” .NET Domain Events with Wolverine and EF Core.

Wolverine 5.7 Knocked Out Bugs

There wasn’t many new features of note, but Wolverine 5.7 less than a week after 5.6 had five contributors and knocked out a dozen issues. The open issue count in Wolverine crested in December in the low 70’s and it’s down to the low 30’s right now.

Client Requests in Wolverine 5.8

Wolverine 5.8 gave us some bug fixes, but also a couple new features requested by JasperFx clients:

• A new command line tool to dump out the “service capabilities” of the system. This client is using that with a Verify test just to detect any accidental changes in configuration of a very large Wolverine system.
• The ability to send raw binary message data with Wolverine. This was a client request to integrate with their existing job scheduling tooling.

The Community Went Into High Gear with Wolverine 5.9

Wolverine 5.9 dropped the week before Christmas with contributions from 7 different people.

The highlights are:

• Sandeep Desai has been absolutely on fire as a contributor to Wolverine and he made the HTTP Messaging Transport finally usable in this release with several other pull requests in later versions that also improved that feature. This is enabling Wolverine to use HTTP as a messaging transport. I’ve long wanted this feature as a prerequisite for CritterWatch.
• Lodewijk Sioen added Wolverine middleware support for using Data Annotations with Wolverine.HTTP
• The Rabbit MQ integration got more robust about reconnecting on errors

Wolverine 5.10 Kicked off 2026 with a Bang!

Wolverine 5.10 came out last week with contributions from eleven different folks. Plenty of bug fixes and contributions built up over the holidays. The highlights include:

• A long requested NATS.io backed messaging transport option from thedonmon.
• Daniel Winkler added the ability to connect to existing GCP subscriptions
• We got a perfectly normal contribution to add integration with Azure SignalR to our SignalR support
• Sandeep Desai added support for native Redis message scheduling to our integration

And several random requests for JasperFx clients because that’s something we do to support our clients.

Wolverine 5.11 adds More Idempotency Options

Wolverine 5.11 dropped this week with more bug fixes and new capabilities from five contributors. The big new feature was an improved option for enforcing message idempotency on non-transactional handlers as a request from a JasperFx support client.

using var host = await Host.CreateDefaultBuilder()
    .UseWolverine(opts =>
    {
        opts.Durability.Mode = DurabilityMode.Solo;
        
        opts.Services.AddDbContextWithWolverineIntegration<CleanDbContext>(x =>
            x.UseSqlServer(Servers.SqlServerConnectionString));
        
        opts.Services.AddResourceSetupOnStartup(StartupAction.ResetState);
        
        opts.Policies.AutoApplyTransactions(IdempotencyStyle.Eager);
        opts.PersistMessagesWithSqlServer(Servers.SqlServerConnectionString, "idempotency");
        opts.UseEntityFrameworkCoreTransactions();
        
        // THIS RIGHT HERE
        opts.Policies.AutoApplyIdempotencyOnNonTransactionalHandlers();
    }).StartAsync();

That release also included several bug fixes and an effort from me to go fill in some gaps in the documentation website. That release got us down to the lowest open issue count in years.

Summary

The Wolverine community has been very busy, it is actually a community of developers from all over the world, and we’re improving fast.

I do think that the release cadence will slow down somewhat though as this has been an unusual burst of activity.