Infinispan

Infinispan 16.1

2026-02-04T01:00:00+01:00

"Polly Want a Pilsner"

Infinispan 16.1 is here, and it is codenamed "Polly Want a Pilsner".

It is the first release that follows our time-boxed plan.

Container-based eviction

Prior to this release, it was only possible to configure memory bounds for individual caches.

Infinispan 16.1 introduces the concept of bounded memory containers: configure a global container (you can have more than one), and whether you want it to be bound by count or by memory and reference that container name in the cache configuration.

The following diagram shows the difference between per-cache and container eviction

In the example below, the memory configuration for caches a and b combined will be bounded at 100MB:

OpenAPI / Swagger

Infinispan 10 introduced the v2 REST endpoint which aimed to improve the original API and expand it with all the requirements we added for data and system management. Unfortunately that API was designed in a way that made it impossible to represent via an OpenAPI descriptor.

Infinispan 16.1 introduces a new v3 REST API which is OpenAPI-compliant.

To try it out, start an Infinispan Server and point to http://127.0.0.1:11222/swagger-ui/

Query and Lucene 10

Thanks to the work done by our friends over at Hibernate Search, Infinispan now supports both Lucene 9 and 10.

Infinispan Server

Server now requires Java 25

Our server image has already included Java 25 since 16.0, but we’ve now made this a hard requirement for bare metal deployments too. Don’t worry: the clients can continue running with ye olde legacy Java versions of choice.

Lucene 10.3

By requiring Java 25, the server can now include Lucene 10.3, which can leverage SIMD to increase performance in several areas.

Pre-start batch scripts

The server can now automatically execute batch scripts before start. This feature is primarily intended for our operator in order to prepare the server according to its configuration, but it may also be useful for your own use-cases.

AOT cache in the container image

The server image now includes an AOT cache to reduce startup and warmup time.

CLI batch error handling

The CLI has been enhanced to better report errors during batch execution: you can now decide to fail-fast, fail-at-end or ignore batch errors altogether.

Default mechanisms

Infinispan Server no longer enables weak/vulnerable authentication mechanisms by default: algorithms which use MD5 and SHA-1 must be explicitly enabled if you want to keep using them.

Backwards compatibility

Infinispan 16.1 is fully backwards compatible with 16.0 deployments.

The next release

According to our roadmap, our next release will be 16.2, and it will happen on 2026-06-03.

Release notes

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

Get them from our download page.

Infinispan Insights: Supporting Redis JSON and Scripting features with Infinispan

2026-01-14T01:00:00+01:00

In Infinispan 15, we added a variety of commands to help replace your Redis server without changing your code. The 15.2 release also included Lua Scripting and Redis JSON APIs. Key takeaways:

Understanding Redis JSON commands
The benefits of Lua scripting
How and why transition applications from Redis to Infinispan, or use Infinispan as a backend while working with Redis clients.

This article follows up on supporting multiple Redis databases with Infinispan. For more details, check out the full article.

Redis drop-in replacement with Infinispan

A drop-in replacement means you can substitute one technology for another without changing application code. This is valuable because:

Minimizes migration effort: You avoid rewriting logic or changing client libraries significantly.
Reduces downtime and risk: You can swap the backend and test incrementally.
Retains existing usage patterns: Developers can continue using the familiar APIs and data models.

Replacing open-source Redis with Infinispan offers several key benefits, especially for Java-based or enterprise-grade systems. Infinispan is fully open source under Apache 2.0, avoiding the licensing limitations of Redis modules. It provides advanced clustering, built-in high availability (Active-Active cross site replication), and better support for distributed and geo-replicated setups. It supports multiple databases even in clustered mode and it offers flexible persistence options like write-through and write-behind. Additionally, it includes robust security features such as fine-grained access control and encryption, and supports multiple deployment modes including embedded, server, and Kubernetes-native.

Let’s test how this works, now also with JSON commands and Lua scripts.

Running Infinispan as usual

Get started tutorial is the best place to start. Just run the following command with docker or podman.

podman/docker run -it -p 11222:11222 -e USER="admin" -e PASS="password" quay.io/infinispan/server:latest

Running Infinispan with the Redis default port

For those want to keep using the 6379 port, run Infinispan providing the following configuration file:

