diff --git a/Nixie.Tests/Actors/RouteeActorStruct.cs b/Nixie.Tests/Actors/RouteeActorStruct.cs
new file mode 100644
index 0000000..d00c025
--- /dev/null
+++ b/Nixie.Tests/Actors/RouteeActorStruct.cs
@@ -0,0 +1,60 @@
+
+using Nixie.Routers;
+
+namespace Nixie.Tests.Actors;
+
+public readonly struct RouterMessageStruct : IConsistentHashable
+{
+    public RouterMessageType Type { get; }
+
+    public string Data { get; }
+
+    public RouterMessageStruct(RouterMessageType type, string data)
+    {
+        Type = type;
+        Data = data;
+    }
+
+    public int GetHash()
+    {
+        return Data switch
+        {
+            "aaa" => 0,
+            "bbb" => 1,
+            "ccc" => 2,
+            "ddd" => 3,
+            "eee" => 4,
+            _ => 0
+        };
+    }
+}
+
+public sealed class RouteeActorStruct : IActorStruct<RouterMessageStruct>
+{
+    private int receivedMessages;
+
+    private readonly IActorContextStruct<RouteeActorStruct, RouterMessageStruct> context;
+
+    public RouteeActorStruct(IActorContextStruct<RouteeActorStruct, RouterMessageStruct> context)
+    {
+        this.context = context;
+    }
+
+    public int GetMessages()
+    {
+        return receivedMessages;
+    }
+
+    private void IncrMessage()
+    {
+        receivedMessages++;
+    }
+
+    public async Task Receive(RouterMessageStruct message)
+    {
+        await Task.Yield();
+
+        if (message.Type == RouterMessageType.Route)
+            IncrMessage();
+    }
+}
diff --git a/Nixie.Tests/TestRouters.cs b/Nixie.Tests/TestRouters.cs
index 76d1041..af5f3e4 100644
--- a/Nixie.Tests/TestRouters.cs
+++ b/Nixie.Tests/TestRouters.cs
@@ -35,6 +35,35 @@ public async Task TestCreateRoundRobinRouter()
             Assert.Equal(1, routeeActor.GetMessages());
         }
     }
+    
+    [Fact]
+    public async Task TestCreateRoundRobinRouterStruct()
+    {
+        using ActorSystem asx = new();
+
+        IActorRefStruct<RoundRobinActorStruct<RouteeActorStruct, RouterMessageStruct>, RouterMessageStruct> router =
+            asx.SpawnStruct<RoundRobinActorStruct<RouteeActorStruct, RouterMessageStruct>, RouterMessageStruct>("my-router", 5);
+
+        router.Send(new RouterMessageStruct(RouterMessageType.Route, "aaa"));
+        router.Send(new RouterMessageStruct(RouterMessageType.Route, "bbb"));
+        router.Send(new RouterMessageStruct(RouterMessageType.Route, "ccc"));
+        router.Send(new RouterMessageStruct(RouterMessageType.Route, "ddd"));
+        router.Send(new RouterMessageStruct(RouterMessageType.Route, "eee"));
+
+        await asx.Wait();
+
+        Assert.IsAssignableFrom<RoundRobinActorStruct<RouteeActorStruct, RouterMessageStruct>>(router.Runner.Actor);
+
+        RoundRobinActorStruct<RouteeActorStruct, RouterMessageStruct> routerActor = (RoundRobinActorStruct<RouteeActorStruct, RouterMessageStruct>)router.Runner.Actor!;
+
+        foreach (IActorRefStruct<RouteeActorStruct, RouterMessageStruct> routee in routerActor.Instances)
+        {
+            Assert.IsAssignableFrom<RouteeActorStruct>(routee.Runner.Actor);
+
+            RouteeActorStruct routeeActor = (RouteeActorStruct)routee.Runner.Actor!;
+            Assert.Equal(1, routeeActor.GetMessages());
+        }
+    }
 
     [Fact]
     public async Task TestCreateRoundRobinRouterExt()
