Skip to content

The Fastest .NET RPC Libraries vs the Fastest gRPC Libraries ​

Published: 2026-11-16 by Alex Yakunin

26 gRPC servers in 10 languages and 6 .NET RPC libraries, tested with the same call on the same 4 CPUs

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_proto scenario, a unary SayHello whose request and reply carry the same small structured message. SayHello in RpcBenchmark uses 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:

ComponentSpecification
CPUAMD Ryzen 9 9950X3D (16 cores / 32 logical CPUs)
RAM96 GB DDR5
OSWindows 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)
ClientsContainers 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 ghz process with 50 connections and 1,000 calls in flight (20 per connection). ghz had 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 ghz processes, 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.
ServerOriginal load, calls/sOptimal load, calls/s (connections x calls-in-flight)
rust_ntex (Rust, ntex)384K =1.01,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 SayHello calls 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 ​

LibraryWorkers per connection x connectionsSum, calls/sGetUser, calls/sSayHello, calls/s
ActualLab.Rpc451 x 545.62M =1.04.36M =1.02.54M =1.0
SignalR213 x 932.71M ↓2.1×2.24M ↓1.9×999K ↓2.5×
gRPC (grpc-dotnet)82 x 30626K ↓9.0×603K ↓7.2×567K ↓4.5×
MagicOnion78 x 23583K ↓9.6×563K ↓7.7×518K ↓4.9×
StreamJsonRpc237 x 74397K ↓14×306K ↓14×134K ↓19×
HTTP100 x 36146K ↓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.

LibraryWorkers per connection x connectionsStream1, items/sStream100, items/sStream10K, items/s
ActualLab.Rpc5 x 5440.19M =1.018.64M =1.0492K =1.0
gRPC (grpc-dotnet)15 x 3815.40M ↓2.6×9.42M ↓2.0×329K ↓1.5×
SignalR1 x 10812.01M ↓3.3×6.97M ↓2.7×239K ↓2.1×
StreamJsonRpc4 x 53163K ↓247×163K ↓114×95K ↓5.2×

5 Gbps LAN, 2-Core Server ​

Server machine:

ComponentSpecification
HostAMD 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)
VMUbuntu 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
NetworkRealtek RTL8157 USB 5GbE adapter, Linux bridge, virtio NIC with 8 queues
ClientA 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.

The LAN setup: client PC, switch, Proxmox host, VM, server container

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.

ServerClient and shape (connections x calls each)Calls/s
rust_ntexRust client, 28 x 450401K =1.0
java_vertx_grpcRust client, 28 x 150319K ↓1.3×
dotnet_grpcRust client, 20 x 450285K ↓1.4×
go_vtgrpcRust client, 14 x 450179K ↓2.2×
scala_akkaRust client, 14 x 225154K ↓2.6×
cpp_grpc_mtRust client, 2 x 240151K ↓2.7×
swift_grpcRust client, 14 x 60092K ↓4.3×

The servers and the shapes of the load are in Benchmarks-gRPC.md.

RpcBenchmark tests ​

Calls ​

LibraryWorkers per connection x connectionsSum, calls/sGetUser, calls/sSayHello, calls/s
ActualLab.Rpc563 x 352.22M =1.01.71M =1.01.07M =1.0
SignalR213 x 701.06M ↓2.1×765K ↓2.2×416K ↓2.6×
gRPC (grpc-dotnet)84 x 16364K ↓6.1×356K ↓4.8×314K ↓3.4×
HTTP66 x 2598K ↓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.

LibraryWorkers per connection x connectionsStream1, items/sStream100, items/s
ActualLab.Rpc10 x 3918.51M =1.05.45M =1.0
gRPC (grpc-dotnet)15 x 87.79M ↓2.4×4.54M ↓1.2×
SignalR3 x 114.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.

ServerLanguageClient and shape (connections x calls each)Calls/s
ActualLab.Rpc.NETRpcBenchmark, 54 x 4512.54M =1.0
rust_ntexRustRust client, 20 x 6001.06M ↓2.4×
SignalR.NETRpcBenchmark, 93 x 213999K ↓2.5×
java_vertx_grpcJavaRust client, 28 x 338672K ↓3.8×
dotnet_grpc.NETRust client, 20 x 900670K ↓3.8×
dotnet_grpc_aot.NET (Native AOT)Rust client, 20 x 600613K ↓4.1×
gRPC (grpc-dotnet).NETRpcBenchmark, 30 x 82567K ↓4.5×
scala_akkaScalaghz, 28 x 150532K ↓4.8×
go_kitex_grpcGoghz, 28 x 150374K ↓6.8×
kotlin_grpcKotlinRust client, 28 x 450267K ↓9.5×
swift_grpcSwiftghz, 28 x 150244K ↓10×
cpp_grpc_mtC++Rust client, 4 x 240227K ↓11×
node_grpcjs_stNode.jsghz, 28 x 15059K ↓43×
python_async_grpcPythonghz, 50 x 204K ↓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.