podman/docker run -it -p 6379:6379 -p 11222:11222 -e USER="admin" -e PASS="password" quay.io/infinispan/server:latest -c infinispan-resp.xml

Map -p 6379:6379 -p 11222:11222 (you keep the access to the console)
Provide -c infinispan-resp.xml configuration file
-e USER="admin" -e PASS="password will be used for 11222 port security

Using a Redis client

Once the server is running, connect to Infinispan using Redis-CLI. Use port 11222 instead of the default 6379 if you are running Infinispan as usual. Since Infinispan is secured by default, make sure to provide the admin credentials.

> redis-cli -3 -p 11222 --raw
127.0.0.1:11222> AUTH admin password
OK

Connect using Protocol 3
Use -p 11222 (Infinispan single port)
Add --raw option to allow formatting
Authenticate with admin/password

You can access the Infinispan Server Console as usual in http://localhost:11222, with admin/password credentials. Check the (cache aliases tutorial to learn more about respCache and how it connects to Redis Databases and cache aliases.

Redis JSON Feature

RedisJSON is a powerful extension for managing JSON data directly in Redis. If you’re working with JSON-like data and need fast, efficient access and manipulation, RedisJSON is a great tool to use. This is part of the RedisStack or Redis Enterprise, and works with the JSON Query engine (which is not supported by Infinispan for now).

127.0.0.1:11222> JSON.SET doc $ '{"project":"infinispan", "details": {"latest": "16.0", "year": 2025}}'
OK
127.0.0.1:11222> JSON.GET doc INDENT "\t" NEWLINE "\n" SPACE " " $
[
	{
		"project": "infinispan",
		"details": {
			"latest": "16.0",
			"year": 2025
		}
	}
]
127.0.0.1:11222> JSON.OBJKEYS doc $
project
details

In the console, the REST API currently shows the key, and the value is only displayed as the JSON.Bucket. Additional support for displaying more data is planned for future Infinispan releases, so we just need to wait a bit for the ability to show more content through the REST API.

All JSON commands are implemented for the RESP 3 responses.

Scripting Feature

Lua scripting in Redis lets you write small programs in the Lua language that run directly on the Redis server. This helps you perform multiple actions in one go, saving time and making things faster. You can use it to do complex tasks without sending many commands back and forth between the client and server.

Since Infinispan 16.0, you can now use Lua Scripting to perform these operations.

127.0.0.1:11222> EVAL "return 'Hello, scripting!'" 0
Hello, scripting!
127.0.0.1:11222> EVAL "return ARGV[1]" 0 Hello
Hello
127.0.0.1:11222> EVAL "return ARGV[1]" 0 Parameterization!
Parameterization!
127.0.0.1:11222> EVAL "redis.call('SET', KEYS[1], ARGV[1]) redis.call('SET', KEYS[2], ARGV[2]) redis.call('SET', KEYS[3], ARGV[3]) return 'SET commands executed'" 3 key1 key2 key3 value1 value2 value3
SET commands executed
127.0.0.1:11222> KEYS "*"
key2
key3
key1
doc

Technically speaking, when using Infinispan, scripts are stored in an internal cache ___script_cache. This cache is handled by Infinispan and manipulating it requires admin permissions.

Conclusions

In this tutorial, you’ve learned how to use Infinispan for JSON commands and Scripting from version 16.0. Redis Hot Replacement is gaining attention, especially with the concerns about Redis' licensing changes in 2024. Infinispan, an open-source solution under the Apache 2.0 license, is part of the Commonhaus foundation, allowing free use in your products. If you need official support, you can get it through supported versions of Infinispan.

Infinispan 16.0.5

2025-12-18T01:00:00+01:00

We don’t usually blog about micros… but this is the second time in as many days that I have to break with tradition.

Serious ProtoStream bug with Latin1 strings

If you were using strings that could be represented as Latin1/ISO-8859-1 in your protocol buffer payloads, ProtoStream was corrupting them. ASCII and full UTF-8 were fine. We’ve now fixed this bug. Thanks Sergey Filipkov for reporting this.

Java serialization failure to serialize some collections

Another marshalling bug was affecting Java serialization of some collection types. Thanks Rato for reporting this

Release notes

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

Get them from our download page.

Infinispan 16.0.4

2025-12-17T01:00:00+01:00

We don’t usually blog about micros, unless there are important things to mention, and in this case we have a couple of significant changes to share with you.