diff --git a/Nixie/ActorRepositoryReply.cs b/Nixie/ActorRepositoryReply.cs
index 5d75988..4319296 100644
--- a/Nixie/ActorRepositoryReply.cs
+++ b/Nixie/ActorRepositoryReply.cs
@@ -75,7 +75,7 @@ public bool IsProcessing(out string? actorName)
             {
                 ActorRunner<TActor, TRequest, TResponse> runner = lazyValue.Value.runner;
 
-                if (!runner.IsShutdown && runner.IsProcessing)
+                if (runner is { IsShutdown: false, IsProcessing: true })
                 {
                     actorName = runner.Name;
                     return true;
@@ -110,7 +110,7 @@ public IActorRef<TActor, TRequest, TResponse> Spawn(string? name = null, params
 
         Lazy<(ActorRunner<TActor, TRequest, TResponse> runner, ActorRef<TActor, TRequest, TResponse> actorRef)> actor = actors.GetOrAdd(
             name,
-            (string name) => new Lazy<(ActorRunner<TActor, TRequest, TResponse>, ActorRef<TActor, TRequest, TResponse>)>(() => CreateInternal(name, args))
+            (string _) => new(() => CreateInternal(name, args))
         );
 
         return actor.Value.actorRef;
diff --git a/Nixie/Nixie.csproj b/Nixie/Nixie.csproj
index 0c3b7b7..615d59a 100644
--- a/Nixie/Nixie.csproj
+++ b/Nixie/Nixie.csproj
@@ -9,7 +9,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <PackageId>Nixie</PackageId>
-    <Version>1.0.3</Version>
+    <Version>1.0.4</Version>
     <Description>A Lightweight Actor Model Implementation for C#/.NET</Description>
     <Authors>Andres Gutierrez</Authors>
     <Company>Andres Gutierrez</Company>    
diff --git a/Nixie/Routers/ActorSystemExtensions.cs b/Nixie/Routers/ActorSystemExtensions.cs
index cd5ffec..99dda82 100644
--- a/Nixie/Routers/ActorSystemExtensions.cs
+++ b/Nixie/Routers/ActorSystemExtensions.cs
@@ -159,7 +159,7 @@ List<IActorRef<TActor, TRequest, TResponse>> instances
     }
 
     /// <summary>
-    /// Creates a Round-Robin router specifying number of instances
+    /// Creates a Consistent Hash router specifying name and number of instances
     /// </summary>
     /// <typeparam name="TActor"></typeparam>
     /// <typeparam name="TRequest"></typeparam>
diff --git a/Nixie/Routers/ActorSystemExtensionsStruct.cs b/Nixie/Routers/ActorSystemExtensionsStruct.cs
new file mode 100644
index 0000000..662a308
--- /dev/null
+++ b/Nixie/Routers/ActorSystemExtensionsStruct.cs
@@ -0,0 +1,290 @@
+
+namespace Nixie.Routers;
+
+public static class ActorSystemExtensionsStruct
+{
+    /// <summary>
+    /// Creates a Round-Robin router specifying name and number of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="name"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest> CreateRoundRobinRouterStruct<TActor, TRequest>(
+        this ActorSystem actorSystem,
+        string name,
+        int instances
+    )
+        where TActor : IActorStruct<TRequest> where TRequest : struct
+    {        
+         return actorSystem.SpawnStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest>(name, instances);
+    }
+
+    /// <summary>
+    /// Creates a Round-Robin router specifying number of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest> CreateRoundRobinRouterStruct<TActor, TRequest>(
+        this ActorSystem actorSystem,        
+        int instances
+    )
+        where TActor : IActorStruct<TRequest> where TRequest : struct
+    {
+        return actorSystem.SpawnStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest>(null, instances);
+    }
+
+    /// <summary>
+    /// Creates a Round-Robin router specifying name and a list of routee actors
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="name"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest> CreateRoundRobinRouterStruct<TActor, TRequest>(
+        this ActorSystem actorSystem,
+        string name,
+        List<IActorRefStruct<TActor, TRequest>> instances
+    )
+        where TActor : IActorStruct<TRequest> where TRequest : struct
+    {
+        return actorSystem.SpawnStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest>(name, instances);
+    }
+
+    /// <summary>
+    /// Creates a Round-Robin router specifying a list of routee actors7uh
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest> CreateRoundRobinRouterStruct<TActor, TRequest>(
+        this ActorSystem actorSystem,
+        List<IActorRefStruct<TActor, TRequest>> instances
+    )
+        where TActor : IActorStruct<TRequest> where TRequest : struct
+    {
+        return actorSystem.SpawnStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest>(null, instances);
+    }
+
+    /// <summary>
+    /// Creates a Round-Robin router specifying name and number of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TResponse"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="name"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>
+        CreateRoundRobinRouterStruct<TActor, TRequest, TResponse>(
+            this ActorSystem actorSystem,
+            string name,
+            int instances
+        )
+        where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct where TResponse : struct
+    {
+        return actorSystem.SpawnStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>(name, instances);
+    }
+
+    /// <summary>
+    /// Creates a Round-Robin router specifying name and number of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TResponse"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>
+        CreateRoundRobinRouter<TActor, TRequest, TResponse>(
+            this ActorSystem actorSystem,
+            int instances
+        )
+        where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct where TResponse : struct
+    {
+        return actorSystem.SpawnStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>(null, instances);
+    }
+
+    /// <summary>
+    /// Creates a Round-Robin router specifying name and a list of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TResponse"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="name"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>
+        CreateRoundRobinRouterStruct<TActor, TRequest, TResponse>(
+            this ActorSystem actorSystem,
+            string name,
+            List<IActorRefStruct<TActor, TRequest, TResponse>> instances
+        )
+        where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct where TResponse : struct
+    {
+        return actorSystem.SpawnStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>(name, instances);
+    }
+
+    /// <summary>
+    /// Creates a Round-Robin router specifying name and a list of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TResponse"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>
+        CreateRoundRobinRouterStruct<TActor, TRequest, TResponse>(
+            this ActorSystem actorSystem,
+            List<IActorRefStruct<TActor, TRequest, TResponse>> instances
+        )
+        where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct where TResponse : struct
+    {
+        return actorSystem.SpawnStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>(null, instances);
+    }
+    
+    /// <summary>
+    /// Creates a Consistent Hash router specifying name and number of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="name"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest> CreateConsistentHashRouterStruct<TActor, TRequest>(
+        this ActorSystem actorSystem,
+        string name,
+        int instances
+    )
+        where TActor : IActorStruct<TRequest> where TRequest : struct, IConsistentHashable
+    {
+        return actorSystem.SpawnStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest>(name, instances);
+    }
+    
+    /// <summary>
+    /// Creates a Consistent Hash router specifying name and number of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest> CreateConsistentHashRouterStruct<TActor, TRequest>(
+        this ActorSystem actorSystem,
+        int instances
+    )
+        where TActor : IActorStruct<TRequest> where TRequest : struct, IConsistentHashable
+    {
+        return actorSystem.SpawnStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest>(null, instances);
+    }
+    
+    /// <summary>
+    /// Creates a Consistent Hash router specifying name and number of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TResponse"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>
+        CreateConsistentHashRouterStruct<TActor, TRequest, TResponse>(
+            this ActorSystem actorSystem,
+            int instances
+        )
+        where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct, IConsistentHashable where TResponse : struct
+    {
+        return actorSystem.SpawnStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>(null, instances);
+    }
+    
+     /// <summary>
+    /// Creates a Consistent Hash router specifying name and a list of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest> CreateConsistentHashRouterStruct<TActor, TRequest>(
+        this ActorSystem actorSystem,
+        List<IActorRefStruct<TActor, TRequest>> instances
+    )
+        where TActor : IActorStruct<TRequest> where TRequest : struct, IConsistentHashable
+    {
+        return actorSystem.SpawnStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest>(null, instances);
+    }
+
+    /// <summary>
+    /// Creates a Consistent Hash router specifying name and number of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TResponse"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="name"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>
+        CreateConsistentHashRouterStruct<TActor, TRequest, TResponse>(
+            this ActorSystem actorSystem,
+            string name,
+            int instances
+        )
+        where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct, IConsistentHashable where TResponse : struct
+    {
+        return actorSystem.SpawnStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>(name, instances);
+    }
+
+    /// <summary>
+    /// Creates a Consistent Hash router specifying name and a list of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TResponse"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="name"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>
+        CreateConsistentHashRouterStruct<TActor, TRequest, TResponse>(
+            this ActorSystem actorSystem,
+            string name,
+            List<IActorRefStruct<TActor, TRequest, TResponse>> instances
+        )
+        where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct, IConsistentHashable where TResponse : struct
+    {
+        return actorSystem.SpawnStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>(name, instances);
+    }
+
+    /// <summary>
+    /// Creates a Consistent Hash router specifying name and a list of instances
+    /// </summary>
+    /// <typeparam name="TActor"></typeparam>
+    /// <typeparam name="TRequest"></typeparam>
+    /// <typeparam name="TResponse"></typeparam>
+    /// <param name="actorSystem"></param>
+    /// <param name="instances"></param>
+    /// <returns></returns>
+    public static IActorRefStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>
+        CreateConsistentHashRouterStruct<TActor, TRequest, TResponse>(
+            this ActorSystem actorSystem,
+            List<IActorRefStruct<TActor, TRequest, TResponse>> instances
+        )
+        where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct, IConsistentHashable where TResponse : struct
+    {
+        return actorSystem.SpawnStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse>(null, instances);
+    }
+}
\ No newline at end of file
diff --git a/Nixie/Routers/ConsistentHashActorStruct.cs b/Nixie/Routers/ConsistentHashActorStruct.cs
new file mode 100644
index 0000000..5d245db
--- /dev/null
+++ b/Nixie/Routers/ConsistentHashActorStruct.cs
@@ -0,0 +1,57 @@
+
+namespace Nixie.Routers;
+
+/// <summary>
+/// Utilizes consistent hashing to choose a routee based on the transmitted message.
+/// </summary>
+/// <typeparam name="TActor"></typeparam>
+/// <typeparam name="TRequest"></typeparam>
+public class ConsistentHashActorStruct<TActor, TRequest> : IActorStruct<TRequest>
+    where TActor : IActorStruct<TRequest> where TRequest : struct, IConsistentHashable
+{
+    private readonly IActorContextStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest> context;
+
+    private readonly List<IActorRefStruct<TActor, TRequest>> instances = new();
+
+    /// <summary>
+    /// Returns the list of instances
+    /// </summary>
+    public List<IActorRefStruct<TActor, TRequest>> Instances => instances;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="numberInstances"></param>
+    public ConsistentHashActorStruct(IActorContextStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest> context, int numberInstances)
+    {
+        this.context = context;
+
+        for (int i = 0; i < numberInstances; i++)
+            instances.Add(context.ActorSystem.SpawnStruct<TActor, TRequest>());
+    }
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="instances"></param>
+    public ConsistentHashActorStruct(IActorContextStruct<ConsistentHashActorStruct<TActor, TRequest>, TRequest> context, List<IActorRefStruct<TActor, TRequest>> instances)
+    {
+        this.context = context;
+        this.instances = instances;
+    }
+
+    /// <summary>
+    /// Receives a message that must be routed to one of the routees
+    /// </summary>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    public Task Receive(TRequest message)
+    {        
+        IActorRefStruct<TActor, TRequest> instance = instances[message.GetHash() % instances.Count];
+        instance.Send(message);
+
+        return Task.CompletedTask;
+    }
+}
\ No newline at end of file
diff --git a/Nixie/Routers/ConsistentHashActorStructReply.cs b/Nixie/Routers/ConsistentHashActorStructReply.cs
new file mode 100644
index 0000000..f74a106
--- /dev/null
+++ b/Nixie/Routers/ConsistentHashActorStructReply.cs
@@ -0,0 +1,58 @@
+
+namespace Nixie.Routers;
+
+/// <summary>
+/// Utilizes consistent hashing to choose a routee based on the transmitted message.
+/// </summary>
+/// <typeparam name="TActor"></typeparam>
+/// <typeparam name="TRequest"></typeparam>
+public class ConsistentHashActorStruct<TActor, TRequest, TResponse> : IActorStruct<TRequest, TResponse>
+    where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct, IConsistentHashable where TResponse : struct
+{
+    private readonly IActorContextStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse> context;
+
+    private readonly List<IActorRefStruct<TActor, TRequest, TResponse>> instances = new();
+
+    /// <summary>
+    /// Returns the list of instances
+    /// </summary>
+    public List<IActorRefStruct<TActor, TRequest, TResponse>> Instances => instances;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="numberInstances"></param>
+    public ConsistentHashActorStruct(IActorContextStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse> context, int numberInstances)
+    {
+        this.context = context;
+
+        for (int i = 0; i < numberInstances; i++)
+            instances.Add(context.ActorSystem.SpawnStruct<TActor, TRequest, TResponse>());
+    }
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="instances"></param>
+    public ConsistentHashActorStruct(IActorContextStruct<ConsistentHashActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse> context, List<IActorRefStruct<TActor, TRequest, TResponse>> instances)
+    {
+        this.context = context;
+        this.instances = instances;
+    }
+
+    /// <summary>
+    /// Receives a message that must be routed to one of the routees
+    /// </summary>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    public Task<TResponse> Receive(TRequest message)
+    {
+        int bucket = Math.Abs(message.GetHash()) % instances.Count;
+        IActorRefStruct<TActor, TRequest, TResponse> instance = instances[bucket];
+        context.ByPassReply = true; // Marks the response to be bypassed so other actor can reply
+        instance.Send(message, context.Reply);
+        return Task.FromResult((TResponse)default);
+    }
+}
diff --git a/Nixie/Routers/RoundRobinActorReply.cs b/Nixie/Routers/RoundRobinActorReply.cs
index 7040e21..e52e00e 100644
--- a/Nixie/Routers/RoundRobinActorReply.cs
+++ b/Nixie/Routers/RoundRobinActorReply.cs
@@ -6,7 +6,7 @@ namespace Nixie.Routers;
 /// each actor receives one message.
 /// 
 /// The round robin method offers equitable distribution, with each routee receiving an equal number of messages
