drogonR — Three Ways to Serve HTTP from R

Choosing a variant

The cpp-shared variant is the only one that bypasses R entirely on the request path. The native and shim variants both run an R closure per request — the difference between them is the calling convention (drogonR-native gets a req object; the shim emulates plumber’s positional / named-arg matching).

Performance snapshot

wrk -t4 -c50 -d30s against four servers running the same two routes on localhost. Workload is intentionally trivial — /ping returns a fixed {"ok":true}, /ping-text returns "ok" — so the numbers measure the framework overhead, not the handler cost. See tools/bench/run.sh for the harness.

(rps = requests per second, single-host loopback; latency is the wrk average.) Two things to read out of this:

• The cpp-shared path leaves R entirely — its throughput is bounded by Drogon and the kernel, not by anything in this package.
• Even when an R handler runs per request, the native path is ~100× plumber on JSON and ~200× on plain text, because requests are marshaled onto the main R thread once per dispatch loop instead of per request, and the response is written from C++ without going back through plumber’s R-level filter chain.

The shim is slower than native for the same workload — it pays the cost of plumber’s argument-matching convention (path / query / body lookup, default-serialiser dispatch) on every call. It’s still well above plumber itself because the I/O loop is C++.

A minimal example of each

Variant 1 — cpp-shared (in your inference package):

// In yourPackage/src/handlers.c
#include <drogonR.h>
#include <R_ext/Rdynload.h>

static int h_predict(const char *body, size_t body_len,
                     const char *query,
                     const char *const *path, size_t path_n,
                     const char *const *hdrs, size_t hdrs_n,
                     char **out_body, size_t *out_len,
                     int  *out_status, char **out_content_type) {
    /* run inference, fill out_body via malloc(), set status, ctype */
    return 0;
}

void R_init_yourPackage(DllInfo *dll) {
    R_RegisterCCallable("yourPackage", "predict", (DL_FUNC) h_predict);
}

# In your serving script
library(drogonR)
app <- dr_app() |>
  dr_post_cpp("/predict", "yourPackage", "predict")
dr_serve(app, port = 8080L)

Variant 2 — drogonR native:

library(drogonR)
app <- dr_app() |>
  dr_get("/users/:id", function(req) {
    dr_json(list(id = req$params[["id"]], ok = TRUE))
  })
dr_serve(app, port = 8080L)

Variant 3 — plumber shim:

# Existing plumber.R, unchanged:
library(plumber)
pr <- pr() |>
  pr_get("/users/<id>", function(id) list(id = id, ok = TRUE))

# Only this line changes — drogonR::, not plumber::
drogonR::pr_run(pr, port = 8080L)

Where to go next

• vignette("mode-cpp-shared", package = "drogonR") — full ABI for variant 1, including memory ownership and the threading rule.
• vignette("mode-native", package = "drogonR") — req/res shape, response helpers, middleware, lifecycle of dr_serve().
• vignette("mode-plumber-shim", package = "drogonR") — exact subset of plumber the shim implements, what triggers an explicit error, what’s silently accepted-and-ignored.