Spring Framework 7 and Spring Boot 4 support

Spring Framework 7 and Spring Boot 4 were released just after we tagged 16.0.0. We were planning on releasing support for these with the 16.1 release at the beginning of February, but we decided it was too important to wait until then. 16.0.4 includes artifacts for both Spring 7 / Boot 4 and Spring 6 / Boot 3. See the documentation for details

Metrics changes

We forgot to make some changes to the default metrics configuration attributes during the 16.0 development cycle, even though that was our intention all along.

JVM metrics are no longer registered by default in embedded mode, as that should be the job of the application and not the library.
Cache names are now included in metrics as tags as opposed to names, which should make querying and charting easier
Legacy metrics name prefixes (base and vendor) have been replaced with more appropriate library names.

All these can be reverted to their old configuration if needed, but trust us: the new defaults are better.

Release notes

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

Get them from our download page.

Infinispan 16.0 is out!

2025-11-10T01:00:00+01:00

"Keep Rollin'"

Infinispan 16.0 is here, and it is codenamed "Keep Rollin'".

This is a very significant release, as it introduces zero-downtime in-place rolling upgrades: the capability of incrementally upgrading individual nodes in a cluster without having to stop operations.

Final not .Final

Starting with this release, we will no longer be appending .Final to the version number. This release is therefore just 16.0.1. Why not 16.0.0 ? Don’t ask 😀.

In-place rolling upgrades

Starting with Infinispan 16.0, we guarantee that it will be possible to upgrade the nodes of a live Infinispan cluster to a newer version with zero downtime. This guarantee will initially cover point releases (16.0.x → 16.0.y), but we will strive to also maintain it across minor releases (16.x → 16.y): for every new release, we will be providing a table of supported upgrade paths to help you plan your upgrade strategies.

Clustering

The clustering messages, that Infinispan nodes use to communicate with each other, have been rewritten to use Protocol Buffers, via the ProtoStream serialization library. By adopting ProtoBuf’s best practices for schema evolution and a number of supporting tools, we can guarantee that incompatibilities cannot be introduced into these messages without breaking our builds and tests.

Upgrade test harness

We have implemented an extensive test harness, integrated into our CI pipelines, that validates that every change that is made to Infinispan does not break backwards compatibility. This harness exercises every command, supported by coverage reports that help us identify untested code paths.

Console

Since Infinispan 15.2, the console has used PatternFly 6 for its interface. With this major update, we also added new features for users starting from version 16.0.

Update at runtime cache configuration

We have allowed mutating some cache configuration attributes at runtime for a while, and, starting with this release, this can also be done from the Web Console.

A new menu option is now available for administrators:

The runtime properties that can be updated will be listed:

Rolling Upgrade detection

From version 16.0 onward, when a rolling upgrade is in progress, the Console will display a warning to inform users that the operation is underway.

Working behind a Reverse Proxy

Previously, the console URL could not be configured to work behind a reverse proxy. Starting with version 16.0, you can set up Infinispan and the console to run behind one, such as NGINX. The X-Forwarded-Prefix header is now supported by both Infinispan and the console to correctly serve the console and the REST API.

 location /infinispan/console/ {
            proxy_pass http://infinispan:11222/console/;
            proxy_set_header X-Forwarded-Prefix /infinispan;
}

See the Reverse Proxy Simple Tutorial in the Infinispan Simple Tutorials repository for more details.

Schemas Management Client API

Users can now manage ProtoStream Schemas with a dedicated administration API.

RemoteSchemasAdmin admin = remoteCacheManager.administration().schemas(); Optional = admin.get("schemaName");

See the Schemas Simple Tutorial in the Infinispan Simple Tutorials repository for more details.

Query

Refactoring

The various query modules have all been aggregated into the single infinispan-query JAR, greatly simplifying our dependency tree and paving the way for JPMS encapsulation.

Aggregations

Previously, only the count aggregation query could be executed in an indexed clustered query, providing excellent performance. Now, all other aggregation types (such as sum, avg, and others) work in the same way. This improvement comes from the new capabilities in Hibernate Search 8.1, which has been integrated into Infinispan’s internal engine.

Server

We have introduced several fixes and enhancements to the Infinispan Server.

Server container image

The Infinispan Server container image is now built using the bare minimum required components, aiming to provide a significantly reduced attack surface.

