Cameleer

Cameleer / Compare / Apache Camel vs Cameleer

Same routes. Measured.

Apache Camel vs Cameleer

Cameleer runs Apache Camel's routes, EIPs and YAML DSL as one native binary. We ran the same routes on both, from in-memory routing to REST APIs, Kafka and PostgreSQL. Cameleer starts in milliseconds, runs in megabytes and moves more messages on the same CPUs.

450xfaster startup3 ms vs 1.1 s
up to 54xless memory8 MB vs 399 MB on the same route
1.7–8.7xthe throughputin every scenario
0changes to Camel YAML routessame URIs, EIPs and DSL

Apache Camel and Cameleer at a glance

Same integration model, different runtime.

Apache CamelCameleer
RuntimeJava virtual machine (or a native image with Camel Quarkus)one native binary, no runtime to install
Routes and EIPsthe reference implementationthe same EIPs, endpoint URIs, Simple expressions and headers
DSLsJava, YAML, XMLYAML, XML and Rust; Camel YAML routes run unchanged
Components300+ componentsabout 230 components, languages and data formats
Startupabout a second on the JVMmilliseconds
Memoryhundreds of MB on the JVMtens of MB
Serverlesswith Camel Quarkus native or a JVM snapshotbuilt-in AWS Lambda runtime
AI agentslangchain4j-agent, the ai-tool abstraction and an MCP server (Camel 4.22)four model components; tools as REST routes with schema validation, idempotency, sagas, approval and audit; MCP server planned
Ecosystemtwo decades, Java libraries, commercial supportyounger project, Rust standard library only

Throughput: in-process routing

Messages per second through the same route on each runtime.

CameleerApache Camel (JVM)Apache Camel (Quarkus native)

Direct call through a route

Cameleer2,230,208 msg/s
Apache Camel (JVM)663,701 msg/s
Apache Camel (Quarkus native)243,522 msg/s

In-memory queue (seda), one-way

Cameleer1,644,186 msg/s
Apache Camel (JVM)603,426 msg/s
Apache Camel (Quarkus native)316,442 msg/s

In-memory queue (seda), request-reply

Cameleer719,433 msg/s
Apache Camel (JVM)117,442 msg/s
Apache Camel (Quarkus native)72,113 msg/s

Content-based router

Cameleer1,144,857 msg/s
Apache Camel (JVM)375,212 msg/s
Apache Camel (Quarkus native)119,416 msg/s

Split and aggregate a JSON order

Cameleer70,926 orders/s
Apache Camel (JVM)26,622 orders/s
Apache Camel (Quarkus native)9,274 orders/s

CSV batch (1,000-row files)

Cameleer998 files/s
Apache Camel (JVM)468 files/s
Apache Camel (Quarkus native)163 files/s

Throughput: APIs, Kafka and databases

Requests per second from clients on another machine, and records per second through Kafka. Kafka and PostgreSQL run on their own machine, as in production.

CameleerApache Camel (JVM)Apache Camel (Quarkus native)

HTTP, fixed reply

Cameleer99,012 req/s
Apache Camel (JVM)56,735 req/s
Apache Camel (Quarkus native)28,584 req/s

REST API with JSON

Cameleer80,367 req/s
Apache Camel (JVM)37,814 req/s
Apache Camel (Quarkus native)17,860 req/s

HTTP into Kafka

Cameleer17,854 req/s
Apache Camel (JVM)10,052 req/s
Apache Camel (Quarkus native)9,267 req/s

HTTP into PostgreSQL

Cameleer11,007 req/s
Apache Camel (JVM)4,710 req/s
Apache Camel (Quarkus native)3,540 req/s

Kafka stream processing

Cameleer6,081 records/s
Apache Camel (JVM)698 records/s
Apache Camel (Quarkus native)694 records/s

Benchmarked use cases

Each one is an ordinary integration, written once and run unchanged on both runtimes. The figure is Cameleer's throughput against Apache Camel on the JVM.

Order API

A REST endpoint reads fields from the JSON order and answers with a JSON confirmation.

2.1x 80,367 vs 37,814 req/s

Order ingestion into Kafka

Each order posted over HTTP is published to Kafka, keyed by order id, then acknowledged.

1.7x 17,854 vs 10,052 req/s

Stream processing

Orders are consumed from Kafka, filtered by amount, reshaped and published to another topic.

8.7x 6,081 vs 698 records/s

Writing to PostgreSQL

Each order posted over HTTP is inserted into PostgreSQL through a pool of 16 connections.

2.3x 11,007 vs 4,710 req/s

CSV batch

A 1,000-row file is split into rows; EU rows are kept, reshaped and written out in batches of 100.

2.1x 998 vs 468 files/s

Order splitting

A JSON order is split into its line items and aggregated back per order.

2.6x 70,926 vs 26,622 orders/s

Full results

Every scenario, including Apache Camel compiled to a native executable with Quarkus. Each figure is the mean of two runs on two identical machines.

Throughput

scenarioCameleerApache Camel (JVM)Apache Camel (Quarkus native)Cameleer vs Camel JVMCameleer vs Camel native
Direct call through a route2,230,208 msg/s663,701 msg/s243,522 msg/s3.3x9.1x
In-memory queue (seda), one-way1,644,186 msg/s603,426 msg/s316,442 msg/s2.7x5.1x
In-memory queue (seda), request-reply719,433 msg/s117,442 msg/s72,113 msg/s6.1x9.9x
Content-based router1,144,857 msg/s375,212 msg/s119,416 msg/s3.0x9.5x
Split and aggregate a JSON order70,926 orders/s26,622 orders/s9,274 orders/s2.6x7.6x
CSV batch (1,000-row files)998 files/s468 files/s163 files/s2.1x6.1x
Kafka stream processing6,081 records/s698 records/s694 records/s8.7x8.7x
HTTP, fixed reply99,012 req/s56,735 req/s28,584 req/s1.7x3.4x
REST API with JSON80,367 req/s37,814 req/s17,860 req/s2.1x4.4x
HTTP into Kafka17,854 req/s10,052 req/s9,267 req/s1.7x1.9x
HTTP into PostgreSQL11,007 req/s4,710 req/s3,540 req/s2.3x3.1x

