Integration routes. On the JVM. In Rust.

Apache Camel and us.

Cameleer exists because Apache Camel got integration right: its patterns, endpoint URIs and YAML DSL are what Cameleer follows, name for name, so the routes you have run unchanged. Cameleer is an independent Rust implementation in the style of Apache Camel. It contains no Camel source code and is not affiliated with or endorsed by the Apache Software Foundation; the comparisons on this site are factual and name the exact versions measured.

Found a route that behaves differently on Cameleer? That is a bug: report it with the route and both outputs. · Migrating from Apache Camel · Cameleering, the practice behind it

Keep your routes. Change the runtime.

The same YAML runs on Apache Camel and on Cameleer. Switch the runtime and watch what changes, including Apache Camel compiled natively with Quarkus.

- route:
    id: triage
    from:
      uri: kafka:support-tickets
      steps:
        - to: "openai:chat-completion?model=gpt-4o-mini"
        - choice:
            when:
              - simple: "${body} contains 'URGENT'"
                steps:
                  - to: kafka:tickets-urgent
            otherwise:
              steps:
                - to: kafka:tickets-routine

Faster in every scenario we measured.

The same routes on Cameleer and Apache Camel: APIs, Kafka, PostgreSQL and in-memory routing.

One loss: p99 latency for HTTP into Kafka is 8.6 ms against Apache Camel's 7.8 ms, while serving 1.7 times the requests. Plain HTTP reaches 68% of a do-nothing server on the same machines; simoom, the new HTTP engine, is measured to close that gap (its ledger rows). Apache Camel compiled natively with Quarkus starts faster than on the JVM but has lower throughput; it is in the full comparison. Every scenario, the method and the raw data.

What people run on it.

Each use case has a tested route in the repository and a page that explains it. A 3 ms start and an 8 MB footprint change where integration code can run.

Cameleer at a glance.

Version

0.6.0 (2026-11-12)

Licence

Apache License 2.0

Container

docker run cameleering/cameleer:0.6.0; health pack: :health

CLI

cargo install cameleer (the cameleer command); in Rust, cargo add cameleer. The cameleer crate wraps cameleer-main, which works the same

Source

github.com/cameleering/cameleer

Platforms

Linux, macOS, Windows; images for linux/amd64 and linux/arm64; AWS Lambda

Dependencies

none outside the Rust standard library

Affiliation

independent; not affiliated with the Apache Software Foundation

Start with Cameleer: your first route in a minute.

Use the container, the Rust crates or the CLI. Every example here is a file in the repository, run end to end by the test suite.

- rest:
    path: /orders
    get:
      - path: /{id}
        to: direct:getOrder
- route:
    from:
      uri: direct:getOrder
      steps:
        - setBody:
            simple: '{"id": "${header.id}", "status": "shipped"}'

use cameleer_core::prelude::*;
use cameleer_http::rest::RestDslExt;

fn main() -> Result<()> {
    let ctx = CamelContext::new();
    cameleer_http::register(&ctx);
    ctx.properties().set("camel.server.port", "8080");
    ctx.add_routes(|b| {
        b.rest("/api/greet").get("/{name}").to("direct:greet");
        b.from("direct:greet")
            .set_body(simple(r#"{"greeting": "Hello, ${header.name}!"}"#));
    })?;
    ctx.start()?;
    loop { std::thread::park(); }
}

$ cameleer run hello-api.camel.yaml
INFO  HTTP server started on 0.0.0.0:8080
INFO  Cameleer 0.6.0 (camel-1) started (3 routes, 3 started)

$ cameleer validate hello-api.camel.yaml   # before it runs
$ cameleer --help
init, run, validate, schema, export, bind, ps, stop, get, cmd, log, trace, catalog, version

Real use cases, ready to run

• AI ticket triageKafka in. An LLM classifies each ticket P1 or P3, and urgent tickets go to their own topic. OpenAI or any compatible server: Ollama, vLLM, Azure OpenAI.
• Alerts to SlackAn HTTP webhook takes monitoring alerts, keeps the critical ones and posts them to a Slack channel.
• Files to S3Watches a folder, uploads each new CSV file to an S3 bucket, then moves it to .done.
• REST APIJSON endpoints with validation, a content-based router and error handling. Needs nothing else.

- route:
    id: ticket-triage
    from:
      uri: "kafka:support-tickets?brokers={{env:KAFKA_BROKERS:localhost:9092}}&groupId=triage&autoOffsetReset=earliest"
      steps:
        - setProperty:
            name: ticket
            simple: "${body}"
        - to: "openai:chat-completion?model={{env:OPENAI_MODEL:gpt-4o-mini}}&baseUrl={{env:OPENAI_BASE_URL:https://api.openai.com/v1}}&temperature=0&systemMessage=Classify the support ticket. Reply P1 for outages, data loss or security issues, otherwise P3. Reply with P1 or P3 only."
        - setHeader:
            name: priority
            simple: "${body}"
        - setBody:
            simple: "${exchangeProperty.ticket}"
        - choice:
            when:
              - simple: "${header.priority} contains 'P1'"
                steps:
                  - to: "kafka:tickets-urgent?brokers={{env:KAFKA_BROKERS:localhost:9092}}"
            otherwise:
              steps:
                - to: "kafka:tickets-routine?brokers={{env:KAFKA_BROKERS:localhost:9092}}"

# docker run --rm --network host -e KAFKA_BROKERS=localhost:9092 -e OPENAI_API_KEY \
#   -v "$PWD:/routes:ro" cameleering/cameleer run /routes/ai-ticket-triage.camel.yaml