I spent a year building Apache Camel for .NET. Here's the honest state of it.

#dotnet #csharp #opensource #discuss

I've spent the last year building an integration ecosystem for .NET that I think fills a real gap. Three repos just went public. This post is the honest account — what it does, what it doesn't do yet, and three questions I genuinely don't know the answer to.

The gap

If you need Apache Camel in .NET, you don't have it.

MassTransit, Wolverine, NServiceBus are message buses — great at what they do, but they give you 4–7 transports and a Saga pattern. Apache Camel has 300+ components and 80+ EIP patterns as first-class DSL. But it's JVM.

There's no .NET project that gives you the full EIP catalogue —
Splitter, Aggregator, Content-Based Router, Recipient List, Dynamic Router,
Wiretap, Dead Letter Channel — as a fluent C# DSL with 20+ transports.

So I wrote one.

What I built

redb.Route — Camel-style fluent C# DSL. Apache 2.0.
github.com/redbase-app/redb-route

22 transports: Kafka, RabbitMQ, Redis, SQL polling, HTTP, gRPC, SFTP, MQTT,
S3, IBM MQ, AMQP 1.0, Azure Service Bus, Elasticsearch, LDAP, Mail, TCP,
WebSocket, SignalR, FTP, Quartz, File — plus 5 built-in (direct, seda, timer, log, mock).

30+ EIP processors as first-class DSL steps. Compiled expression engine:
${header.price} * 1.2 compiles to Func<IExchange, decimal> via
System.Linq.Expressions at route-build time. No interpreter at runtime.

redb.Tsak — runtime container for redb.Route modules. Apache 2.0.
github.com/redbase-app/redb-tsak

Drop a .dll or .tpkg (ZIP + manifest) into a folder. Tsak picks it up,
wires the DI container, starts the routes. Hot-reload — replace the file while
running, zero downtime. REST API + CLI + Blazor dashboard.

Cluster: leader election + auto-rebalance, no ZooKeeper/etcd/Consul.
Coordination lives entirely in EAV (row locks + SELECT FOR UPDATE CAS + epoch fencing).

Closest analogues are Apache Karaf and Camel K. Both JVM-only until now.

redb.Core — the storage layer underneath. Apache 2.0.
github.com/redbase-app/redb

EAV-style typed object store over Postgres / MSSQL with full LINQ. Schema is a
C# class with [RedbScheme]. Values live in typed columns with FK constraints —
not JSON blobs. SyncSchemeAsync<T>() at startup, no migration files.

[RedbScheme("Order")]
public class OrderProps
{
    public string  Status { get; set; } = "";
    public decimal Total  { get; set; }
}

// Inside a route pipeline:
.ProcessWithRedb("pg-main", async (redb, ex, ct) =>
{
    var id = await redb.SaveAsync(new RedbObject<OrderProps>
    {
        name  = $"Order-{DateTime.UtcNow:HHmmss}",
        Props = new() { Status = "new", Total = 299.99m }
    });
    ex.In.Headers["order-id"] = id;
})
.To("rabbitmq://processed");

Production state

Running at East-West / EWS — a 30-year-old national HoReCa
food distributor in Russia.

~150k orders/month, ~20k B2B customers, 600+ cities
3-node cluster (4 cores / 8 GB / 50 GB SSD per node)
~550 daily users, ~3 months stable, 10–15% CPU under full load
Routes integrate: SAP, Kafka, RabbitMQ, GPS feeds, Mercury / EGAIS / Chestny Znak / FGIS Grain (Russian regulatory systems)

43 NuGet packages, ~8.4k total downloads. Real but small.

What's honest

Bus factor of 1. I'm the solo author of the framework code. Publishing
to find early users and get harsh feedback.

Pro tier exists. Commercial license covers: compiled expression-tree-to-SQL,
parallel materialization, change-tracking diff, schema migrations.
Everything above — Route, Tsak, Core CRUD/LINQ/trees/security/export,
22 transports, hot-reload, cluster — is Apache 2.0 and stays free.

No third-party benchmarks yet. Internal Free-vs-Pro numbers at
redbase.app/results — treat as
"how editions compare on the same machine", not universal claims.

Architecture writeup: redbase.app/architecture

redb.Identity (near-complete, not yet public) — OAuth 2.0 / OIDC server
built on redb.Core. Authorization Code + PKCE, Client Credentials, Device Code,
Refresh Token, PAR, DPoP, backchannel logout, private_key_jwt. Apache 2.0.

Three questions I don't have the answer to

1. Is "another integration framework" the wrong framing?

The gap I described feels real to me — I lived with it for years before building
this. But maybe .NET teams that need Camel just use Camel via NativeAOT interop,
or have given up on the EIP model entirely. Curious what you've actually done.

2. Does "EAV" as a term kill the pitch?

redb.Core uses EAV — and that word triggers people (slow, untyped, joins
everywhere). The design is typed columns + FK constraints + 40+ indexes, not
JSON blobs. But maybe the term itself is a non-starter regardless of the
implementation. Has anyone successfully reframed EAV to a skeptical audience?

3. What makes a Pro/Free split feel fair vs bait-and-switch?

The free tier covers everything you need to build and run production pipelines.
Pro adds performance features (compiled SQL, parallel materialization) and ops
features (change tracking, migrations). Is that split legible from the outside,
or does "compiled queries are Pro" read as "the free tier is intentionally crippled"?

Links


redb.Route	github.com/redbase-app/redb-route
redb.Tsak	github.com/redbase-app/redb-tsak
redb.Core	github.com/redbase-app/redb
Architecture	redbase.app/architecture
Discussions	github.com/redbase-app/redb-route/discussions