Server startup

We have decoupled the server and the cache container start procedure, where they can start concurrently. This provides a faster startup time for the server, that can start replying to requests earlier. This helps in scenarios where the server receive probe requests for liveness and readiness. Also, this allows for better handling when a cache may fail to start allowing other caches to continue operating.

On-demand caches

The caches associated with dedicated connectors, such as Memcached and RESP, do not create the caches at start. These caches are now created on demand at the first access. In case these endpoints are not accessed, the caches are never created.

Updated Lua engine

We are shipping an updated Lua 5.1 engine, for Redis scripting, that includes a number of CVE fixes that have not been applied to the upstream Lua repository. Also, a number of dangerous Lua scripting operations have been disabled. The security of your servers is of the highest priority to us.

JDK improvements

While Infinispan still requires at least JDK 17, we have made several changes to take advantage of the features introduced in newer JDKs, including support for the recently released JDK 25.

Virtual threads

Infinispan by default not utilized Virtual Threads in both Embedded and Server modes. This includes Infinispan enabling virtual threads in JGroups by default. Virtual threads are used by the non-blocking and blocking thread pools in Embedded mode and the blocking thread pool in Server mode. The latter utilizes Netty event loop for its non-blocking thread pool which does not yet support virtual threads.

If necessary is possible to disable by setting the org.infinispan.threads.virtual system property to false.

AOT

Infinispan Server (and the CLI) can leverage OpenJDK’s Ahead-of-Time features introduced in JEP 483 to decrease startup time and initial memory usage.

Fixes

Lots of these. However, should you find something that doesn’t work, head over to our issues and provide any details that help us debug and solve problems.

Deprecations and removals

The old Single File Store has now been completely replaced by the more scalable Soft-Index File Store and cannot be configured declaratively any longer.

Documentation

As usual, many improvements, updates and fixes.

What’s next?

Infinispan is adopting timeboxed releases starting with our next release (16.1). See our roadmap for information. We will soon be blogging more about it.

Release notes

You can look at the release notes to see what was changed since our last development build.

Get them from our download page.

Infinispan 15.2.0.Final

2025-03-27T01:00:00+01:00

"Feelin' Blue"

It’s new. It’s blue. It’s Infinispan 15.2, codenamed "Feelin' Blue".

Without further ado, here’s a list of what’s new (and I promise to stop with the Dr. Seuss rhyming):

RESP endpoint

JSON

Infinispan now implements the Redis JSON API.

Lua scripting

It is now possible to run Lua scripts. The big advantage is that this works in Infinispan clusters, without having to worry about key ownership.

Server

All endpoints limit the maximum request size, which defaults to 10MB. This protects your server from abuse. Use the max-content-length configuration attribute to change it to your liking.

Metrics

You can now disable exporting the base (JVM) metrics, which is desirable when running in embedded mode. Such metrics are usually exported by the application framework.

Console

The console sports a new look & feel, thanks to the upgrade to PatternFly 6.

Manage roles, users and access control for Principal Role Mappers from the console.

Fixes

Lots of these. However, should you find something that doesn’t work, head over to our issues and provide any details that help us debug and solve problems.

JDK requirements

Like the previous 15.x releases, you will need at least JDK 17 in order to use Infinispan 15.2. Infinispan also supports the recently released JDK 24.

Deprecations and removals

We are no longer building the native server, since it did not provide the same level of functionality and performance as our Java server. However, if you miss it, please let us know your use case, and we’ll look into bringing it back.

Documentation

Our documentation now includes * a complete list of our OpenMetrics and JMX metrics * a complete list of log messages As usual, many improvements, updates and fixes.

Release notes

You can look at the release notes to see what was changed since our last development build.

Get them from our download page.

Bilbostack Conference

2025-01-27T01:00:00+01:00

This weekend, I had the honor of speaking about In-Memory Databases at BilboStack in Bilbao, Spain. It was a special moment for me because Bilbao is my hometown, where I completed my Software Engineering studies 20 years ago. Public speaking is always a challenge, but presenting in my hometown came with the added pressure of not wanting to disappoint.

BilboStack is a 1000-attendees tech event featuring two tracks with four talks each in the morning, followed by networking sessions in the afternoon. This year marked its 13th edition. Here is a short video of the conference.

What did I talk about?

