Blogs Infinispan 16.2

Infinispan 16.2

June 03, 2026

By Tristan Tarrant

"Arctic Panzer Wolf"

Infinispan 16.2 is here, and it is codenamed "Arctic Panzer Wolf". Like the beer, this release packs a punch: it’s bold, it’s fierce, and there’s a lot of it.

RESP endpoint

This release is a huge step forward for our Redis-compatible RESP endpoint. So many new things that it deserves its own section!

Probabilistic data structures

We’ve implemented a whole family of probabilistic data structures:

Bloom Filters (BF.*): space-efficient probabilistic membership testing. Add items and check whether they might be in the set — with a configurable false positive rate.
Cuckoo Filters (CF.*): like Bloom Filters, but they also support deletion. Handy when your data is more dynamic.
Count-Min Sketch (CMS.*): estimate the frequency of items in a stream without storing all the data. Perfect for anomaly detection and traffic analysis.
Top-K (TOPK.*): maintain a list of the K most frequent items in a stream. While CMS can tell you how many times an item has appeared, Top-K tells you which items appear most often — it tracks the heavy hitters so you don’t have to query every item individually.
HyperLogLog (PFCOUNT, PFMERGE): estimate the cardinality of large datasets using very little memory. Count unique visitors, unique events, unique everything.

All of these work in clustered mode too!

New BITOP operations from Redis 8.2

Keeping up with the latest from Redis, we’ve added the four new bitwise operations introduced in Redis 8.2: These give you finer-grained control over bitwise set operations across keys.

GEOSEARCH commands

The GEOSEARCH family of commands is now fully implemented, letting you perform radius and bounding-box queries on geospatial data.

COPY, DELEX, DIGEST, and more

COPY: copy a key to another key, optionally replacing the destination.
DELEX: delete a key only if it exists (returning whether it was actually deleted).
DIGEST: return a hash digest of a key’s value.
SET conditional options: additional flags for conditional set operations.
PSUBSCRIBE / PUNSUBSCRIBE: pattern-based Pub/Sub subscriptions.
AGGREGATE COUNT option for ZUNION, ZINTER, ZUNIONSTORE, and ZINTERSTORE.
BITFIELD / BITOP: implemented all operations.

Local RESP caches in clustered mode

You can now use local RESP caches in a clustered server. Previously, a local RESP cache created on an unclustered server would prevent the server from starting in clustered mode. No more!

Infinispan Server

Granular JVM options

The server startup scripts now split JAVA_OPTS into independently overridable categories:

JAVA_OPTS_BASE — essential JVM flags (headless, ExitOnOutOfMemoryError, incubator modules)
JAVA_OPTS_NETWORK — network settings (IPv4/IPv6 stack preference)
JAVA_OPTS_MEMORY — heap, metaspace, and RAM percentage configuration
JAVA_OPTS_DEBUG — JPDA debug settings

Want to tweak just the memory settings? Set JAVA_OPTS_MEMORY and leave the rest alone. Setting JAVA_OPTS directly still overrides everything for backward compatibility.

ECS logging support

The server now bundles log4j-layout-template-json, enabling native Elastic Common Schema (ECS) formatted logging out of the box. Just point your Log4j2 config at the built-in ECS template:

<JsonTemplateLayout eventTemplateUri="classpath:EcsLayout.json"/>

No more custom images or runtime library hacking to get structured JSON logs into your Elasticsearch/Kibana stack.

Simplified PEM certificate configuration

TLS configuration with PEM certificates has been unified and simplified. The server now auto-detects keystore types, so you no longer need to juggle different property names for PEM vs PKCS#12 certificates.

Minimal boot logging

The server now uses minimal logging until the classpath is fully configured, preventing noisy or misleading log messages during early startup.

Configurable backpressure for Hot Rod client listeners

The server now supports configurable backpressure for Hot Rod client event listeners. When a client cannot consume events fast enough, the server buffers them up to a configurable limit instead of dropping events or blocking the originating cache operation. This gives operators control over the trade-off between memory usage and event delivery reliability for slow consumers.