ServerLanguageClient and shape (connections x calls each)Calls/s
ActualLab.Rpc.NETRpcBenchmark, 35 x 5631.07M =1.0
SignalR.NETRpcBenchmark, 70 x 213416K ↓2.6×
rust_ntexRustRust client, 28 x 450401K ↓2.7×
java_vertx_grpcJavaRust client, 28 x 150319K ↓3.4×
gRPC (grpc-dotnet).NETRpcBenchmark, 16 x 84314K ↓3.4×
dotnet_grpc.NETRust client, 20 x 450285K ↓3.8×
go_vtgrpcGoRust client, 14 x 450179K ↓6.0×
scala_akkaScalaRust client, 14 x 225154K ↓7.0×
cpp_grpc_mtC++Rust client, 2 x 240151K ↓7.1×
swift_grpcSwiftRust client, 14 x 60092K ↓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_ntex and 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 RpcBenchmark applies; 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_ntex does.
  • 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. RpcBenchmark is in the Fusion.Samples repository, ActualLab.Rpc is in the Fusion repository, and the grpc_bench servers and the Rust client are in the dev branch of the grpc_bench fork.
  • RpcBenchmark isn'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 RpcBenchmark is 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 RpcBenchmark client 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:

TestActualLab.RpcSignalRgRPC (.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
RuntimeServerLibrary
.NET 11.0.0ActualLab.Rpc (RpcBenchmark)ActualLab.Fusion 15.1.38
.NET 11.0.0HTTP (RpcBenchmark)ASP.NET Core
.NET 11.0.0dotnet_grpcGrpc.AspNetCore 2.85.0
.NET 11.0.0gRPC (RpcBenchmark)Grpc.AspNetCore 2.85.0
.NET 11.0.0MagicOnion (RpcBenchmark)MagicOnion 7.11.0
.NET 11.0.0SignalR (RpcBenchmark)SignalR 11.0.0
.NET 11.0.0StreamJsonRpc (RpcBenchmark)StreamJsonRpc 2.26.150
.NET 11.0.0, Native AOTdotnet_grpc_aot (new)Grpc.AspNetCore 2.85.0
GCC 16.2cpp_grpc_mtgRPC C++ 1.85.2
GCC 16.2cpp_asio_grpcgRPC C++ 1.85.2, asio-grpc 3.7.0
Go 1.27.4go_connect, go_vtconnectconnect-go 1.21.1
Go 1.27.4go_grpcgrpc-go 1.85.0
Go 1.27.4go_vtgrpcgrpc-go 1.85.0, vtprotobuf 0.6.0
Go 1.27.4go_kitex_grpc (new)Kitex 0.16.4
JDK 25scala_akkaAkka 2.8.8, Akka gRPC 2.3.4
JDK 25java_armeriaArmeria 1.43.0
JDK 25java_hotspot_grpc_pgcgrpc-java 1.85.1
JDK 25kotlin_grpcgrpc-kotlin 1.5.0, Kotlin 2.4.21
JDK 25java_micronaut (both)Micronaut 5.2.6
JDK 25scala_pekkoPekko 1.7.1, Pekko gRPC 1.2.0
JDK 25java_quarkusQuarkus 3.40.1
JDK 25java_vertx_grpcVert.x 5.2.3, grpc-java 1.85.1
Node.js 26.13.1node_grpcjs_st@grpc/grpc-js 1.14.7
Python 3.15python_async_grpcgrpcio 1.85.1
Rust 1.100rust_grpciogrpcio 0.13.0
Rust 1.100rust_ntexntex 4.9.1, ntex-grpc 4.1.1
Rust 1.100rust_tonic_mttonic 0.14.9, tokio 1.54.1
Rust 1.100rust_volo_grpc (new)volo-grpc 0.12.2
Swift 6.4.2swift_grpcgrpc-swift 1.27.6
Swift 6.4.2swift_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.