DEV Community

Gaspard Kirira
Gaspard Kirira

Posted on

Vix.cpp vs Drogon vs Crow: a local benchmark of the v2.7.0 HTTP runtime

#vixcpp #drogon #crow #cpp

Vix.cpp vs Drogon vs Crow: a local benchmark of the v2.7.0 HTTP runtime

Vix.cpp v2.7.0 is moving forward, and one of the things I wanted to validate more seriously before pushing this release further was the HTTP runtime.

Vix.cpp is not only a web framework. It is a C++ application platform and developer toolkit around real native C++ projects. The goal is to make C++ development more direct: create a project, run it, build it, test it, install SDK profiles, use modules, package applications, and prepare them for production without losing the native C++ model.

But even if Vix.cpp is broader than a web framework, the HTTP runtime still has to be fast.

So I decided to compare it with two known C++ web frameworks: Drogon and Crow.

Drogon is one of the strongest references in high-performance C++ web development. Crow is also well known because it gives C++ developers a simple and lightweight way to write web services.

That makes this comparison useful.

Not because Vix.cpp is trying to become Drogon or Crow, but because developers need a clear idea of where Vix.cpp stands when the discussion is about C++ HTTP performance.

Website: https://vixcpp.com

Vix.cpp benchmark comparison with Drogon and Crow

The benchmark context

This benchmark was not run on a cloud server.

It was not run on a dedicated bare-metal benchmark machine.

It was run locally on my laptop, the same machine I use for development.

The machine was an HP EliteBook running Linux on x86_64 with 8 CPU threads.

Platform        : linux
Architecture    : x86_64
Kernel version  : 6.17.0-35-generic
Hostname        : softadastra-HP-EliteBook-x360-1030-G3
CPU count       : 8
Page size       : 4096 bytes
Enter fullscreen mode Exit fullscreen mode

That detail matters because the goal of this benchmark was not to claim a universal performance result.

The goal was more practical.

I wanted to see how Vix.cpp behaves on the same machine, with the same benchmark pressure, against two known C++ web frameworks.

Benchmark command

Each framework was tested with a simple endpoint:

/bench
Enter fullscreen mode Exit fullscreen mode

The benchmark command was the same:

wrk -t8 -c800 -d30s --latency http://127.0.0.1:8080/bench
Enter fullscreen mode Exit fullscreen mode

This means:

8 wrk threads
800 concurrent connections
30 seconds duration
latency distribution enabled
Enter fullscreen mode Exit fullscreen mode

The server runtime was also configured around 8 threads where applicable.

This benchmark does not include database access, JSON serialization, authentication, templates, file serving, middleware chains, TLS, or application logic.

It is a simple HTTP runtime benchmark.

That makes it limited, but still useful.

A runtime that wants to support real C++ applications should at least show that it can handle a simple high-concurrency HTTP endpoint correctly.

Drogon result

Drogon was the fastest in raw throughput in this run.

Running 30s test @ http://127.0.0.1:8080/bench
  8 threads and 800 connections

Thread Stats   Avg      Stdev     Max   +/- Stdev
  Latency     6.38ms    4.61ms  94.29ms   72.13%
  Req/Sec    14.51k     3.71k   37.65k    74.49%

Latency Distribution
  50%    5.49ms
  75%    8.64ms
  90%   12.03ms
  99%   21.16ms

3461890 requests in 30.06s, 498.53MB read
Requests/sec: 115151.01
Transfer/sec: 16.58MB
Enter fullscreen mode Exit fullscreen mode

The important number here is:

Drogon: 115,151.01 requests/sec
Enter fullscreen mode Exit fullscreen mode

This is a strong result, and it confirms why Drogon is usually treated as one of the serious references for C++ HTTP performance.

Vix.cpp result

Vix.cpp came very close to Drogon in raw throughput.

Running 30s test @ http://127.0.0.1:8080/bench
  8 threads and 800 connections

Latency:
  Avg:   7.31ms
  Stdev: 16.26ms
  Max:   606.15ms

Latency Distribution:
  50%:  6.51ms
  75%:  7.59ms
  90%:  8.73ms
  99%: 12.19ms

Requests:
  3,386,276 requests in 30.09s
  112,539.11 requests/sec
Enter fullscreen mode Exit fullscreen mode

The throughput result was:

Vix.cpp: 112,539.11 requests/sec
Enter fullscreen mode Exit fullscreen mode

For me, the most interesting part is not only that Vix.cpp reached 112k requests per second.

The more important signal is the p99 latency.

At 800 concurrent connections, Vix.cpp stayed at:

p99: 12.19ms
Enter fullscreen mode Exit fullscreen mode

That is the best p99 latency result in this local run.

Crow result

Crow also stayed fast, but it was behind both Drogon and Vix.cpp in this benchmark.

Running 30s test @ http://127.0.0.1:8080/bench
  8 threads and 800 connections

Thread Stats   Avg      Stdev     Max   +/- Stdev
  Latency     8.30ms    5.31ms  92.21ms   80.21%
  Req/Sec    11.76k     2.54k   30.21k    72.62%

Latency Distribution
  50%    7.21ms
  75%   10.40ms
  90%   14.72ms
  99%   26.76ms

2809917 requests in 30.10s, 324.25MB read
Requests/sec: 93339.82
Transfer/sec: 10.77MB
Enter fullscreen mode Exit fullscreen mode

The throughput result was:

Crow: 93,339.82 requests/sec
Enter fullscreen mode Exit fullscreen mode

Crow remains simple and useful, especially for small C++ web services, but in this specific benchmark it was behind Drogon and Vix.cpp.

Summary table

Framework Requests/sec Avg latency P50 P90 P99
Drogon 115,151.01 6.38 ms 5.49 ms 12.03 ms 21.16 ms
Vix.cpp 112,539.11 7.31 ms 6.51 ms 8.73 ms 12.19 ms
Crow 93,339.82 8.30 ms 7.21 ms 14.72 ms 26.76 ms

The comparison in one paragraph

On this local benchmark, Drogon is slightly ahead in raw throughput with 115,151.01 requests/sec, Vix.cpp stays very close with 112,539.11 requests/sec, and Crow reaches 93,339.82 requests/sec.

The most interesting part for Vix.cpp is the latency distribution: Vix.cpp had the best p99 latency in this run with 12.19ms, compared to 21.16ms for Drogon and 26.76ms for Crow.

That is the comparison I want people to remember.

Drogon is still ahead in raw throughput.

Vix.cpp is very close to Drogon.

Vix.cpp is ahead of Crow in this run.

And Vix.cpp has the best p99 latency in this benchmark.

What the numbers mean

The raw throughput result is close between Drogon and Vix.cpp.

Drogon : 115,151.01 req/s
Vix.cpp: 112,539.11 req/s
Enter fullscreen mode Exit fullscreen mode

That difference is around 2.27%.

For a project like Vix.cpp, that matters because Vix.cpp is not only trying to expose HTTP routes. It also carries a bigger platform direction around the CLI, SDK profiles, modules, registry workflow, project commands, diagnostics, and production preparation.

So being close to Drogon at the HTTP runtime level is a good sign.

Compared to Crow, the difference is larger.

Vix.cpp: 112,539.11 req/s
Crow   :  93,339.82 req/s
Enter fullscreen mode Exit fullscreen mode

That is around 20.57% more requests per second for Vix.cpp in this local run.

But again, the result I care about most is the p99 latency.

Vix.cpp: 12.19ms
Drogon : 21.16ms
Crow   : 26.76ms
Enter fullscreen mode Exit fullscreen mode

Throughput is easy to look at because it gives one big number.

Latency is more interesting because it shows how the runtime behaves under pressure, especially near the tail.

A runtime can look good on average and still feel unstable when the tail latency grows too much.

In this run, Vix.cpp showed a strong p99 result.

Why compare Vix.cpp with Drogon and Crow?

Because those are the names people already know.

When someone talks about C++ web frameworks, Drogon and Crow usually come up quickly.

That is normal.

Drogon has a strong performance reputation.

Crow has a simple and familiar style.

So if Vix.cpp is going to be taken seriously as a modern C++ application platform, it needs to stand next to the tools developers already recognize.

This comparison is not about attacking Drogon or Crow.

Both are valuable C++ projects.

The point is to show that Vix.cpp is not only about developer experience. It is also moving in a competitive runtime direction.

Vix.cpp is not just another C++ web framework

This part is important.

Drogon and Crow are mainly focused on the web framework question:

How do I build a C++ web service?
Enter fullscreen mode Exit fullscreen mode