Backup support for multimaps, RESP, and Memcached caches

Server backups now include multimap caches as well as caches created via the RESP and Memcached endpoints. Previously, these were silently skipped during backup and restore operations.

RocksDB cache store removed from the server distribution

The RocksDB cache store has been moved out of the server distribution. It is still available as a separate module if you need it, but the server image is now lighter. The bundled SIFS store is the recommended persistence option.

CLI

Suggestions

The CLI now provides suggestions based on your command history and command syntax.

Connection bookmarks

Tired of typing long connection URLs and credentials every time? The new bookmark command lets you save named connection bookmarks:

bookmark set prod -u https://prod-server:11222 --username admin --password secret
connect prod

Passwords are stored encrypted in a PKCS12 credential store. Bookmarks are also used by the new mcp CLI command for a seamless AI integration experience.

Core

JSON configuration schemas

Infinispan now provides JSON schemas that mirror the existing XSD schemas, making it easier to author and validate configuration in JSON and YAML formats with full editor support and autocompletion.

Pull-based state transfer

State transfer has been reworked to use a pull-based approach instead of the previous push model. This gives the receiving node much better control over backpressure and memory consumption during rebalancing. Previously, all existing owners would push data simultaneously, making memory pressure scale linearly with cluster size. The new approach is smarter and more efficient.

Memory monitor

A new MemoryMonitor component tracks JVM memory and GC health with configurable thresholds:

Memory threshold alerts when old generation heap usage exceeds a percentage (default 85%)
GC duration alerts when a single GC pause is too long (default 5 seconds)
GC pressure tracking alerts when too much time is spent in GC over a rolling window

All thresholds are tunable at runtime and configurable via a new <memory-monitor> element.

Dynamic eviction based on memory pressure

Eviction can now be driven by actual JVM memory pressure instead of relying solely on static entry counts or fixed memory sizes. When enabled, Infinispan monitors old generation heap usage and dynamically adjusts eviction thresholds to keep the JVM healthy. This means caches can make the most of available memory without the guesswork of manually sizing max-count or max-size — the system responds to real conditions, evicting more aggressively when memory is tight and relaxing when there is headroom.

Serialized cache entries on heap

You can now store cache entries in their serialized form even when using heap storage. This is particularly useful for entries with many fields where the serialized byte representation is more memory-efficient than the full Java object graph.

Graceful shutdown and network partitions

The graceful shutdown procedure has been hardened to handle network partitions correctly. Previously, star-shaped partitions (where the coordinator could see all nodes, but nodes couldn’t see each other) during restart could lead to data loss. This has been fixed.

Orderly cache scale-down

Stopping a cache or (concurrently) scaling down a cluster node while state transfer is in progress could previously result in data loss: the departing node would leave before its data had been fully redistributed to the remaining members. New overloads on Cache.stop(timeout, TimeUnit), EmbeddedCacheManager.stop(timeout, TimeUnit), and EmbeddedCacheManager.stopCache(cacheName, timeout, TimeUnit) let you specify how long to wait for any in-flight state transfer to complete before leaving. If the timeout elapses, the method returns false so you can decide what to do next. The existing no-arg stop() methods continue to work as before.

Generic Micrometer MeterRegistry support

Infinispan now supports any Micrometer MeterRegistry, not just Prometheus. This means you can use OTLP, Simple, or any other Micrometer registry implementation without needing a Prometheus dependency on the classpath.

Counter configuration events

Counter configuration changes (add/modify/remove) now generate container events and are streamed via the REST SSE listeners. This enables the Infinispan Operator to implement Counter custom resources.

SIFS persistence store improvements

The Soft-Index File Store (SIFS) has received several reliability and performance improvements:

Buffered index updates: index writes are now batched in memory before being flushed to disk, reducing the number of I/O operations and improving write throughput.
B+ tree refactoring: the internal B+ tree used for the SIFS index has been extracted into a standalone, independently testable class, resolving a number of hard-to-reproduce corruption issues related to soft reference reclamation and concurrent access.
Segment lifecycle fixes: fixed a race condition where rapid segment removal and re-addition could corrupt the index, and ensured that segment removal completes fully before the segment can be reused.
Persistence timeout support: persistence operations now have configurable timeouts, preventing the system from hanging indefinitely when a store operation stalls or a lock is never released.

ProtoStream

The ProtoStream serialization library has seen major improvements across performance, usability, and JSON support:

ASCII string optimizations: writing ASCII strings now takes advantage of the JVM’s internal String coder and value fields, and uses VarHandle for fixed-width writes, reducing encoding overhead.
Kotlin support: the annotation processor now supports Kotlin classes and data class types.
Copy-on-write serialization context: the serialization context state is now copy-on-write, improving thread safety when schemas are registered concurrently as well as improving performance.
JPMS support: ProtoStream is now fully modularized with proper module-info descriptors.

Query

ANTLR 4

The Ickle query parser has been migrated from the unmaintained ANTLR 3 to ANTLR 4, improving reproducible builds and eliminating a stale runtime dependency.

Spring Boot

Automatic schema registration

The Spring Boot integration now automatically registers Protobuf schemas, matching the behavior that was already available in the Quarkus integration.

Console

The web console has received a batch of usability improvements:

User permissions page: a new page to display current user permissions, making it easier to understand who can do what.

Schema editor with syntax highlighting: the schema editor now uses the Monaco code editor with Protobuf syntax highlighting and code assistance.

Manage columns in cache detail: customize which columns are displayed in the cache entries view.

Query history: your recent queries are now remembered, so you can quickly re-run them.

Swagger UI and metrics links: direct links to the Swagger UI and metrics endpoints from the console.
Truncate result values: a checkbox to truncate long values in query results for better readability.
Persistent pagination settings: pagination preferences are now remembered across sessions.
Cache deletion from detail view: delete a cache directly from its detail page.
Internationalization: updated translations for French, Spanish, Italian, and Brazilian Portuguese.

MCP

CLI stdio transport

Connecting your AI tools to Infinispan just got a whole lot easier. We’ve added an mcp command to the CLI that acts as a stdio transport bridge for the Model Context Protocol.

This means you can now use Infinispan as an MCP server from Claude Desktop, Claude Code, VS Code, or any other MCP client:

{
  "mcpServers": {
    "infinispan": {
      "command": "infinispan",
      "args": ["mcp", "--bookmark", "prod-cluster"]
    }
  }
}

The CLI command connects to the server’s /v3/mcp HTTP endpoint and proxies JSON-RPC messages via stdin/stdout. Use it with CLI bookmarks (we mentioned those above!) for a seamless, secure connection.

GC log as MCP resource

The server’s GC log is now exposed as an MCP resource, so your AI tools can inspect garbage collection behavior directly.

Backwards compatibility

Infinispan 16.2 is fully backwards compatible with 16.1 deployments.

The next release

According to our roadmap, our next release will be 16.3, and it will happen on 2026-10-07.

Release notes

You can look at the release notes to see what was changed since our previous release.

Get them from our download page.

Get it, Use it, Ask us!

We’re hard at work on new features, improvements and fixes, so watch this space for more announcements!

Please, download and test the latest release.

The source code is hosted on GitHub. If you need to report a bug or request a new feature, look for a similar one on our GitHub issues tracker. If you don’t find any, create a new issue.

If you have questions, are experiencing a bug or want advice on using Infinispan, you can use GitHub discussions. We will do our best to answer you as soon as we can.

The Infinispan community uses Zulip for real-time communications. Join us using either a web-browser or a dedicated application on the Infinispan chat.

Tristan Tarrant

Tristan is the Infinispan lead. He's been a passionate open-source advocate and contributor for over three decades.