-/// when the group remains relatively constant.However, if there are frequent changes in the group of routees,
+/// when the group remains relatively constant. However, if there are frequent changes in the group of routees,
 /// the distribution might not be as balanced.
 /// </summary>
 /// <typeparam name="TActor"></typeparam>
diff --git a/Nixie/Routers/RoundRobinActorStruct.cs b/Nixie/Routers/RoundRobinActorStruct.cs
new file mode 100644
index 0000000..594ca6a
--- /dev/null
+++ b/Nixie/Routers/RoundRobinActorStruct.cs
@@ -0,0 +1,68 @@
+namespace Nixie.Routers;
+
+/// <summary>
+/// The router cycles through the group of routees, ensuring that for every n messages sent,
+/// each actor receives one message.
+/// 
+/// The round robin method offers equitable distribution, with each routee receiving an equal number of messages
+/// when the group remains relatively constant.However, if there are frequent changes in the group of routees,
+/// the distribution might not be as balanced.
+/// </summary>
+/// <typeparam name="TActor"></typeparam>
+/// <typeparam name="TRequest"></typeparam>
+public class RoundRobinActorStruct<TActor, TRequest> : IActorStruct<TRequest>
+    where TActor : IActorStruct<TRequest> where TRequest : struct
+{
+    private int position = -1;
+
+    private readonly IActorContextStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest> context;
+
+    private readonly List<IActorRefStruct<TActor, TRequest>> instances = new();
+
+    /// <summary>
+    /// Returns the current list of instances
+    /// </summary>
+    public List<IActorRefStruct<TActor, TRequest>> Instances => instances;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="numberInstances"></param>
+    public RoundRobinActorStruct(IActorContextStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest> context, int numberInstances)
+    {
+        this.context = context;
+
+        for (int i = 0; i < numberInstances; i++)
+            instances.Add(context.ActorSystem.SpawnStruct<TActor, TRequest>());
+    }
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="instances"></param>
+    public RoundRobinActorStruct(IActorContextStruct<RoundRobinActorStruct<TActor, TRequest>, TRequest> context, List<IActorRefStruct<TActor, TRequest>> instances)
+    {
+        this.context = context;
+        this.instances = instances;
+    }
+
+    /// <summary>
+    /// Receives a message that must be routed to one of the routees
+    /// </summary>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    public Task Receive(TRequest message)
+    {        
+        if ((position + 1) >= int.MaxValue)
+            position = 0;
+        else
+            position++;
+
+        IActorRefStruct<TActor, TRequest> instance = instances[position % instances.Count];        
+        instance.Send(message);
+
+        return Task.CompletedTask;
+    }
+}
\ No newline at end of file
diff --git a/Nixie/Routers/RoundRobinActorStructReply.cs b/Nixie/Routers/RoundRobinActorStructReply.cs
new file mode 100644
index 0000000..23ac633
--- /dev/null
+++ b/Nixie/Routers/RoundRobinActorStructReply.cs
@@ -0,0 +1,69 @@
+namespace Nixie.Routers;
+
+/// <summary>
+/// The router cycles through the group of routees, ensuring that for every n messages sent,
+/// each actor receives one message.
+/// 
+/// The round robin method offers equitable distribution, with each routee receiving an equal number of messages
+/// when the group remains relatively constant. However, if there are frequent changes in the group of routees,
+/// the distribution might not be as balanced.
+/// </summary>
+/// <typeparam name="TActor"></typeparam>
+/// <typeparam name="TRequest"></typeparam>
+/// <typeparam name="TResponse"></typeparam>
+public class RoundRobinActorStruct<TActor, TRequest, TResponse> : IActorStruct<TRequest, TResponse>
+    where TActor : IActorStruct<TRequest, TResponse> where TRequest : struct where TResponse : struct
+{
+    private int position = -1;
+
+    private readonly IActorContextStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse> context;
+
+    private readonly List<IActorRefStruct<TActor, TRequest, TResponse>> instances = new();
+
+    /// <summary>
+    /// Returns the current list of instances
+    /// </summary>
+    public List<IActorRefStruct<TActor, TRequest, TResponse>> Instances => instances;
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="numberInstances"></param>
+    public RoundRobinActorStruct(IActorContextStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse> context, int numberInstances)
+    {
+        this.context = context;
+
+        for (int i = 0; i < numberInstances; i++)
+            instances.Add(context.ActorSystem.SpawnStruct<TActor, TRequest, TResponse>());
+    }
+
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="instances"></param>
+    public RoundRobinActorStruct(IActorContextStruct<RoundRobinActorStruct<TActor, TRequest, TResponse>, TRequest, TResponse> context, List<IActorRefStruct<TActor, TRequest, TResponse>> instances)
+    {
+        this.context = context;
+        this.instances = instances;
+    }
+
+    /// <summary>
+    /// Receives a message that must be routed to one of the routees
+    /// </summary>
+    /// <param name="message"></param>
+    /// <returns></returns>
+    public Task<TResponse> Receive(TRequest message)
+    {
+        if ((position + 1) >= int.MaxValue)
+            position = 0;
+        else
+            position++;
+
+        IActorRefStruct<TActor, TRequest, TResponse> instance = instances[position % instances.Count];
+        context.ByPassReply = true; // Marks the response to be bypassed so other actor can reply
+        instance.Send(message, context.Reply);
+        return Task.FromResult((TResponse)default);
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index b37d5a7..2fedde2 100644
--- a/README.md
+++ b/README.md
@@ -35,7 +35,7 @@ To install Nixie into your C#/.NET project, you can use the .NET CLI or the NuGe
 #### Using .NET CLI
 
 ```shell
-dotnet add package Nixie --version 1.0.3
+dotnet add package Nixie --version 1.0.4
 ```
 
 ### Using NuGet Package Manager
@@ -43,7 +43,7 @@ dotnet add package Nixie --version 1.0.3
 Search for Nixie and install it from the NuGet package manager UI, or use the Package Manager Console:
 
 ```shell
-Install-Package Nixie -Version 1.0.3
+Install-Package Nixie -Version 1.0.4
 ```
 
 ## Usage