Vix.cpp is trying to answer a wider question:

How do I build, run, test, package, extend, and maintain a real native C++ application?
Enter fullscreen mode Exit fullscreen mode

That difference matters because most C++ friction does not come from the language alone.

It also comes from everything around the language.

Project setup.

Build configuration.

Dependency workflow.

Running examples.

Testing.

Packaging.

Installing runtime profiles.

Checking the environment.

Preparing a project for production.

Keeping the workflow understandable as the application grows.

Vix.cpp exists around that problem.

The HTTP runtime is one piece of it, but it is an important piece because modern applications often need APIs, services, realtime features, internal dashboards, tools, and backend workflows.

What this benchmark does not prove

This benchmark does not prove that Vix.cpp is always faster than Drogon.

It does not prove that Vix.cpp is always faster than Crow.

It does not prove that one framework is better for every workload.

A real application can change the result completely depending on what it does.

Database queries can dominate everything.

JSON serialization can change the profile.

TLS can change the cost.

Middleware can add overhead.

Logging can slow down hot paths.

Memory allocation patterns can become more important than routing.

Static files, request bodies, WebSocket traffic, cache layers, and business logic can all change the final behavior.

So this benchmark should be read honestly.

It is a simple local HTTP benchmark.

Nothing more.

But it is still a useful signal.

It shows that the current Vix.cpp HTTP runtime is already competitive on a basic high-concurrency endpoint.

Why the p99 result matters to me

The 112k req/s number is nice.

It looks good in a table.

It is easy to share.

But the p99 latency matters more to me because it gives a better signal about the runtime behavior under load.

In this benchmark, Vix.cpp did not only process many requests.

It kept the p99 latency lower than both Drogon and Crow.

Vix.cpp p99: 12.19ms
Drogon p99 : 21.16ms
Crow p99   : 26.76ms
Enter fullscreen mode Exit fullscreen mode

That does not mean Vix.cpp will always win p99 in every situation.

But it does mean the v2.7.0 runtime direction is promising.

And that is what I wanted to verify.

The current position of Vix.cpp

After this benchmark, I would describe the current position like this:

Drogon is still slightly ahead in raw throughput.
Vix.cpp is very close to Drogon.
Vix.cpp is ahead of Crow in this local run.
Vix.cpp has the best p99 latency in this benchmark.
Enter fullscreen mode Exit fullscreen mode

That is a good place for Vix.cpp v2.7.0 to be.

Especially because Vix.cpp is still growing as a full platform, not only as an HTTP router.

The goal is not to win one chart and stop there.

The goal is to keep building a C++ workflow that feels modern while staying native, fast, and understandable.

What comes next

This benchmark is only one step.

The next useful tests should be more realistic.

I want to test:

  • different concurrency levels,
  • longer benchmark durations,
  • JSON responses,
  • larger response bodies,
  • route-heavy applications,
  • WebSocket workloads,
  • middleware-heavy endpoints,
  • file serving,
  • real application endpoints,
  • different machines,
  • and different compiler configurations.

That will give a better picture than a single Hello World benchmark.

But this first comparison is still important because it gives a clean baseline.

Before testing complex applications, the runtime should behave well on the simplest endpoint.

Here, Vix.cpp does.

Final result

The final result of this local benchmark is simple:

Drogon : 115,151.01 req/s
Vix.cpp: 112,539.11 req/s
Crow   :  93,339.82 req/s
Enter fullscreen mode Exit fullscreen mode

And the p99 latency result is:

Vix.cpp: 12.19ms
Drogon : 21.16ms
Crow   : 26.76ms
Enter fullscreen mode Exit fullscreen mode

So the fair conclusion is this:

Vix.cpp v2.7.0 is very close to Drogon in raw throughput, ahead of Crow in this run, and shows the best p99 latency on this local benchmark.

That is a strong signal for the current direction of the HTTP runtime.

Vix.cpp is still growing, but the foundation is becoming stronger.

The goal remains the same: make C++ development feel more direct, more modern, and more reliable without hiding the power of the language.

Links

Website: https://vixcpp.com

Documentation: https://docs.vixcpp.com

Registry: https://registry.vixcpp.com

Engineering notes: https://blog.vixcpp.com

GitHub: https://github.com/vixcpp/vix

Top comments (0)