Reading this comparison honestly
Most caches are a hash map with a network adapter bolted on. Aeron Cache is the inverse: it begins with Aeron — the messaging fabric used to move orders on exchanges — and treats the key-value (and counter) store as a deterministic replicated state machine riding on top of it. That starting point is what shapes every comparison below. Aeron Cache is not trying to be the biggest cache or the most feature-dense database; it is trying to be the one with the most predictable path from a write on one node to a delta on a subscriber’s socket.
Its niche is the intersection of five properties that rarely ship together as one integrated system: low-latency design (SBE binary codecs, Agrona buffers, single-threaded agents), high availability through RAFT consensus (Aeron Cluster, snapshots, cluster timers), patch-native streaming (JSON Merge Patch deltas pushed to subscribers, not invalidation messages), polyglot embedded clients that keep a local mirror for network-free reads, and multiple transports (HTTP, WebSocket uni/bidi, SSE, and a native Aeron SBE gateway) over one consistent command surface. Any single one of these you can find elsewhere. The point is having them as a coherent whole.
The honest framing, then: the table below compares defensible, well-known public characteristics of each system. Where a competitor’s behaviour is configurable or version-dependent, we keep the claim general rather than pretend to a precision we cannot defend. And Aeron Cache is pre-1.0 — the engineering is real and soak-tested, but you should weigh maturity alongside capability. We say where it fits and where it does not.
The main comparison
| Dimension | Aeron Cache | Redis | Hazelcast | Memcached | Apache Ignite | Infinispan |
|---|---|---|---|---|---|---|
| Primary model | Key-value and counter caches (int64), per-item TTL | Key-value with rich data structures (lists, sets, hashes, streams) | Distributed maps, plus other data structures | Key-value only, flat strings/blobs | Distributed key-value with SQL tables and compute | Distributed key-value data grid, with indexing and queries |
| Consistency / HA model | Strong, leader-based replication via RAFT; deterministic replicated state machine | Primary-replica async replication; strong consistency is opt-in, not the default posture | Distributed partitions with configurable backups | None built in — each node is independent | Partitioned with backups; configurable consistency | Distributed/replicated modes; primary owner + backups, sync or async |
| Clustering / consensus | Aeron Cluster (RAFT) by default; 3-node StatefulSet. Also single-node ephemeral and monolith modes | Clustering via Redis Cluster (hash slots) or Sentinel for failover | Native peer-to-peer clustering | No native clustering; sharding is client-side | Native clustering with partition rebalancing | Native peer-to-peer clustering (JGroups); consistent-hash distribution |
| Wire protocols / transports | HTTP, WebSocket (uni + bidi), SSE, native Aeron SBE (UDP/IPC) | Primarily the RESP protocol over TCP | Native binary client protocol | Memcached text/binary protocol | Native binary client protocol, plus JDBC/ODBC | Hot Rod binary, REST and RESP; plus embedded (library) mode |
| Streaming / pub-sub | First-class: keyed and patch-mode streaming subscriptions with a subscribe-ack barrier | Pub/Sub and Streams are available as separate features | Event listeners and reliable topics | None | Continuous queries and events | Client listeners and continuous queries |
| Partial updates (JSON merge patch) | Native: RFC 7386 deep-merge on JSON values, with PATCH_ITEM deltas streamed to subscribers | Field-level ops exist for hashes; no built-in JSON merge-patch on string values (module-dependent) | Entry processors for in-place mutation | No — value is opaque, replace only | SQL UPDATE on columns; no merge-patch on opaque values | Functional/compute entry mutations; no JSON merge-patch on opaque values |
| Embedded / near cache | Near cache (read-ahead) and client-side embedded mirror kept live via the stream, in all four client languages | Client-side caching is available in newer protocol versions | Native near cache | Not applicable | Native near cache | First-class embedded (library) mode; near cache for Hot Rod clients |
| Persistence | Replicated log + periodic snapshots (Aeron Archive); in-memory state rebuilt from them | Optional RDB snapshots and AOF append log | Optional persistence add-on | None — purely in-memory | Native disk persistence and durable storage | Optional cache stores (passivation, write-through/behind) |
| Client languages | Java, TypeScript, Python, Rust embedded clients; Rust CLI; any HTTP/WS/SSE client | Very broad client ecosystem across languages | Clients across several languages | Broad, simple-protocol clients | Clients across several languages, plus SQL tooling | Java (native); Hot Rod clients incl. C++, C#, Node.js, Python |
| Deploy (K8s / brew) | Helm charts (clustered, ephemeral, monolith); Homebrew local monolith + UI | Containers, managed services, operators | Containers, Kubernetes operator | Containers, packages | Containers, Kubernetes deployment | Containers, Kubernetes operator |
| License | MIT | Source-available / varies by distribution and version | Open-source and enterprise editions | BSD | Apache 2.0 | Apache 2.0 |
Takeaway: Redis and Ignite are broader; Memcached is simpler; Hazelcast and Infinispan overlap most on the distributed-maps-plus-near-cache axis, and both offer a first-class embedded (library) mode for the JVM. Aeron Cache’s distinguishing line is the combination of RAFT strong-consistency-by-default, patch-native streaming, and a native low-latency binary transport, delivered as one system with embedded polyglot clients.
Where Aeron Cache fits
- Low-latency fan-out of changing state. When many readers need to see a write quickly and you would rather stream what changed than invalidate-and-refetch, the patch-mode subscriptions and the Aeron SBE transport are the reason to choose it. See streaming subscriptions.
- High-availability control-plane and operational state. RAFT consensus plus snapshots means the cluster survives node loss without electing a stale leader or losing committed writes. See RAFT consensus.
- JSON state that mutates field-by-field. Feature flags, pricing objects, config documents — anything where a tick changes one nested field and you do not want to resend the whole object. See JSON Merge Patch.
- Read-heavy services that want network-free reads. The embedded cache mirrors server state locally and keeps it live over the stream, so a
getItemis a local map lookup, not a round-trip. - Polyglot shops. The same high-level API is offered in Java, TypeScript, Python and Rust, with the Aeron SBE transport available in Java and Rust.
The four transports at a glance
All four transports speak to the same cache and counter model; they differ in how they are framed, which directions they carry, and how far down the latency curve they go. Choose by the shape of the client, not by preference.
| Transport | Latency orientation | Directionality | Streaming | Client languages | When to use |
|---|---|---|---|---|---|
HTTP REST (:7070 /api/v1) | Standard request/response | Request → response | No (commands only) | Any HTTP client; all 4 embedded langs | CRUD, scripting, tooling, broad compatibility; always on |
WebSocket (:7071) | Low-latency, persistent | Uni (subscribe routes) and bidi (/api/ws/v1/bidi) | Yes | All 4 embedded langs | Live subscriptions, or full command + subscribe surface over one socket |
SSE (:7072 /api/sse/v1) | Low-latency, persistent | Server → client only | Yes (receive only) | Any SSE client; all 4 embedded langs | Browser-friendly, firewall-friendly one-way streaming of updates |
Aeron SBE gateway (UDP :7075/:7076 or IPC) | Lowest-latency, binary zero-copy | Bidirectional | Yes | Java, Rust | Latency-sensitive services that want commands + streaming over Aeron |
The SSE and uni-WS routes support keyed filters and patch mode via query parameters; the bidi WebSocket and Aeron gateway carry the full command surface plus dynamic subscribe/unsubscribe, correlated per request. For the binary path’s internals — schema id 7, little-endian, zero-copy flyweight codecs — see Aeron + SBE transport.
Next steps: get it running at Getting Started, pick a client at embedded clients, or read the API overview for the exact endpoints.