I spoke about In-Memory Databases. One of their main use cases is caching and session replication, so I explained the basics of distributed caching.

I covered:

Embedded caching with a library.
Embedded distributed caching, which works across multiple systems.
Using an in-memory database to keep applications stateless while managing caching through the database, making it easy to scale cpu or memory up or down.

I also highlighted use cases such as real-time statistics, fast operations, and implementing security and backups for cross-site deployments (spanning multiple data centers).

The talk was very well received, and I got great feedback. I kept the content general but also showcased how Infinispan, the open-source product I work on, fits these scenarios.

Demo and Slides

Demo and slides are available in this repository: GitHub - Bilbo Stack 2025.

Questions

I got many questions, but we did not have time to answer them during the session. Here are some of them, others will be answered in more detailed blog posts.

Can Infinispan be compared to Redis?

Yes, Infinispan is a competitor to Redis and can even act as a drop-in replacement. This allows you to continue using your existing applications and clients while switching to Infinispan. Tristan Tarrant’s video offers a detailed comparison: Redis vs Infinispan: Battle of the in-memory data stores.

Is "clear the cache" the new "restart your computer"?

It often feels that way! Caches—whether browser-based or tools like Varnish—can trick us into thinking something is broken when it’s not. Clearing the cache is often a quick fix.

Can in-memory databases work with other languages or visualization tools?

Absolutely! In-memory databases support multiple programming languages via clients or APIs. These databases (e.g., Infinispan, Redis, Couchbase) also integrate with popular visualization tools and frameworks.

On Vector Databases

Vector databases are growing in popularity for AI use cases, but in-memory databases like Infinispan have supported similar features for years. For example, Infinispan uses Hibernate Search and Lucene for full-text queries, and from Lucene 7.2, KNN/ANN searches, and vector indexing is supported too. This makes it easy to integrate with tools like LangChain without needing a separate vector database. For more details, see Clement Escoffier’s blog post on the Quarkus blog.

Final words

BilboStack was amazing! The conference, held in Bilbao, is all in Spanish and was very well organized. Everything ran smoothly, and the Basque culture made it extra special. There was great food, traditional dances, live music, and plenty of chances to meet people and connect.

It’s not just a tech event — it’s an experience. The talks aren’t filmed because what happens at BilboStack stays there. You really have to be there to enjoy it fully! A huge thank you to the organizers for treating us, as speakers, so incredibly well. The effort and care they put into making us feel welcome and valued are like nowhere else. It was an honor to be part of such a well-organized and thoughtful event. Thank you for everything!

See you soon Bilbao, and see you next year Bilbostack! Next time, in San Mamés!

Infinispan joins Commonhaus!

2025-01-13T01:00:00+01:00

We’re very excited to announce that Infinispan is joining the Commonhaus Foundation.

Why join a foundation?

We want to make it clear that Infinispan’s roadmap is independent of the company that has funded its development since day 1, and we welcome contributors to participate in what we think is a bright future for our project. In the same vein, we’ve also recently transitioned our issue tracking to a neutral platform.

Why Commonhaus?

Commonhaus just ticks all the right boxes for us: its lightweight governance is ideal. We get all the benefits of being part of an awesome foundation, with all the benefits of running the project on our own terms.

Commonhaus is also the home to a number of "friend projects": Hibernate, Quarkus, Debezium, Jackson all play a key role in our software and it’s great that we share a "common home".

Infinispan 15.1.0.Final

2024-12-16T01:00:00+01:00

"It Was All A Dream"

No, man. This time it’s for real!

Freshly brewed, for the fine connoisseurs of distributed caching, we are proud to present Infinispan 15.1, codenamed "It Was All A Dream"

Just like its beer namesake, this is a stout release, packed with flavor and features. Here’s a quick rundown of what’s new:

Query

Spatial queries

Infinispan now supports geographical queries. The feature allows users to perform queries based on geographical criteria. Spatial predicates can be used in combination with other predicates to implement additional filtering. Moreover, spatial fields can be used to project distances and to order the results according to distances from a given geographical point. You can define on the same entity one or more spatial fields. Each of them denotes a pair of geographical coordinates: latitude and longitude. Infinispan’s query language supports three spatial predicates: within circle, within polygon and within box. If we want to sort our results according to the distance from a given query point, we can use the order by distance clause. We can also project the distances from the same query point. Different units of measurement can be used to denote the radius of the circle predicate or to project the distances from a given query point. Read our recent blog post and the documentation for more information.

