OrleansContrib/Orleankka

This system is a .NET-based actor framework built on top of Microsoft Orleans, providing a structured approach to building distributed, scalable applications using the actor model. It offers a comprehensive toolkit for managing actor lifecycles, hierarchical state machines, and background jobs, while also supporting HTTP-based RPC and streaming capabilities. The codebase includes a robust test kit for mocking and verifying actor interactions, alongside a collection of samples demonstrating event sourcing, finite state machines, and chat applications.

12 changes.

The project was updated to target .NET 9.0 and Microsoft Orleans 9.0.1, modernizing the build system and project structure. A major focus was the introduction of strongly-typed actor references, a comprehensive testkit for unit testing, and a refactored runtime supporting hierarchical state machines and middleware pipelines.

20 changes.

This period focused on modernizing the Orleankka framework and its samples to align with current Orleans idioms, particularly the adoption of IGrainWithStringKey and modern HostBuilder patterns. Concurrently, extensive test coverage was added for the core library and test kit, while new samples demonstrated streaming, FSM, and Blazor integration.

9 changes.

This period focused on introducing a legacy actor runtime with declarative behavior management and state machines. It also added HTTP-based remote procedure call support for actors, enabling HTTP RPC routing and client-side middleware registration. The work was accompanied by comprehensive test coverage for these new features.

The FSM sample now includes a complete Blazor web application that provides a dashboard for managing and monitoring file copy jobs. Users can start, restart, suspend, continue, and cancel jobs via a web UI, with real-time updates on job status, progress, and state changes streamed from the Orleans cluster. The sample demonstrates durable state management using a custom file-based storage provider and integrates with the Orleankka actor framework to showcase a full-stack .NET Core 3.0 preview5 application.

Samples/CSharp/FSM/ProcessManager · high confidence

The demo application has been restored and reorganized to demonstrate the use of Orleans and Orleankka. The new files introduce a complete sample project including an Api actor that implements a circuit breaker pattern to handle intermittent API failures, a Topic actor that manages scheduled queries and retry logic, and storage utilities for persisting data to Azure Blob Storage. The application also includes configuration for the .NET runtime and a console-based logging utility.

Samples/CSharp/Demo/Demo.App · high confidence

A new Chat sample application has been added to the Samples/CSharp/Streams directory, featuring both a server and client implementation. The server (Chat.Server) configures an Orleans host with memory-based pub/sub streams, while the client (Chat.Client) connects to the cluster, subscribes to message streams, and allows users to join chat rooms, send messages, and handle reconnection scenarios. This sample demonstrates the use of Orleankka for actor-based messaging and Orleans streams for real-time communication.

Samples/CSharp/Streams/Chat.Server · high confidence

Introduces a new HTTP transport layer for Orleankka actors, enabling HTTP RPC calls. The change adds several new classes in the \Orleankka.Http\ namespace: \HttpActorSystem\ and \HttpActorEndpoint\ handle the HTTP client interactions and routing, while \ActorRouteMapper\ and \ActorRouteMapping\ manage the mapping of actor interfaces and messages to HTTP routes. This allows actors to be invoked via HTTP requests, with JSON serialization for request and response bodies.

Source/Orleankka/Http · high confidence

A new Extensions class has been added to the Orleankka.TestKit.Meta namespace, providing helper methods for testing actor interactions. These extensions allow test code to easily verify received commands, queries, and events on mock objects, including methods to check if no commands or queries were received, and to retrieve the first or all instances of specific command, query, or event types.

Source/Orleankka.TestKit/Meta · high confidence

Introduced a new \LegacyOrleankkaClusterOptions\ class and associated \IHostBuilder\ extension methods (\UseOrleankkaLegacyFeatures\) to configure the legacy runtime. This change enables automatic discovery and registration of actor behaviors for all classes inheriting from \Actor\ within the relevant assemblies, simplifying the setup process for legacy features.

Source/Orleankka.Legacy.Runtime/Cluster · medium confidence

A new shared utility file (Shared.cs) was added to the C\# samples, introducing a static extension method that configures an Orleans host with localhost clustering, in-memory grain storage, and in-memory reminder and pub/sub stores, providing a simplified setup for the demo applications.

Samples/CSharp · high confidence

The Orleankka.TestKit library has been completely rewritten to provide a fluent, mockable API for unit testing Orleans applications. The diff introduces a suite of new mock classes that simulate the Orleans runtime environment, including ActorRefMock for simulating actor message passing (Tell, Ask, Notify) with expectation matching, StreamRefMock for pub/sub stream interactions, and service mocks for Timers, Reminders, Background Jobs, and Activation. These components allow developers to verify message flow, set up expectations, and inspect recorded interactions without needing a live Orleans cluster.

Source/Orleankka.TestKit · high confidence

