C++ already gives developers exceptional performance, control, and a mature ecosystem. But when it comes to web development, getting from an empty project to a structured HTTP application can still involve considerably more friction than it does with many modern frameworks.

I wanted something different: a framework with familiar concepts like routing, controllers, middleware, dependency injection, model binding, and validation, while retaining the performance and control that make C++ compelling in the first place.

That project became Mach.

Yesterday, after a couple of months of development, I released Mach v1.0.0, the first stable release of the framework.

What Does Mach Look Like?

At its simplest, a complete Mach application requires only a few lines of C++:

#include <mach/mach.hpp>

int main() {
    mach::AppBuilder builder;
    auto app = builder.build();

    app.mapGet("/", [] {
        return mach::ok("Hello from Mach!");
    });

    return app.run();
}

This is a complete Mach application. AppBuilder configures the application, build() creates it, and mapGet() maps a handler directly to an HTTP route. Returning mach::ok() produces the response, while run() starts the server.

The minimal API is intentionally small. For simple applications, you can define routes directly like this. As an application grows, Mach also provides controllers, middleware, dependency injection, model binding, validation, and other tools for structuring larger projects.

Why Mach?

One of the main goals behind Mach is to provide the kind of developer experience that has become standard in modern web frameworks without trying to hide C++ itself.

Mach is built around modern C++20 and a strongly typed API. Rather than relying heavily on macros, configuration files, or runtime conventions, the framework aims to make as much as possible explicit and verifiable at compile time.

At the same time, performance has been a priority from the beginning. Mach is built on top of Boost.Asio and Boost.Beast, using asynchronous I/O while providing a higher-level API for application development.

The result I’m aiming for is a framework where C++ developers can build an HTTP API without spending most of their time assembling the infrastructure around it.

What’s Included in Mach 1.0

Mach 1.0 includes the core features needed to build structured HTTP applications, including routing, controllers, middleware, dependency injection, model binding and validation, JSON serialization, configuration, logging, CORS and CSRF protection, and centralized error handling.

These features are designed to work together as part of the framework while remaining unobtrusive when they aren’t needed. A small application can remain small, while larger applications can adopt additional structure as they grow.

Performance

Performance has been a priority throughout Mach’s development. The framework is built on Boost.Asio and Boost.Beast and uses asynchronous I/O underneath its higher-level APIs.

In the final pre-release benchmarks, Mach handled approximately 278,000 requests per second in a simple HTTP request benchmark.

As with any framework benchmark, results depend heavily on the workload, hardware, compiler, and configuration. The number isn’t intended to represent the performance of every Mach application, but it provides a useful indication of the framework’s baseline HTTP performance.

Getting Started

Mach supports Windows and Linux and integrates with CMake, making it straightforward to add to an existing C++ workflow.

The documentation covers installation, routing, controllers, model binding, validation, middleware, configuration, security, error handling, and the rest of the framework, along with a complete tutorial for building an API with Mach.

You can get started here:

Documentation: https://machframework.dev/
GitHub: https://github.com/machframework/mach

What’s Next?

Mach 1.0 is an important milestone, but it’s also the beginning of the project as a stable, publicly available framework.

From here, my focus is on improving the framework based on real-world usage, expanding the ecosystem and tooling around it, and continuing to refine the developer experience without sacrificing the performance and type safety that Mach was built around.

Mach is open source under the MIT license, and contributions are welcome. I’d also be very interested to hear feedback from C++ developers, whether about the API design, implementation, documentation, performance, or the overall direction of the project.

If you decide to try Mach, I’d love to hear what you build with it.