Nested entities joins

This contribution has been made by András Gyuró and Gabor Ori from our amazing Infinispan open source community. A big thanks to them! The feature allows to exploit the nested (not-flattened) relations between root entities and embedded entities in order to join their values to be queried. As an example, let’s suppose we have an entity Team having a nested embedded field named players. It is possible to execute a query which selects all the teams having at least one player having number 7 and at the same time having name Ryan or Will. A possible query in this case could be:

select t.name from model.Team t
join t.players p
where (p.name ='Ryan' AND p.number=7) or (p.name='Will' AND p.number=7)

Non-blocking query API

A new addition has been added to the Query API. Non-blocking/reactive alternative methods are available to query your data. Those methods are:

Publisher publish(int maxBatchSize);
CompletionStage> executeAsync();
CompletionStage executeStatementAsync();

The new methods are experimental, meaning they may change in the future, and only available for the Hot Rod client (remote query).

New Java Hot Rod client

A brand-new client implementation has been introduced replacing the current hotrod-client module. The public API is still the same so the code can be used without changes. The new client completely removes the prior connection pool, instead opting for a single pipelined channel to each server instead. The client configuration is thus ignored and deprecated.

Due to only having a single client connection to each server users should see a substantial decrease in file descriptors in use for both server and client applications. Also, the majority of usage should see performance gains with the new client. The opposite may occur in cases of a single server with extremely high concurrency usage on the client.

The new client has dropped support for HotRod protocols older than 3.0, which is from Infinispan 10. This was mostly done as some features in some versions of 2 require dedicated sockets which is not acceptable in the new client.

The streaming cache commands (InputStream and OutputStream-based) had to be reworked to support a single socket, and thus we had to add a new Hot Rod protocol 4.1 to support these commands. If you are using the new client you can only use these streaming commands if your server also supports 4.1 or newer.

If you find the need to use a Hot Rod protocol version older than 3.0 the prior client can be used by importing the hotrod-client-legacy module instead.

Console

Cache aliases

Index metamodel

Tracing

Cache aliases

Infinispan 15.0 had cache aliases that only worked within the context of the RESP connector. Now this functionality has been extended to all parts of Infinispan, including all other protocols as well as embedded.

Certificate reloading

SSL/TLS certificates have an expiration date, after which they will no longer be valid. The process of renewing a certificate is also known as rotation. Infinispan now monitors the keystore files for changes and automatically reloads them without requiring a server or client restart.

Note

to ensure seamless operations during certificate rotation, use certificates signed by a Certificate Authority and configure both server and client trust stores with the CA certificate. The use of self-signed certificates will cause temporary handshake failures until all clients and servers have been updated.

Time quantities in configuration

Wherever a time quantity, such as a timeout or an interval, is specified within a declarative configuration, it is possible to describe it using time units: * ms: milliseconds * s: seconds * m: minutes * h: hours * d: days

For example:

{ "distributed-cache": { "remote-timeout":  "35s"} }

Fixes

Too many to count. We want to thank our amazing community members for reporting issues and helping out with providing detailed information that helps us debug and solve problems.

Deprecations and removals

The main change is the removal of the old server templates (like org.infinispan.DIST_SYNC) which were redundant and didn’t provide any advantage to defining configurations.

JDK requirements

Like for 15.0, you will need at least JDK 17 in order to use Infinispan 15.1. Infinispan also supports JDK 21 and the recently released JDK 23.

Documentation

As usual, many improvements, updates and fixes.

Release notes

You can look at the release notes to see what was changed since our last development build.

Get them from our download page.

Issue tracking migration from Jira to GitHub

2024-11-29T01:00:00+01:00

Infinispan issue tracking is now on GitHub issues.

We have decided to do this in order to make it easier for the community to report issues and for developers to cross-reference them in pull requests, release notes and discussions. GitHub issues offer a streamlined interface for reporting bugs and requesting features.

We have archived the Infinispan and ProtoStream Jira projects and have decided not to bulk import all open issues into GitHub, as the backlog had accumulated a lot of stuff. If you had a bug report or feature request on Jira you’d like to see fixed/implemented please report it again on GitHub, referencing the original via a link.

We hope this improvement makes it easier for everybody.