A new \ClientActorSystem\ class and \IClientActorSystem\ interface have been added to the \Orleankka.Client\ package, providing a client-side actor system that integrates with Orleans' \IClusterClient\ and \IGrainFactory\. This change enables client applications to interact with Orleans grains through a dedicated actor system, supporting observable patterns via \IClientObservable\.

Source/Orleankka/Client · high confidence

The Orleankka runtime now registers a new ClusterActorSystem that automatically scans assemblies to discover and register actor grains, wiring them into the dependency injection container alongside default middlewares and a dispatcher registry. Additionally, a new DashboardIntegration component is introduced to format and display actor method invocation details in the dashboard, enhancing observability for cluster-based actor systems.

Source/Orleankka.Runtime/Cluster · medium confidence

The library now supports strongly-typed actor references and messages. A new \ActorRef\<TActor\>\ generic class provides type-safe interaction with actors, ensuring compile-time validation of message types. Correspondingly, \ActorMessage\<TActor\>\ and \ActorMessage\<TActor, TResult\>\ interfaces define the structure for strongly-typed messages, including helper methods like \Result\ and \TaskResult\ to simplify response building. The \ActorPath\ and \StreamPath\ classes have been introduced to manage actor and stream identification consistently. Additionally, a middleware pipeline (\IActorRefMiddleware\) has been added to allow interception and modification of actor messages, enhancing extensibility.

Source/Orleankka · high confidence

Added the core implementation for actor behavior management in the legacy runtime. The new \ActorBehavior\ class manages the state machine, including \Become\ and \Super\ transitions, lifecycle hooks (Activate/Deactivate), and message handling. \CustomBehavior\ stores the configuration for each behavior state, and \Transition\ captures state change details. Extension methods on \Actor\ (in \BehaviorExtensions\) provide a fluent API for setting initial behaviors, switching states, and registering handlers for reminders, receives, and lifecycle events.

Source/Orleankka.Legacy.Runtime/Behaviors · high confidence

The Orleankka.Legacy.Runtime package now provides a new base Actor class that routes incoming messages to behavior handlers and processes reminders via the OnReminder method. The runtime also includes the Behavior and Trait attributes for declarative configuration, and a LegacyDispatcherExtensions helper for message dispatching.

Source/Orleankka.Legacy.Runtime · medium confidence

The Orleankka.Meta namespace now includes new interfaces for Message, Command, Event, Query, and Result, along with corresponding extension methods on ActorRef and ObserverRef. These changes provide a structured way to handle actor messages and queries, with explicit requirements for actors to implement IGrainWithStringKey. This supports serialization and communication patterns within the Orleankka framework.

Source/Orleankka/Meta · high confidence

The runtime now exposes dedicated services for managing actor activation lifetimes (via IActivationService), scheduling and tracking background jobs (via IBackgroundJobService), and registering local timers (via ITimerService). These new internal services provide the underlying mechanisms for actor deactivation, non-interleaved background task execution, and one-shot or periodic timer callbacks within the Orleans runtime.

Source/Orleankka.Runtime/Services · high confidence

The Orleankka library now includes a new \Orleankka.Utility\ namespace containing static helper classes. \Requires\ provides assertion methods (\NotNull\, \NullOrWhitespace\) that throw exceptions for invalid arguments, annotated with ReSharper attributes to improve static analysis. \DictionaryExtensions\ adds a \Find\ method to \IDictionary\ for safe, null-safe lookups. Additionally, \Annotations.cs\ introduces internal ReSharper-style attributes (e.g., \NotNull\, \AssertionMethod\) to support these utility classes.

Source/Orleankka/Utility · high confidence

The Orleankka.Http.AspNetCore library now supports HTTP-based remote procedure calls. A new RoutingExtensions class provides a MapActors method that maps HTTP routes to actor messages, allowing clients to send requests via HTTP GET and POST to specific actor endpoints. The implementation handles request deserialization, actor invocation, and response serialization, with appropriate HTTP status codes for not found and internal server errors.

Source/Orleankka.Http.AspNetCore · medium confidence

The Orleankka.Client package now registers default middleware for both actors and streams (DefaultActorRefMiddleware and DefaultStreamRefMiddleware) via the new ClientBuilderExtension. Users calling UseOrleankka on their IHostBuilder will automatically have these middleware components added to the service container, enabling standard actor and stream reference handling in the client.

Source/Orleankka.Client · medium confidence

The Orleankka library now explicitly grants access to its internal members for specific test and runtime assemblies (Orleankka.Tests, Orleankka.TestKit, Orleankka.Runtime, Orleankka.FSharp, and Orleankka.Legacy.Runtime) via the new AssemblyInfo.cs file. This allows those assemblies to access internal APIs, which is typically required for unit testing or runtime integration.

Source/Orleankka/Properties · high confidence