Latency

scenario, p99 latencyCameleerApache Camel (JVM)Apache Camel (Quarkus native)
Direct call through a route1 µs3 µs10 µs
In-memory queue (seda), request-reply38 µs85 µs137 µs
Content-based router2 µs6 µs22 µs
Split and aggregate a JSON order30 µs70 µs382 µs
CSV batch (1,000-row files)1.7 ms3.2 ms12.5 ms
HTTP, fixed reply2.9 ms3.8 ms7.4 ms
REST API with JSON2.6 ms6.3 ms12.3 ms
HTTP into Kafka8.6 ms7.8 ms12.6 ms
HTTP into PostgreSQL10.6 ms19.8 ms27.7 ms

Memory

scenario, peak memoryCameleerApache Camel (JVM)Apache Camel (Quarkus native)
Direct call through a route7 MB399 MB113 MB
In-memory queue (seda), one-way9 MB440 MB199 MB
In-memory queue (seda), request-reply9 MB257 MB113 MB
Content-based router7 MB332 MB113 MB
Split and aggregate a JSON order8 MB299 MB114 MB
CSV batch (1,000-row files)8 MB337 MB126 MB
Kafka stream processing36 MB214 MB130 MB
HTTP, fixed reply18 MB244 MB121 MB
REST API with JSON19 MB402 MB129 MB
HTTP into Kafka67 MB328 MB129 MB
HTTP into PostgreSQL25 MB273 MB133 MB

Startup

CameleerApache Camel (JVM)Apache Camel (Quarkus native)
Time to a started context2.5 ms1106 ms30 ms
Memory at startup8 MB114 MB69 MB

What about Apache Camel on Quarkus native?

Compiling Camel ahead of time with Quarkus and GraalVM (Mandrel) removes most of the JVM's startup time and memory. It is the closest thing to Cameleer in the Java world, so we measured it too.

What native compilation gives Camel

  • Startup in tens of milliseconds instead of about a second.
  • Much less memory than on the JVM.
  • One executable to ship.

What it costs

  • No JIT compiler: throughput is lower than the same routes on the JVM.
  • Long native builds and closed-world restrictions on reflection and dynamic features.
  • Cameleer still starts faster, uses less memory and has more throughput than both.

How we tested

Three identical cloud machines on one private network, default settings on every runtime, and the servers swapped halfway so neither side got the better machine.

Setup

  • Three DigitalOcean CPU-optimized droplets (c-4): 4 dedicated vCPUs (Intel Xeon Platinum 8168), 8 GB RAM, Ubuntu 24.04, region blr1.
  • Two servers take turns running each runtime; the third runs the HTTP load generator, Apache Kafka 4.3.2 and PostgreSQL 16.
  • Apache Camel 4.23.0 on Temurin 21.0.13. Apache Camel 4.22.1 on Quarkus 3.40.0, compiled with Mandrel 25.0.4.1. Cameleer 0.4.0, built with Rust 1.99.1.

Method

  • The same routes on every side, defined once per language from one specification.
  • 15 s warmup, then five timed 5-second iterations; the figure is the mean of both servers.
  • 64 concurrent HTTP keep-alive connections from the load machine; PostgreSQL pool of 16 on every side.
  • Default settings: no JVM flags, no GC or thread tuning. Peak memory and CPU from /usr/bin/time.

Run it yourself

git clone https://github.com/pmsudhi/cameleer && cd cameleer
export DO_TOKEN_FILE=~/do-token.txt
scripts/cloud-bench/droplets.sh up
scripts/cloud-bench/run.sh all
scripts/cloud-bench/droplets.sh down

The routes are in crates/cameleer-bench, benchmarks/java-camel and benchmarks/camel-quarkus. Raw results: benchmarks/results. The full report with every caveat: BENCHMARKS.

Common questions

Is Cameleer a drop-in replacement for Apache Camel?

For routes written in Camel's YAML or XML DSL with the components Cameleer provides, yes: the same endpoint URIs, EIPs, Simple expressions and headers. Routes that call Java beans or use the Java DSL need those parts rewritten, and a few Camel components have no Cameleer equivalent.

Was the JVM warmed up?

Yes. Every scenario runs 15 seconds of warmup before five timed 5-second iterations, on both sides, so the JIT compiler has finished its work before anything is measured.

Was Apache Camel tuned?

Both sides ran their default settings: no JVM flags, no thread pool or GC tuning, and the same connection pool size for PostgreSQL. The routes are identical on both sides.

What about Apache Camel on Quarkus native?

It is in the benchmark. Native compilation makes Camel start much faster and use less memory than on the JVM, but without a JIT compiler its throughput is lower than on the JVM. Cameleer is faster and smaller than both.

Can I run the benchmark myself?

Yes. The routes, the harness and the scripts that create the cloud machines are in the repository under scripts/cloud-bench; a full run costs about one US dollar of cloud time.

Run your Camel routes on Cameleer

Mount a Camel YAML route and run it. No JVM, no build.

docker run --rm -p 8080:8080 -v "$PWD:/routes:ro" pmsudhi/cameleer run /routes/hello-api.camel.yaml
Get started Migrating from Apache Camel Other alternatives Use cases