Appearance
The Fastest .NET RPC Libraries vs the Fastest gRPC Libraries
Published: 2026-11-16 by Alex Yakunin

Disclosure: I am the author of ActualLab.Rpc and of
RpcBenchmark, so I am not a neutral party, and Claude helped write some of the conclusions. The code is open source, and I welcome you to read it, run it and check the results. What I did to keep the comparison fair is in Disclosure and Fairness.
grpc_bench is the best-known public benchmark of gRPC server implementations: dozens of servers in about a dozen languages, each built from its own Dockerfile and loaded with the same unary call. My own RpcBenchmark uses the same message and the same 4-CPU server setup, but until now I compared ActualLab.Rpc, the RPC library Fusion is built on, only with other .NET libraries.
For this post I ran 26 gRPC servers from grpc_bench on the machine I use for my benchmarks and measured how many calls each can handle on 4 CPUs. Then I ran the RPC libraries for .NET that RpcBenchmark covers (ActualLab.Rpc, SignalR, grpc-dotnet, MagicOnion, StreamJsonRpc and a plain HTTP API) in the same setup, so both groups can be put into one table. Finally, I repeated the tests over a 5 Gbps LAN, with a 2-CPU server and the client on a separate PC. The raw data, including every load shape I tried, is in Benchmarks-gRPC.md; the ActualLab.Rpc side is in Benchmarks.md (local) and Benchmarks.md (LAN).
What Was Tested
- The call: grpc_bench's
complex_protoscenario, a unarySayHellowhose request and reply carry the same small structured message.SayHelloinRpcBenchmarkuses the same message. - The servers: 26 servers written in Rust, Java, Kotlin, Scala, Go, .NET, C++, Swift, Node.js and Python: 22 that grpc_bench already has, upgraded to the current versions of their runtimes and libraries, and 4 new ones. The results table lists all of them, and Library and Runtime Versions lists what they run on.
- The setups: in the local setup, the server runs in a Docker container limited to 4 CPUs, as in grpc_bench. In the LAN setup, the client is a separate PC and the server is limited to 2 CPUs: with more, the fastest libraries would saturate the 5 Gbps link, and the test would measure the link instead of the library.
Just want the results? Jump to Combined Tables.
What Was Wrong with the Original Test
I started by running the servers the way grpc_bench runs them: one ghz process (its Go load generator) with 50 connections and 1,000 concurrent calls. The fastest server, rust_ntex, handled about 400K calls/s with its 4 CPUs at 320-340%, so that number was not the server's limit.
The load generator. It quickly became clear that ghz can't saturate the fastest servers. ghz spends about 35 microseconds of CPU time on every call it makes, and rust_ntex spends about 4 microseconds serving one. So one CPU of rust_ntex needs about 9 CPUs of ghz to keep it busy, and 4 server CPUs need more than the 28 this machine has left. Even with 28 ghz processes, each at 98% of its CPU, rust_ntex stayed at 315% server CPU. No ghz setting changed that.
So I asked Claude to write a load generator in Rust, on tonic. It does what a real client does: a worker sends a call, awaits and decodes the reply, and sends the next one. It needs about 10 microseconds of CPU per call, several times less than ghz, and that is what saturated every server here.
The load shape. With grpc_bench's shape (50 connections with 20 calls each) most servers were at 400% CPU and still handled half as many calls as they can. With a few hundred concurrent calls per connection a server processes them in batches. The best shape is different for every server: 600-900 calls per connection for rust_ntex and grpc-dotnet, about 75-110 for Quarkus and Armeria, and just 4 connections for the C++ servers. So for each server I tried both the Rust client and 28 ghz processes, and for the Rust client a set of shapes plus a few more around the best one. I report the best result without errors.
The versions. Most of grpc_bench's servers were pinned to libraries that were 2 to 4 years old: Vert.x 4.4.4, Quarkus 3.1.2, Armeria 1.20.3, grpc-java 1.58, gRPC C++ 1.51, Node.js 20. The first round of results described those versions, not the frameworks as they are today. So every server was moved to the current release of its runtime and gRPC library, and four servers were added: grpc-swift 2, a Native AOT build of grpc-dotnet, and two frameworks from CloudWeGo, Volo (Rust) and Kitex (Go). The upgrade moved some results by 20-25%: Armeria, grpc-java and Node.js got that much faster, while Vert.x 5 and grpc-go 1.85 got about 14% slower than the versions they replaced.
The .NET settings. grpc_bench's .NET server set no runtime options, so it ran with the DATAS garbage collector mode on. Turning DATAS off, which is what my benchmark does, gives it 3-5% more at the cost of about 270 MB of memory.
The upgraded servers, the new ones and the Rust client are all in the dev branch of a fork of grpc_bench, which I'm proposing upstream as a series of pull requests.
The local tests run on one machine, so the calls never leave the Docker network. The 5 Gbps LAN, 2-Core Server section repeats the tests over a LAN, with the client on a separate machine.
Local Tests, 4-Core Server
Server machine:
| Component | Specification |
|---|---|
| CPU | AMD Ryzen 9 9950X3D (16 cores / 32 logical CPUs) |
| RAM | 96 GB DDR5 |
| OS | Windows 11, Docker Desktop with the WSL2 backend (32 CPUs, 25 GB) |
| Server container | --cpus 4 --memory 8g, on a Docker network on the same machine (no published ports) |
| Clients | Containers on the same machine, using the 28 logical CPUs the server doesn't use |
grpc_bench tests
SayHello, 4-CPU server, no TLS, successful calls per second. Each server was measured under two loads:
- Original load: the one grpc_bench uses: one
ghzprocess with 50 connections and 1,000 calls in flight (20 per connection).ghzhad 28 CPUs here, so it wasn't the limit. - Optimal load: the highest error-free result I got for that server. I varied the client (28
ghzprocesses, or the Rust client), the number of connections, and the number of calls in flight per connection. The numbers in parentheses show the winning shape. - The factor after a result is how many times slower that result is than the fastest one in its column: =1.0 is the fastest, ↓2.0× is half as fast, ↓10× is ten times slower. The color goes from green (1x) through red (3x) to black (50x or more) on a log scale. The tables below use the same notation.
| Server | Original load, calls/s | Optimal load, calls/s (connections x calls-in-flight) |
|---|---|---|
| rust_ntex (Rust, ntex) | 384K =1.0 | 1,057K =1.0 (20 x 600) |
| java_vertx_grpc (Java, Vert.x) | 350K ↓1.1× | 672K ↓1.6× (28 x 338) |
| dotnet_grpc (.NET, grpc-dotnet) | 281K ↓1.4× | 670K ↓1.6× (20 x 900) |
| java_quarkus (Java, Quarkus) | 320K ↓1.2× | 632K ↓1.7× (28 x 75) |
| dotnet_grpc_aot (.NET, grpc-dotnet, Native AOT) | 271K ↓1.4× | 613K ↓1.7× (20 x 600) |
| scala_akka (Scala, Akka gRPC) | 236K ↓1.6× | 532K ↓2.0× (28 x 150) |
| rust_tonic_mt (Rust, tonic) | 267K ↓1.4× | 491K ↓2.2× (28 x 300) |
| java_armeria (Java, Armeria) | 242K ↓1.6× | 485K ↓2.2× (28 x 112) |
| rust_volo_grpc (Rust, Volo) | 243K ↓1.6× | 428K ↓2.5× (28 x 225) |
| java_hotspot_grpc_pgc (Java, grpc-java) | 206K ↓1.9× | 399K ↓2.7× (28 x 338) |
| java_micronaut_workstealing (Java, Micronaut) | 213K ↓1.8× | 387K ↓2.7× (28 x 150) |
| go_kitex_grpc (Go, Kitex) | 213K ↓1.8× | 374K ↓2.8× (28 x 150) |
| go_vtgrpc (Go, grpc-go + vtprotobuf) | 201K ↓1.9× | 357K ↓3.0× (28 x 450) |
| go_grpc (Go, grpc-go) | 197K ↓1.9× | 340K ↓3.1× (28 x 300) |
| rust_grpcio (Rust, gRPC C core) | 144K ↓2.7× | 269K ↓3.9× (28 x 150) |
| kotlin_grpc (Kotlin, grpc-kotlin) | 158K ↓2.4× | 267K ↓4.0× (28 x 450) |
| swift_grpc (Swift, grpc-swift 1) | 149K ↓2.6× | 243K ↓4.3× (28 x 150) |
| cpp_grpc_mt (C++) | 102K ↓3.8× | 227K ↓4.7× (4 x 240) |
| cpp_asio_grpc (C++, asio-grpc) | 89K ↓4.3× | 212K ↓5.0× (4 x 240) |
| scala_pekko (Scala, Pekko gRPC) | 197K ↓1.9× | 197K ↓5.4× (50 x 20) |
| go_vtconnect (Go, ConnectRPC + vtprotobuf) | 57K ↓6.7× | 109K ↓9.7× (28 x 150) |
| go_connect (Go, ConnectRPC) | 56K ↓6.9× | 107K ↓9.9× (28 x 150) |
| java_micronaut (Java, Micronaut, default executor) | 45K ↓8.5× | 68K ↓16× (28 x 150) |
| node_grpcjs_st (Node.js, single process) | 35K ↓11× | 59K ↓18× (28 x 150) |
| swift_grpc2 (Swift, grpc-swift 2) | 16K ↓24× | 16K ↓66× (50 x 20) |
| python_async_grpc (Python, asyncio, single process) | 4K ↓96× | 4K ↓257× (50 x 20) |
- Choosing the load well roughly doubles almost every result (1.5x to 2.8x).
- Every multi-threaded server is at 382-404% of its 4 CPUs under its optimal load.
- The optimal load is the better of two clients. Most servers do better with the Rust client; Akka, Kitex, grpcio, Swift, ConnectRPC, Micronaut and Node.js do better with
ghz. - Native AOT doesn't make grpc-dotnet faster here: the AOT build is 3-8% slower than the JIT build.
- Five servers stop working or start returning errors under high concurrency, so their optimal load is a modest one: the two C++ servers and the Python one (gRPC's C core cancels calls once too many are pending), grpc-swift 2 (it allows 100 concurrent calls per connection) and Pekko (its JVM exits with a stack overflow).
- The fastest gRPC server on 4 CPUs handles about a million
SayHellocalls per second.
RpcBenchmark tests
The same machine and the same 4-CPU server container, no TLS, .NET 11.0.0, the client of RpcBenchmark in a second container with 24 CPUs. Each library ran with fixed parameters: its best known number of connections and of workers per connection, verified against one nearby set. A worker sends a call, waits for the reply and sends the next one, so workers per connection is the number of calls in flight on a connection. The best of 6 tries of 5 seconds is listed.
Calls
| Library | Workers per connection x connections | Sum, calls/s | GetUser, calls/s | SayHello, calls/s |
|---|---|---|---|---|
| ActualLab.Rpc | 451 x 54 | 5.62M =1.0 | 4.36M =1.0 | 2.54M =1.0 |
| SignalR | 213 x 93 | 2.71M ↓2.1× | 2.24M ↓1.9× | 999K ↓2.5× |
| gRPC (grpc-dotnet) | 82 x 30 | 626K ↓9.0× | 603K ↓7.2× | 567K ↓4.5× |
| MagicOnion | 78 x 23 | 583K ↓9.6× | 563K ↓7.7× | 518K ↓4.9× |
| StreamJsonRpc | 237 x 74 | 397K ↓14× | 306K ↓14× | 134K ↓19× |
| HTTP | 100 x 36 | 146K ↓38× | 147K ↓30× | 130K ↓20× |
Sum adds two integers, GetUser returns a small object, SayHello is the grpc_bench message. ActualLab.Rpc uses the msgpack6c serialization format here.
Streams
Items per second. A stream has 1,800 items; the name of the test is the item size in bytes.
| Library | Workers per connection x connections | Stream1, items/s | Stream100, items/s | Stream10K, items/s |
|---|---|---|---|---|
| ActualLab.Rpc | 5 x 54 | 40.19M =1.0 | 18.64M =1.0 | 492K =1.0 |
| gRPC (grpc-dotnet) | 15 x 38 | 15.40M ↓2.6× | 9.42M ↓2.0× | 329K ↓1.5× |
| SignalR | 1 x 108 | 12.01M ↓3.3× | 6.97M ↓2.7× | 239K ↓2.1× |
| StreamJsonRpc | 4 x 53 | 163K ↓247× | 163K ↓114× | 95K ↓5.2× |
5 Gbps LAN, 2-Core Server
Server machine:
| Component | Specification |
|---|---|
| Host | AMD Ryzen 7 8745HS (8 cores / 16 logical CPUs), 30 GB RAM, one NVMe SSD, Proxmox VE 9.0.3 (Debian 13, kernel 6.14.8-2-pve) |
| VM | Ubuntu 24.04.5 (kernel 6.8.0-149), 16 vCPUs, 26 GB RAM, the only VM running on the host |
| Server container | --cpus 2 --memory 8g (Docker 29.10.0), published ports |
| Network | Realtek RTL8157 USB 5GbE adapter, Linux bridge, virtio NIC with 8 queues |
| Client | A separate PC: AMD Ryzen AI MAX+ PRO 395 (16 cores / 32 logical CPUs), 96 GB RAM, Windows 11 Pro, Realtek USB 5GbE adapter |
The same tests, with the client on a separate PC and a 5 Gbit/s LAN between the two machines (iperf3 measures 4.74 Gbit/s). The server is a Docker container limited to 2 CPUs, in a VM on a Proxmox host, and the client PC has 32 logical CPUs. There is no TLS, and the figures were measured on 2026-11-17. The machines, the network path and the commands are in Benchmarks.md.
These figures are not comparable with the ones above: the server has 2 CPUs instead of 4, its CPU is slower, and the client is another machine.
Why 2 CPUs. The test should measure the libraries, not the network. With 2 CPUs the server is the limit in every call test and in Stream1, but ActualLab.Rpc already reaches 92% of the link in Stream100, and Stream10K saturates it at any server speed. Twice the CPUs would move the limit from the server to the link in more of the stream tests for the fastest libraries, and their results would converge on the link speed.
grpc_bench tests
SayHello, 2-CPU server, no TLS: 7 gRPC servers, one per language, loaded by the Rust client. Each is the fastest server of its language in the 4-CPU tests with that client. Each figure is a single 15-second run.
| Server | Client and shape (connections x calls each) | Calls/s |
|---|---|---|
| rust_ntex | Rust client, 28 x 450 | 401K =1.0 |
| java_vertx_grpc | Rust client, 28 x 150 | 319K ↓1.3× |
| dotnet_grpc | Rust client, 20 x 450 | 285K ↓1.4× |
| go_vtgrpc | Rust client, 14 x 450 | 179K ↓2.2× |
| scala_akka | Rust client, 14 x 225 | 154K ↓2.6× |
| cpp_grpc_mt | Rust client, 2 x 240 | 151K ↓2.7× |
| swift_grpc | Rust client, 14 x 600 | 92K ↓4.3× |
The servers and the shapes of the load are in Benchmarks-gRPC.md.
RpcBenchmark tests
Calls
| Library | Workers per connection x connections | Sum, calls/s | GetUser, calls/s | SayHello, calls/s |
|---|---|---|---|---|
| ActualLab.Rpc | 563 x 35 | 2.22M =1.0 | 1.71M =1.0 | 1.07M =1.0 |
| SignalR | 213 x 70 | 1.06M ↓2.1× | 765K ↓2.2× | 416K ↓2.6× |
| gRPC (grpc-dotnet) | 84 x 16 | 364K ↓6.1× | 356K ↓4.8× | 314K ↓3.4× |
| HTTP | 66 x 25 | 98K ↓23× | 104K ↓16× | 82K ↓13× |
Every call test is limited by the server's 2 CPUs, and none of them uses more than a quarter of the link.
Streams
Items per second. Stream10K wasn't run, because it saturates the 5 Gbit/s NICs at any server speed.
| Library | Workers per connection x connections | Stream1, items/s | Stream100, items/s |
|---|---|---|---|
| ActualLab.Rpc | 10 x 39 | 18.51M =1.0 | 5.45M =1.0 |
| gRPC (grpc-dotnet) | 15 x 8 | 7.79M ↓2.4× | 4.54M ↓1.2× |
| SignalR | 3 x 11 | 4.98M ↓3.7× | 2.63M ↓2.1× |
ActualLab.Rpc's Stream100 reaches 92% of the link's ceiling of 5.93M items/s (4.74 Gbit/s with no framing at all), so it has CPU to spare. gRPC runs out of CPU at 4.54M items/s.
Combined Tables
The fastest gRPC server in each language, the Native AOT build of grpc-dotnet, ActualLab.Rpc and SignalR, running the same SayHello call, without TLS. The first table is the local test, the second one is the LAN test.
Local Tests, 4-Core Server
SayHello, 4-CPU server in Docker.
| Server | Language | Client and shape (connections x calls each) | Calls/s |
|---|---|---|---|
| ActualLab.Rpc | .NET | RpcBenchmark, 54 x 451 | 2.54M =1.0 |
| rust_ntex | Rust | Rust client, 20 x 600 | 1.06M ↓2.4× |
| SignalR | .NET | RpcBenchmark, 93 x 213 | 999K ↓2.5× |
| java_vertx_grpc | Java | Rust client, 28 x 338 | 672K ↓3.8× |
| dotnet_grpc | .NET | Rust client, 20 x 900 | 670K ↓3.8× |
| dotnet_grpc_aot | .NET (Native AOT) | Rust client, 20 x 600 | 613K ↓4.1× |
| gRPC (grpc-dotnet) | .NET | RpcBenchmark, 30 x 82 | 567K ↓4.5× |
| scala_akka | Scala | ghz, 28 x 150 | 532K ↓4.8× |
| go_kitex_grpc | Go | ghz, 28 x 150 | 374K ↓6.8× |
| kotlin_grpc | Kotlin | Rust client, 28 x 450 | 267K ↓9.5× |
| swift_grpc | Swift | ghz, 28 x 150 | 244K ↓10× |
| cpp_grpc_mt | C++ | Rust client, 4 x 240 | 227K ↓11× |
| node_grpcjs_st | Node.js | ghz, 28 x 150 | 59K ↓43× |
| python_async_grpc | Python | ghz, 50 x 20 | 4K ↓620× |
ActualLab.Rpc handles 2.4x more SayHello calls than the fastest gRPC server here and 3.8x more than grpc-dotnet, the gRPC implementation for the same runtime.
This is the same call, the same message, the same machine and the same 4 CPUs for the server. The load is not the same, though, and the difference favors the gRPC servers; see How the Two Clients Load a Server below.
5 Gbps LAN, 2-Core Server
SayHello, 2-CPU server in Docker in a VM, client on a separate PC.
| Server | Language | Client and shape (connections x calls each) | Calls/s |
|---|---|---|---|
| ActualLab.Rpc | .NET | RpcBenchmark, 35 x 563 | 1.07M =1.0 |
| SignalR | .NET | RpcBenchmark, 70 x 213 | 416K ↓2.6× |
| rust_ntex | Rust | Rust client, 28 x 450 | 401K ↓2.7× |
| java_vertx_grpc | Java | Rust client, 28 x 150 | 319K ↓3.4× |
| gRPC (grpc-dotnet) | .NET | RpcBenchmark, 16 x 84 | 314K ↓3.4× |
| dotnet_grpc | .NET | Rust client, 20 x 450 | 285K ↓3.8× |
| go_vtgrpc | Go | Rust client, 14 x 450 | 179K ↓6.0× |
| scala_akka | Scala | Rust client, 14 x 225 | 154K ↓7.0× |
| cpp_grpc_mt | C++ | Rust client, 2 x 240 | 151K ↓7.1× |
| swift_grpc | Swift | Rust client, 14 x 600 | 92K ↓12× |
ActualLab.Rpc handles 2.7x more SayHello calls than the fastest gRPC server here and 3.4x more than grpc-dotnet. The gRPC servers' figures are single 15-second runs, and the RpcBenchmark figures are the best of six 5-second tries, which favors the RpcBenchmark rows.
Conclusions
ActualLab.Rpc Is in a League of Its Own
Even with the disclaimer in mind, the gap is hard to overstate.
- Calls: it is 2.7x faster over the LAN than
rust_ntex, the fastest gRPC server. - Per core: that's about 635K calls/s per core, a number nearly every other server here can't reach even with 4 cores. And only
rust_ntexand SignalR need "just" 3 cores to produce the same number! - Streams: it processes more than 10M one-byte items per second per core (40.2M/s on 4 CPUs). It's almost the same over the LAN: 9.3M per core, on a slightly slower CPU.
- And that's very good news for all other library authors: if a library written almost single-handedly beats every RPC stack in every language here by such a margin, all of them have huge room to improve. And many of them eventually will.
On .NET, SignalR Is the Next Choice
- Over the LAN it is slightly ahead of
rust_ntex(416K vs 401K calls/s); locally it is 6% behind (999K vs 1.06M). - It is 1.3-1.8x faster than grpc-dotnet.
- On .NET 11 it needs one fix to get there, which
RpcBenchmarkapplies; see The .NET 11 Pipe Scheduler Fix.
Among gRPC Servers, rust_ntex Is the Clear Winner
- Locally it is 1.6x faster than the next ones, Vert.x and grpc-dotnet, and it is the fastest gRPC server over the LAN as well.
- That's ntex, not Rust in general: tonic, the most popular Rust gRPC library, is slower than grpc-dotnet.
- grpc-dotnet is 3rd of 26, but SignalR beats it on the same runtime and the same Kestrel. So I suspect most of its overhead is in its own HTTP/2 and gRPC layers rather than in .NET, and that it could be a lot faster.
Everything Else Is Far Behind
- Go: the fastest Go server (Kitex, 374K) handles about half of what grpc-dotnet does and a third of what
rust_ntexdoes. - C++: the servers on gRPC's C core are surprisingly slow (227K).
- Swift, Node.js, Python: 243K (only 16K with grpc-swift 2), 59K and 4K, i.e. 4-260x slower than
rust_ntex. If your server's RPC throughput matters, avoid them there.
Important Remarks
Disclosure and Fairness
I wrote ActualLab.Rpc and RpcBenchmark, and some of the conclusions in this post were written by Claude. You don't have to take my word for the results:
- The code is open source.
RpcBenchmarkis in the Fusion.Samples repository, ActualLab.Rpc is in the Fusion repository, and the grpc_bench servers and the Rust client are in thedevbranch of the grpc_bench fork. RpcBenchmarkisn't tuned for ActualLab.Rpc. Every library gets the same load: workers that send a call, wait for the reply and send the next one. Each library runs with its own best known number of connections and workers, found the same way.- Compared to grpc_bench, the load from
RpcBenchmarkis not in ActualLab.Rpc's favor, nor in favor of any other .NET library it tests. It's the opposite. The next section explains why.
How the Two Clients Load a Server
In both clients a worker sends a call and waits for the reply before sending the next one. A new call is queued on a connection only when a reply to one of the queued calls arrives, so the number of calls open on a connection is capped by the number of workers on it. The difference is in where the workers run, and that shapes the load.
- The Rust client keeps a connection and all of its workers on one thread. It is a faster replica of
ghz, the tool grpc_bench uses: the same model of a fixed number of connections and of concurrent calls, the same payload and the same report. Each client thread runs a single-threaded runtime with its own connections, and the workers are tasks on it. The client doesn't batch anything itself: when the HTTP/2 stack reads several replies from the socket at once, their workers resume one after another on the same thread, and each queues its next call. The next calls go out right after the replies came in, and there is no cross-thread synchronization, because no other thread touches the connection. The client threads share nothing except the start barrier, so the load from each thread is independent of the others and more uniform, as long as the machine has enough cores to run them in parallel. It does here: the client never starts more threads than CPUs, and it had 28 CPUs locally and 16 on the LAN. The connection and call counts were also searched per server. - The
RpcBenchmarkclient spreads the workers over the thread pool. N workers are spread over M connections as tasks on the shared thread pool. Each reply resumes its own worker individually, on whichever thread is free, and the worker sends its next call at once, independently of the others. The calls reach a connection from different threads, so the client library has to synchronize them and decide how to batch them. Batches still form, but they are less uniform, because the timing of the threads is stochastic, and nobody times them to suit the server. The worker and connection counts were the ones I already knew, checked against one nearby set.
So RpcBenchmark's load is closer to real life, where callers neither coordinate with each other nor time their calls to suit the server.
The shaping is worth a lot. The same Rust client with one multi-threaded runtime instead of a runtime per CPU gives rust_ntex 667K instead of 900K, and grpc-dotnet gets 567K from RpcBenchmark against 670K from the Rust client with the optimal load.
The .NET 11 Pipe Scheduler Fix
.NET 11 changed PipeScheduler.ThreadPool (System.IO.Pipelines) to queue its work items with preferLocal: true. Under load, a pipe reader such as SignalR's send loop now runs almost immediately and flushes tiny batches, so the number of socket sends per call grows several times, and SignalR's call throughput drops several times with it.
RpcBenchmark works around this: at startup, both its server and its client processes replace the scheduler behind PipeScheduler.ThreadPool with one that queues to the global thread pool queue, as .NET 10 did. The fix is process-wide, so it applies to every .NET library in the test, not only to SignalR, and the ActualLab_PipeSchedulerFix=0 environment variable turns it off. Without it, SignalR's numbers in this post would be much lower. The details are in Benchmarks.md, and the code is PipeSchedulerFix.cs.
The Effect of TLS
RpcBenchmark used to run with TLS. I only noticed that grpc_bench runs without it while preparing this post. I then turned TLS off by default in RpcBenchmark (-tls turns it on), because the goal of all these benchmarks is to show the overhead the RPC library itself adds. TLS adds a fixed overhead of its own, which makes the differences between libraries less visible.
I measured the effect of TLS on .NET only, that is, on Kestrel and the .NET libraries running on it. I didn't run the other grpc_bench servers with TLS, so the numbers below say nothing about Rust, Java or Go.
How much faster each test runs without TLS, with the same parameters:
| Test | ActualLab.Rpc | SignalR | gRPC (.NET) | MagicOnion |
|---|---|---|---|---|
| Sum | +10% | +9% | +17% | +18% |
| GetUser | +4% | +9% | +19% | +20% |
| SayHello | +3% | +7% | +20% | +17% |
| Stream1 (1-byte items) | +5% | +11% | +7% | - |
| Stream100 (100-byte items) | +27% | +16% | +19% | - |
- TLS matters least for calls over WebSockets: 3-10% for ActualLab.Rpc and SignalR.
- It matters most for gRPC calls on .NET: 17-20% for gRPC and MagicOnion, both of which run over HTTP/2.
- For streams it grows with the item size, because the cost is per byte: up to 27% with 100-byte items.
So on .NET, a gRPC result measured without TLS is about 20% higher than the same test with TLS. All the figures in this post are measured without it, for every library.
Library and Runtime Versions
Every server runs on the newest stable release of its runtime and gRPC library as of 2026-11-16, with the exceptions listed below the table.
Show library and runtime versions
| Runtime | Server | Library |
|---|---|---|
| .NET 11.0.0 | ActualLab.Rpc (RpcBenchmark) | ActualLab.Fusion 15.1.38 |
| .NET 11.0.0 | HTTP (RpcBenchmark) | ASP.NET Core |
| .NET 11.0.0 | dotnet_grpc | Grpc.AspNetCore 2.85.0 |
| .NET 11.0.0 | gRPC (RpcBenchmark) | Grpc.AspNetCore 2.85.0 |
| .NET 11.0.0 | MagicOnion (RpcBenchmark) | MagicOnion 7.11.0 |
| .NET 11.0.0 | SignalR (RpcBenchmark) | SignalR 11.0.0 |
| .NET 11.0.0 | StreamJsonRpc (RpcBenchmark) | StreamJsonRpc 2.26.150 |
| .NET 11.0.0, Native AOT | dotnet_grpc_aot (new) | Grpc.AspNetCore 2.85.0 |
| GCC 16.2 | cpp_grpc_mt | gRPC C++ 1.85.2 |
| GCC 16.2 | cpp_asio_grpc | gRPC C++ 1.85.2, asio-grpc 3.7.0 |
| Go 1.27.4 | go_connect, go_vtconnect | connect-go 1.21.1 |
| Go 1.27.4 | go_grpc | grpc-go 1.85.0 |
| Go 1.27.4 | go_vtgrpc | grpc-go 1.85.0, vtprotobuf 0.6.0 |
| Go 1.27.4 | go_kitex_grpc (new) | Kitex 0.16.4 |
| JDK 25 | scala_akka | Akka 2.8.8, Akka gRPC 2.3.4 |
| JDK 25 | java_armeria | Armeria 1.43.0 |
| JDK 25 | java_hotspot_grpc_pgc | grpc-java 1.85.1 |
| JDK 25 | kotlin_grpc | grpc-kotlin 1.5.0, Kotlin 2.4.21 |
| JDK 25 | java_micronaut (both) | Micronaut 5.2.6 |
| JDK 25 | scala_pekko | Pekko 1.7.1, Pekko gRPC 1.2.0 |
| JDK 25 | java_quarkus | Quarkus 3.40.1 |
| JDK 25 | java_vertx_grpc | Vert.x 5.2.3, grpc-java 1.85.1 |
| Node.js 26.13.1 | node_grpcjs_st | @grpc/grpc-js 1.14.7 |
| Python 3.15 | python_async_grpc | grpcio 1.85.1 |
| Rust 1.100 | rust_grpcio | grpcio 0.13.0 |
| Rust 1.100 | rust_ntex | ntex 4.9.1, ntex-grpc 4.1.1 |
| Rust 1.100 | rust_tonic_mt | tonic 0.14.9, tokio 1.54.1 |
| Rust 1.100 | rust_volo_grpc (new) | volo-grpc 0.12.2 |
| Swift 6.4.2 | swift_grpc | grpc-swift 1.27.6 |
| Swift 6.4.2 | swift_grpc2 (new) | grpc-swift-2 2.4.4 |
Not on the very latest version: Akka is at 2.8.8, the newest release on Maven Central (later releases need a license token for Akka's own repository); Pekko is on its stable 1.x line, because Pekko gRPC has no stable 2.x release; the JVM servers run on JDK 25, the current LTS release.
The RpcBenchmark libraries were the latest releases at the time. The load generators are ghz 0.114.0, the version grpc_bench uses, and the Rust client on tonic 0.14.9.
P.S.
ActualLab.Rpc isn't only a benchmark entry: together with Fusion, it runs Voxt, which we're building to be the best chat for everyday communication. Here's its quick intro:
In one of the next posts, I'll explain why a chat app needs an RPC library this fast.