The Orleankka runtime now supports a hierarchical state machine model where actors can transition between named states with support for stacking and unstacking behaviors. Users can define state hierarchies using a builder API, allowing for super/substate relationships and trait-based behavior composition. The system enforces valid state transitions, prevents illegal state switching, and provides introspection capabilities for debugging. This replaces the previous flat behavior model with a more structured approach to managing actor lifecycle and message handling.

Source/Orleankka.Runtime/Behaviors · medium confidence

The Orleankka.Runtime library now explicitly grants access to its internal members for the Orleankka.Tests, Orleankka.Azure, Orleankka.TestKit, and Orleankka.Legacy.Runtime assemblies. This change enables these specific packages to access internal implementation details, which may affect how tests are written or how legacy components interact with the runtime.

Source/Orleankka.Runtime/Properties · high confidence

The HelloWorld sample has been updated to align with Orleans 2.1 idioms, including the adoption of the modern HostBuilder pattern for cluster setup and the explicit requirement of IGrainWithStringKey. The sample now includes an App.config to configure GC settings and uses the Orleankka library for actor-based communication, replacing the previous static cluster setup code.

Samples/CSharp/HelloWorld · medium confidence

The Reentrant sample in Samples/CSharp/Reentrant has been reorganized and updated to align with current Orleans idioms. The demo now explicitly requires the IGrainWithStringKey interface on the grain, addressing issue \#148. The project structure has been reorganized to match upstream conventions, and all compilation errors have been fixed. The sample now includes an App.config for runtime settings and a Program.cs entry point that demonstrates reentrant grain behavior with a reader-writer lock pattern.

Samples/CSharp/Reentrant · medium confidence

The Orleankka runtime has been refactored to use a new \ActorGrain\ base class that implements Orleans' \IGrainContext\ and \IConfigureGrainContext\ interfaces, replacing the previous activation model. This change introduces a new \ActorMiddleware\ pipeline for intercepting and processing messages, allowing for more flexible message handling. Additionally, a \Dispatcher\ class has been added to handle message routing based on naming conventions, and specific message types like \Reminder\ and \Timer\ have been introduced to support background jobs and timers. These changes alter how actors are activated and how messages are processed, potentially requiring updates to existing actor implementations to inherit from \ActorGrain\ or \DispatchActorGrain\ and configure the new middleware pipeline.

Source/Orleankka.Runtime · medium confidence

The project has been updated to target .NET 9.0 and Microsoft Orleans 9.0.1, with all related NuGet package versions (including Microsoft.Extensions.\* and testing libraries) aligned to 9.0.1. The solution now uses a centralized Directory.Build.props file to manage these versions and common build properties, replacing the previous per-project configuration approach.

(repo-wide) · high confidence

The Streamstone persistence sample has been updated to explicitly require IGrainWithStringKey on the IInventoryItem actor interface, aligning with current Orleans idioms. The sample's domain model, infrastructure, and message definitions have been reorganized to match upstream conventions, and the project structure has been updated to version 2.0.0-RC of the Streamstone library.

Samples/CSharp/EventSourcing/Persistence/Streamstone · medium confidence

The chat application's message models (Join, Leave, Say, and ChatRoomMessage) have been updated to include Orleans serialization attributes (\[Serializable\], \[GenerateSerializer\], and \[Id\]). This ensures that these message types are correctly serialized and deserialized by the Orleans framework, resolving the issue where IGrainWithStringKey was not being explicitly required.

Samples/CSharp/Streams/Chat.Shared · medium confidence

The Idiomatic C\# sample has been restructured to align with current Orleans idioms and terminology. The example now explicitly requires IGrainWithStringKey, utilizes the Orleans 8.0.0 serialization attributes (\[GenerateSerializer\], \[Id\]), and implements a streaming-based event sourcing pattern where domain events are published to a stream provider. The sample demonstrates creating, renaming, checking in/out, and deactivating inventory items, with an inventory dispatcher that subscribes to these events to maintain a global stock level.

Samples/CSharp/EventSourcing/Idiomatic · medium confidence

The C\# Observers sample has been updated to target Orleans 2.0, migrating from the legacy \OrleansHost\ to the modern \HostBuilder\ pattern for both the client and server applications. The chat room grain interface now explicitly requires \IGrainWithStringKey\, and message classes use the \GenerateSerializer\ attribute for serialization. Additionally, the client application now connects to the cluster using the new \UseOrleansClient\ API, and the sample includes configuration for the .NET runtime GC server.

Samples/CSharp/Observers · high confidence

The Lightbulb sample has been reorganized and simplified to follow current Orleans and Orleankka patterns. The ILightbulb grain interface now explicitly inherits from IGrainWithStringKey, and the Lightbulb class inherits from ActorGrain. The sample code has been streamlined, removing explicit binding redirects and updating the project structure to match upstream conventions.

