Vix is a next-generation offline-first, peer-to-peer, ultra-fast runtime for modern C++.

Its goal is clear:

A runtime capable of running apps like Node / Deno / Bun —
but engineered for unstable, low-quality, real-world networks.

Vix is more than a backend framework:
it is a modular runtime, designed for distributed applications, edge systems, offline devices, and environments where traditional cloud frameworks fail.

Inspired by FastAPI, Vue.js, React, and modern runtimes — but rebuilt from scratch in C++20 for raw speed and full control.

All benchmarks were executed using wrk
8 threads, 800 connections, for 30 seconds, on the same machine:
Ubuntu 24.04 — Intel Xeon — C++20 optimized build — Logging disabled

Results represent steady-state throughput on a simple "OK" endpoint.

🔥 New record: When pinned to a single core (taskset -c 2)
Vix.cpp reaches ~99k req/s, surpassing Go and matching the fastest C++ microframeworks.

• zero-cost abstractions
• custom ThreadPool tuned for HTTP workloads
• optimized HTTP pipeline
• fast-path routing
• Beast-based IO
• minimal memory allocations
• predictable threading model

$ wrk -t8 -c800 -d30s --latency http://127.0.0.1:8000
Requests/sec: 48,868.73

When benchmarking from inside the Vix.cpp repository (using the built-in example):

cd ~/vixcpp/vix
export VIX_LOG_LEVEL=critical
export VIX_LOG_ASYNC=false

# Run the optimized example server
vix run example main

Then, in another terminal:

wrk -t8 -c800 -d30s --latency http://127.0.0.1:8080/bench

If you want CPU pinning for more stable results:

taskset -c 2 ./build/main
wrk -t8 -c800 -d30s --latency http://127.0.0.1:8080/bench

✔ Fast-path routing gives +1–3%

Use /fastbench to bypass RequestHandler overhead.

#include <vix.hpp>
using namespace Vix;

int main() {
    App app;

    app.get("/", [](auto&, auto& res) {
        res.json({ "message", "Hello world" });
    });

    app.run(8080);
}

QueryBuilder qb;
qb.raw("UPDATE users SET age=? WHERE email=?")
  .param(29)
  .param("[email protected]");

This example shows the smallest fully working HTTP + WS hybrid server.

• Basic GET route
• Simple WS connection handling
• Auto-start server

#include <vix.hpp>
#include <vix/websocket/AttachedRuntime.hpp>

using namespace vix;

int main()
{
    auto bundle = vix::make_http_and_ws("config/config.json");
    auto &[app, ws] = bundle;

    app.get("/", [](const Request &, Response &res)
            { res.json({"framework", "Vix.cpp",
                        "message", "HTTP + WebSocket example (basic) 🚀"}); });

    ws.on_open([&ws](auto &session)
               {
        (void)session;

        ws.broadcast_json("chat.system", {
            "user", "server",
            "text", "Welcome to Vix WebSocket! 👋"
        }); });

    vix::run_http_and_ws(app, ws, 8080);

    return 0;
}

auto client = Client::create("localhost", "9090", "/");

client->on_open([] {
    std::cout << "Connected!" << std::endl;
});

client->send("chat.message", {"text", "Hello world!"});

app.get("/", [](Request req, Response res) {
    return json::o("message", "Hello from Vix");
});

app.get("/users/{id}", [](Request req, Response res) {
    auto id = req.param("id");
    return json::o("user_id", id);
});

app.get("/search", [](Request req, Response res) {
    auto q = req.query_value("q", "none");
    auto page = req.query_value("page", "1");

    return json::o(
        "query", q,
        "page", page
    );
});

app.get("/missing", [](Request req, Response res) {
    return std::pair{
        404,
        json::o("error", "Not found")
    };
});

app.get("/go", [](Request req, Response res) {
    res.redirect("https://vixcpp.com");
});

app.get("/forbidden", [](Request req, Response res) {
    res.status(403).send();
});

app.post("/echo", [](Request req, Response res) {
    return json::o(
        "received", req.json()
    );
});

struct UserInput {
    std::string name;
    int age;
};

app.post("/users", [](Request req, Response res) {
    UserInput input = req.json_as<UserInput>();

    return std::pair{
        201,
        json::o(
            "name", input.name,
            "age", input.age
        )
    };
});

app.get("/headers", [](Request req, Response res) {
    res.header("X-App", "Vix")
       .type("text/plain")
       .send("Hello headers");
});

app.get("/state", [](Request req, Response res) {
    req.set_state<int>(42);

    return json::o(
        "value", req.state<int>()
    );
});

app.get("/manual", [](Request req, Response res) {
    res.status(200)
       .json(json::o("ok", true));
});

app.get("/items/{id}", [](Request req, Response res) {
    const auto& params = req.params();
    return json::o("id", params.at("id"));
});

app.delete("/items/{id}", [](Request req, Response res) {
    res.status(204).send();
});

Cloud-first frameworks assume:

• stable networks
• predictable latency
• always-online connectivity

But in most of the world, this is not reality.

Vix is built for:

Applications continue functioning even without internet.

Nodes sync and communicate locally without a central server.

C++20 + Asio + zero-overhead abstractions.

• 🌍 Offline-first runtime
• 🔗 P2P-ready communication model
• ⚙️ Async HTTP server
• 🧭 Expressive routing
• 💾 ORM for MySQL/SQLite
• 🧠 Middleware system
• 📡 WebSocket engine
• 🧰 Modular design
• 🚀 Developer experience similar to Node/Deno/Bun
• ⚡ 80k+ requests/sec performance

To set up Vix.cpp on your system:

git clone https://github.com/vixcpp/vix.git
cd vix
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j
./build/hello_routes

Once installed, you can generate a new project using the CLI:

vix new myapp
cd myapp
vix build
vix run

vix dev file.cpp
vix run file.cpp
vix orm migrate

Vix can execute a single .cpp file like a script, without creating a full project.

vix run file.cpp
vix dev file.cpp

• Generates a temporary CMake project under:
  ./.vix-scripts/<filename>/
• Compiles the .cpp file as a standalone executable
• Runs it immediately
• Stops cleanly on Ctrl+C (no gmake noise)

~/myapp/test$ vix run server.cpp
Script mode: compiling server.cpp
Using script build directory:
  • .vix-scripts/server

✔ Build succeeded
[I] Server running on port 8080
^C
ℹ Server interrupted by user (SIGINT)

• 🧭 Introduction
• ⚡ Quick Start
• 🧱 Architecture & Modules
• 💾 ORM Overview
• 📈 Benchmarks
• 🧰 Examples
• 🛠️ Build & Installation
• ⚙️ CLI Options

• 🧩 Core Module — docs/modules/core.md
• 📡 WebSocket Module — docs/modules/websocket.md
• 🗃️ ORM Module — docs/modules/orm.md
• 🔧 JSON Module — docs/modules/json.md
• 🛠️ Utils Module — docs/modules/utils.md
• 🧰 CLI Module — docs/modules/cli.md
• ⚙️ Rix Library (Essential C++ utilities) — docs/modules/rix.md

📊 Summary

Vix.cpp sits at the top of modern backend runtimes, matching or exceeding high-performance frameworks like Go Fiber, and outperforming Deno, Node, PHP, Python, and even several C++ frameworks like Crow.

Vix.cpp = the C++ runtime pushing boundaries.

Contributions are welcome!
Please read the contributing guidelines.

Licensed under the MIT License.