Samples/CSharp/FSM/Lightbulb · medium confidence

The GES sample has been updated to explicitly require IGrainWithStringKey on the IInventoryItem interface, aligning the code with current Orleankka idioms and fixing compilation errors. The sample now demonstrates event sourcing with an inventory item that supports creation, renaming, stock adjustments, and deactivation, persisting state to an EventStore instance.

Samples/CSharp/EventSourcing/Persistence/GES · medium confidence

Add tests for legacy actor behavior features; Added C\# 9 compatibility shim for internal static class; Added test fixtures for Orleankka TestKit mocks; Added test infrastructure for Orleans serialization and silo lifecycle management; Added tests for HTTP RPC actor routing and serialization; Added tests for actor behavior lifecycle, state transitions, and trait composition; Added tests for actor identity, background jobs, lifecycle, request/response, reminders, streams, and more; Added unit tests for core Orleankka types; Added unit tests for the Demo application's core components.

The project has been reorganized into the modern .csproj format, introducing separate packages for the client, runtime, and test kit, alongside a legacy runtime package. The samples are now structured into distinct projects for features like event sourcing, finite state machines, and streams, each referencing the appropriate Orleankka and Microsoft.Orleans packages. This change simplifies the build process and aligns the codebase with current .NET standards.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 51 → 44 (-7.0)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 51 → 35 (-15.2)
• Architecture 97 → 97 (+0.0)
• Maturity 46 → 46 (+0.0)
• Readiness 46 → 44 (-2.0)
• Security 100 → 76 (-23.4)
• Performance 54 → 54 (+0.0)

• Bounded contexts not declared
• Change coupling: ActivationService.cs ↔ TimerService.cs (Source/Orleankka.Runtime/Services/ActivationService.cs)
• Duplicated block (12 lines × 2) (Samples/CSharp/EventSourcing/Idiomatic/Program.cs)
• Duplicated block (13 lines × 2) (Samples/CSharp/Streams/Chat.Client/Program.cs)
• Duplicated block (9 lines × 2) (Source/Orleankka.Runtime/Dispatcher.cs)
• Low XML-doc coverage: Orleankka.TestKit (Source/Orleankka.TestKit/Orleankka.TestKit.csproj)
• No exposed public API
• Scanner failed to run — not a clean result
• The README is largely feature-driven and install-focused, with no dedicated Examples or Usage section for the core message-based API. (README.md)
• The README mentions Orleankka's YouTube references and a slide link but does not cite any source material or include links to the actual documentation (e.g. features page) that it claims to be based on. (README.md)
• dormant codebase — no living knowledge left to concentrate

• Change coupling: ActorPath.cs ↔ StreamPath.cs (Source/Orleankka/ActorPath.cs)
• Documentation: no architecture or design documentation (README.md)
• Duplicated block (10 lines × 2) (Samples/CSharp/EventSourcing/Idiomatic/Program.cs)
• Duplicated block (105 lines × 3) (Samples/CSharp/EventSourcing/Idiomatic/Messages.cs)
• Duplicated block (11 lines × 4) (Source/Orleankka.Runtime/Dispatcher.cs)
• Duplicated block (13–14 lines × 2) (Samples/CSharp/Observers/Chat.Client/Program.cs)
• Duplicated block (16 lines × 2) (Samples/CSharp/EventSourcing/Idiomatic/Program.cs)
• Duplicated block (17 lines × 2) (Samples/CSharp/EventSourcing/Persistence/GES/Infrastructure.cs)
• Duplicated block (76 lines × 2) (Samples/CSharp/EventSourcing/Persistence/GES/Domain.cs)
• Duplicated block (8 lines × 2) (Samples/CSharp/EventSourcing/Persistence/GES/Infrastructure.cs)
• Duplicated block (8 lines × 2) (Samples/CSharp/EventSourcing/Persistence/GES/Program.cs)
• High secret: WD-SECRET-0003 (Source/Orleans.Internals/Orleans.snk)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (Source/Orleankka.Runtime/Dispatcher.cs)
• No SBOM
• No artifact signing
• No assertions: When_running_failing_one_off_job (Tests/Orleankka.Tests/Features/Background_jobs.cs)
• No assertions: When_running_one_off_job (Tests/Orleankka.Tests/Features/Background_jobs.cs)
• No assertions: When_sending_interleaved_fire_and_forget_message (Tests/Orleankka.Tests/Features/Message_based_timers.cs)
• No assertions: When_sending_non_interleaved_fire_and_forget_message (Tests/Orleankka.Tests/Features/Message_based_timers.cs)
• No assertions: When_setting_interleaved_one_off_timer (Tests/Orleankka.Tests/Features/Message_based_timers.cs)
• …and 9 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

OrleansContrib/Orleankka was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.