You can also see the Release Notes document at https://docs.hazelcast.org/docs/rn/.

Release 4.2

(See https://docs.hazelcast.org/docs/rn/#bc-42 for Breaking Changes in IMDG 4.2)

- Added support of SQL sorting feature. 
- Added support of partition grouping mechanism in the Hazelcast discovery plugin for Kubernetes (NODE_AWARE partition grouping).
- Added support of partition grouping mechanism in the Hazelcast discovery plugin for AWS (PLACEMENT_AWARE partition grouping.
- Added support of changing Hazelcast log levels without restarting cluster members.
- Introduced a configuration option (`per-entry-stats-enabled`) for retrieving per-entry statistics of a map, which is disabled by default.
- Added the ability to override Hazelcast's built-in serializers.
- Added the serialization support of `java.util.Optional`.

Release 4.1

(See https://docs.hazelcast.org/docs/rn/#bc-41 for Breaking Changes in IMDG 4.1)

- Implemented the SQL engine that supports map scans, index scans, projections and filters.
- Introduced the automatic detection of the cloud environment where Hazelcast IMDG is running on (Kubernetes, AWS, GCP or Azure).
- Enabled overriding the configuration entries of your cluster without changing the declarative configuration files (XML/YAML).
- Hazelcast now writes a file on a Hazelcast member startup at the configured location. This file contains metadata about the member such as version, product name and process ID, and it is not deleted on the member shutdown.
- Introduced security audit logging which allows observing some important cluster events.
- Introduced properties to be configured to detect and resolve the partial network issues among the Hazelcast IMDG members.
- Parallelized the partition replica migrations so that the time needed for rebalancing the partitions after adding or removing a member to/from a cluster is reduced.
- Added membership and group availability listeners for CP Subsystem. Also, added support for publishing CP Subsystem and CP data structure statistics via Metrics. - Added support for accessing domain objects without domain classes (GenericRecord).
- Introduced the CPU thread affinity; threads can have affinity for particular CPUs and using this you have a better control on the latency and a better throughput.
- Introduced the restriction of the source IP addresses from which the Management Center operations are allowed.
- Added support for the queues with comparators (Priority Queue).
- Added statistics for scheduled and durable executor services, and for the executor of offloaded entry processors to be monitored by Management Center.
- Introduced support for Kerberos authentication protocol which is one of the standard solutions for single-sign-on.
- Added support for multiple mounting directories in the persistent memory configuration and also thread affinity for NVMs (Non-Volatile Main Memories).
- Introduced the WAN throttling mechanism; this prevents the WAN consumers from getting overloaded by the WAN producers if transferring the WAN events takes less time than processing them in the target cluster.

Release 4.0

(See https://docs.hazelcast.org/docs/rn/#bc-40 for Breaking Changes in IMDG 4.0)

- Added support for persistent memory, such as Intel® Optane™ DC, to be used by Hazelcast’s High-Density Memory Store feature.
- Provided a framework and implementation to encrypt data in Hot Restart stores ("at rest") for data held in distributed structures.
- Added support for credential retrieval by the members from the X.509 certificates configured on the clients.
- Added support of out-of-the-box LDAP Configuration.
- Implemented persistency for Hazelcast CP subsystem.
- Introduced CP Subsystem development mode, i.e., UNSAFE mode for the CP data structures.
- Introduced bitmap indexes to significantly lower index memory usage for low-cardinality columns.
- Separated WAN Publisher configuration into two configuration elements: batch-publisher and custom-publisher.
- Management Center, logs and diagnostics now report the progress of a WAN synchronization.
- Introduced improvements in the JAAS Authentication Mechanism and Security configurations.
- cluster.sh and healthcheck.sh scripts now use HTTPS.
- Introduced the EntryStore and EntryLoader interfaces (adding custom expiration support for MapStore).
- Introduced friendly names (Moby naming) for the Hazelcast instances to be shown in the Hazelcast Management Center. 
- Improved the client performance by eliminating the sync backup wait from the client and sending the backup ACK to the client.
- Introduced the ownerless client mechanism.
- Optimized the client performace for the single thread sending requests.
- Added JSON support (HazelcastJsonValue) for REST API.


Release 3.12

- Support for JDK 6 and 7 has been dropped. The minimum Java version that Hazelcast supports now is Java 8.
- Introduced the new CP Subsystem which offers linearizable implementations of Hazelcast's concurrency APIs.
- Added support for multiple endpoints when configuring member’s networking.
- Added the new Blue-Green and Disaster Recovery for Java Clients feature.
- Added the support for querying JSON strings.
- Introduced pipelining mechanism using which you can send multiple requests in parallel to Hazelcast members or clients, and read the responses in a single step.
- Introduced REST Endpoint Groups.
- Introduced the ability to share the Hot Restart `base-dir` among multiple members.
- Redesigned WAN Replication for more lower latencies and higher throughput.
- Added the support for adding/removing WAN publishers in a running cluster.
- Added the ability to automatically remove the stale Hot Restart data.
- Introduced a mechanism which allows to choose whether a new member joining to a cluster will apply the client permissions stored in its own configuration, or will use the ones defined in the cluster.
- Introduced the ability to automatically change the cluster version after a rolling upgrade.
- Added the ability to retrieve the names of client instances on the member side.
- Introduced client attributes.
- Added support for configuration in YAML.
- Introduced composite indexes.
- Deprecated the original `ILock`, `IAtomicLong`, `IAtomicReference`, `ISemaphore` and `ICountDownLatch` implementations and introduced their implementations provided by CP Subsystem.


Release 3.11

- Added fine-grained control over WAN replication events by Introducing the new event type LOADED and the class EntryLoadedListener.
- Introduced a license monitor daemon that warns about license expirations and instructs about the next steps.
- Introduced Delta WAN Synchronization which uses Merkle trees.
- Added ability to set custom TTL for map and cache entries.
- Added ability to set custom maximum idle timeouts for map entries.
- Introduced configurable backoff strategy for client reconnections.
- Introduced map index statistics.
- Improved JCache's lazy eviction with a periodic cleanup that eventually removes all expired entries and frees up the occupied space.
- Enhanced network I/O to allow TLS handshake in a block-free manner and to support offloadable tasks, improving the latency and security.
- Added support for discovery in GCP Compute Engine environment.
- Deprecated:
  - The data structure IdGenerator is deprecated. Use Flake ID Generator.
  - Following system properties are removed: 
    - hazelcast.master.confirmation.interval.seconds 
    - hazelcast.max.no.master.confirmation.seconds 
    - hazelcast.mc.max.visible.instance.count

Release 3.10

- Split-Brain Healing for Hazelcast Data Structures with High-Density (HD) Memory Store.
- Multiple Users/Roles in a Single Security Mapping.
- Extended Split-Brain Protection.
- Shorter Split-Brain Detection Window.
- Extended Merge Policies.
- Introduced Flake ID Generator.
- Deprecated ID Generator.
- Introduced PN Counter.
- More consistency on findXConfig methods.
- Enabled Health Check on F5 BIG-IP LTM.
- Deprecated:
  - hazelcast.master.confirmation.interval.seconds
  - hazelcast.max.no.master.confirmation.seconds
  - hazelcast.mc.max.visible.instance.count

Release 3.9

- WAN Replication using Discovery SPI.
- Dynamic Creation of Distributed Objects Configuration.
- Client Support for User Code Deployment.
- Client Statistics in Management Center.
- OpenSSL Integration.
- Event Journal
- Fine-Grained Anti-Entropy Mechanism.
- Offloadable and Readonly entry processors.
- Gigantic Cache Migration Enhancements: It enables manual control on the partition migrations.
- Keeping JCache Implementation Updated.
- Storing Near Cache Keys by Reference.
- Client Connection Strategy Enhancements: Allows lazy initiation for Hazelcast Clients.
- Default Group Password and Symmetric Encryption Default Credentials Policy.
- Hazelcast Consistency Model Documentation.


Release 3.8

- Introduced rolling member upgrades for minor releases (Hazelcast IMDG Enterprise).
- Added the capability of restoring Hot Restart data in a different cluster (Hazelcast IMDG Enterprise).
- Continuous Query Cache is now open source.
- Introduced Cardinality Estimator data structure.
- Introduced distributed implementation of Scheduled Executor Service.
- Introduced User Code Deployment enabling you to load your new classes to Hazelcast IMDG members dynamically without restarting all of them.
- Introduced fast aggregations and projections for queries.
- Improved Near Cache so that it is eventually consistent; possible losses of invalidation events are detected and stale reads are prevented.
- Added cluster split-brain protection for Queue and Lock.
- Unified Near Cache implementation.
- Introduced a preloader to improve the performance of near caches.
- Implemented Ringbuffer with persistent datastore.
- Introduced Hazelcast Striim Hot Cache Adapter.
- Implemented one-off WAN synchronization with dynamically added endpoint (Hazelcast IMDG Enterprise) allowing to copy the maps' all content to a target cluster dynamically in runtime.
- Improved Hot Restart usability (Hazelcast IMDG Enterprise).
- Added partial start capability for Hot Restart (Hazelcast IMDG Enterprise).
- Added the capability of copying Hot Restart Store data from Source to Target (Hazelcast IMDG Enterprise).
- Improved WAN queue full behavior.
- Added client support for distributed scheduled executor service.
- Bug fixes.


Release 3.7

- Added the capability of custom eviction policies.
- Implemented Discovery SPI for Microsoft Azure Services.
- Added Hazelcast CLI with scripting feature.
- Now, Hazelcast members on OpenShift and CloudFoundry can discover each other.
- Introduced Apache Spark Connector which allows Hazelcast maps and caches to be used as shared RDD caches by Spark.
- Added alignment of WAN Replication Clusters feature providing a mechanism to align or realign distributed objects in the clusters connected through WAN.
- Introduced fault tolerant executor service.
- Introduced modularized Hazelcast. Clients, languages and plugins are now modules which have separate GitHub repositories, Maven modules, and release cycles.
- Enhanced Near Cache (for JCache) notifications.
- Enhanced migration algorithm.
- Integrated WAN Replication with Solace.
- Added Cloud Discovery SPI plugin for Multicast.
- Synced IMap eviction algorithm with that of JCache.
- Enhanced Hazelcast Docker image.
- Enhanced the data collected by phone home..
- Improved the performance of IMap.putAll().
- Enhanced the integration of Hazelcast Instance and JCache.
- Now, entry processor can use indexing when a predicate is used to filter entries that need to be processed.
- Improved partition grouping.
- Now the read operations are blocked only during committing the transactions.
- Jetty and Tomcat based web session replications are now open source.
- Enabled collection querying in Portables.
- The path for performance logs is now configurable.
- Added support for Spring's Transaction API.
- Added support for Hibernate 5.
- Bug fixes.


Release 3.6

- Introduced High-Density Memory Store feature for Hazelcast Map.
- Added Discovery Service Provider Interface (Discovery SPI) to discover Hazelcast instances on cloud environments.
- Introduced a new open binary client protocol.
- Added client cross version compatibility so that you can upgrade your Hazelcast clients independently from servers and other clients.
- Added the support for cloud providers through jclouds®.
- Added Hot Restart Persistence feature providing fast restarting of the Hazelcast clusters.
- Introduced Ringbuffer and Reliable Topic structures  in Hazelcast Clients.
- Added cluster quorum for Hazelcast JCache implementation.
- Added split-brain syndrome handler for Hazelcast JCache implementation.
- Added partition lost listener for Hazelcast JCache implementation.
- Now you can run Hazelcast using its image in the Docker platform.
- Re-introduced lite members that can mostly be used for your task executions and listener registrations (no data storage).
- Introduced querying in collections and arrays.
- It is now possible to extract a value of an object's attribute using a custom extractor class.
- Now, you can try to acquire locks with a lease time.
- Added monitoring capability for WAN replications.
- Improved Hazelcast replicated map implementation, paging predicates, rule based query optimizations, WAN replication, and Hazelcast's OSGI support.
- Removed approximate max-size calculation for IMap eviction.
- Now, SpringAwareWebFilter has a constructor which takes properties as arguments.
- OSGI Manifest Spring package imports are now optional.
- Bug fixes.


Release 3.5

- Back Pressure feature now supports async operations.
- Added importing feature for Hazelcast (clients) declarative configuration.
- Added the support for replacing variables with system properties in the declarative configuration of Hazelcast client.
- Added cluster quorum feature which enables you to define the minimum number of machines required in a cluster for the cluster to remain in an operational state.
- Added Hazelcast client protocol introducing the support for different versions of clients in a cluster.
- Added listener for lost partitions.
- Increased the visibility of slow operations with the introduction of the SlowOperationDetector feature.
- Added Hazelcast Enterprise implementation of the WAN Replication.
- Added sub-listener interfaces for map listener enabling you to listen to map-wide or entry-based events.
- Implemented scalable map loader enabling you to load the keys incrementally if the number of keys is large.
- Added Near Cache feature for Hazelcast JCache implementation.
- Added fail fast feature on invalid configuration.
- Added Continuous Query Caching feature.
- Improved eventing system by introducing RingBuffer and Reliable Topic structures.
- Improved XA transactions so that you can now obtain a Hazelcast XA Resource instance through HazelcastInstance.
- Improved Query and Indexing.
- Added iam-role support to Hazelcast Cloud module.
- Bug fixes.


Release 3.4

- Introduced High-Density Memory Store feature.
- Added Jetty based web sessions clustering functionality.
- Added importing feature for Hazelcast (members) declarative configuration.
- Added Back Pressure feature which prevents the overload caused by pending asynchronous backups.
- Event packets sent to the client now has "partitionId".
- Added Spring configuration for replicated map.
- Timeout for SocketConnector now can be configured.
- The method MultiMap.get() now returns the correct collection type (Set or List).
- Implemented the support for Log4j 2.x.
- Management Center now informs when the cluster is safe and all backups are up to date.

Release 3.3

- Added heartbeat feature for Java client.
- Added Tomcat 6 and 7 based web sessions clustering functionality.
- Implemented replicated map.
- Improved WAN replication by adding configurable replication queue size.
- Implemented data aggregations.
- Added evictAll and loadAll features for IMap.
- Introduced Hazelcast JCache implementation.
- Bug fixes.


Release 3.2

- Introduced a new architecture based on NIO to support more scalable and concurrent client usage.
- Added MapReduce framework.
- Added Order/Limit support so that can order and limit results returned by queries performed on Hazelcast Distributed Map.
- Added native C++ Client.
- Added native C# Client.
- Added InitialLoadMode configuration parameter (having Lazy and Eager as values) to MapStoreConfig.
- Introduced tagging support for Executor Service.
- Introduced getForUpdate() operation for transactional map.
- Introduced getNearCacheStats().
- Bug fixes.

Release 3.1

- Added Elastic Memory (Enterprise Edition Only).
- Added Hazelcast Security framework.
- Added Hazelcast JCA integration back.
- Added Controlled Partitioning functionality.
- TransactionalMap now supports keySet(), keySet(predicate), values() and values(predicate) methods.
- Eviction based on USED_HEAP_PERCENTAGE or USED_HEAP_SIZE now takes account real heap memory size consumed by map.
- SqlPredicate now supports '\' as escape character and regular expressions using REGEX keyword.
- Hazelcast queue now supports QueueStoreFactory that will be used to create custom QueueStores for persistent queues.
- TransactionalQueue now supports peek() and peek(timeout, timeunit) methods.
- Added SSL support for client.
- Added the support for custom socket implementations using SocketFactory API for client.
- Hazelcast IList and ISet now have their own configurations.
- Added HazelcastInstance.shutdown() method back.
- Improved OSGI compatibility.
- Bug fixes.



Release 3.0.3

- Added multi-thread execution.
- Introduced SPI (Service Programming Interface) to develop new partitioned services, data structures.
- Added IdentifiedDataSerializable.
- Added Portable Serialization.
- Added Custom Serialization that can be plugged into Hazelcast.
- Added the support for executing an EntryProcessor on the key or on all entries.
- Added the support for storing entries in Binary, Object and Cached format.
- Added the listener with predicates functionality.
- Added interceptors.
- Added lazy indexing functionality.
- Queue: No more dependency on the distributed map. Scales really well as you have thousands of separate queues. Persistence Support with QueueStore.
- Multimap: Values can be Set/List/Queue.
- For Topic, added the support for global ordering where all members receive all messages in the same order.
- Added Distributed Transactions with a totally new API.
- Added a new binary protocol based on portable serialization.
- Bug fixes.

Release 2.6

- Fixed issues with Spring configuration and merge policies.
- Hazelcast source archives in Maven central repository now contains the class files.
- Fixed formatting problems when using SQL predicates with date.
- Fixed the issues of Near Cache functionality for Java client.
- Improved the Memcache client content in the Reference Manual.


Release 2.5

- Added Near Cache support for Java Client.
- Management Center alert system can now receive alerts based on custom filters.
- Management Center has now better support for Hazelcast cluster running in OSGI environment.
- Nodes can be easily shutdown or restarted using Management Center interface.
- Bug fixes.

Release 2.4

- Added Hibernate 2nd level cache local/invalidation mode.
- Added quick clear feature for maps.
- Client threads does not have fixed size anymore.
- Added ability to restrict outbound ports.
- Bug fixes.

Release 2.3

- Changed hazelcast.max.operation.timeout unit from seconds to milliseconds.
- Added hazelcast.max.concurrent.operation.limit property.
- Added hazelcast.backup.redo.enabled property.
- Added MultiMap and Distributed ExecutorService statistics to Management Center application.
- MigrationListener now receives failed migration events.
- ItemEvent now returns the Member firing that event.
- Improved out of memory (OOM) error detection and handling.
- Fixed some issues related to domain name handling and networking/join.
- During cluster merge after a network split-brain, merging side will now fire MERGING and MERGED before and after RESTARTING and RESTARTED LifecycleEvents.
- Bug fixes.

Release 2.2

- Improved redo logs and added maximum call/operation timeout.
- Improved domain name handling.
- Added Cluster Health Check to Management Center application.
- Introduced distributed backups.
- Parallel IO: You can have more IO threads, if you have good number of CPU/cores and high-throughput network.
- More tolerance to connection failures.
- Listeners such as migration, membership and map indexes can be added with configuration.
- Added new event objects.
- Introduced ClientConfig API.
- SSL communication support among cluster nodes.
- Distributed MultiMap value collection can be either List or Set.
- SuperClient is renamed to LiteMember.
- Implemented new IMap.set(key, value, ttl, TimeUnit).
- Added forceUnlock to unlock the locked entry from any member and any thread regardless of the owner.
- Added enum type query support
- Added support for IPv6 addresses.
- Added async backup support.
- Hazelcast now can be used as Spring Cache provider.
- Added Spring dependency injection support.
- Added persistence support with Spring-Data MongoDB and JPA integration.
- Member.getUuid() now will return UUID for node.
- Improved session clustering configuration.
- Bug fixes.


Release 1.9.4.9

- Added WAN Replication (synchronization of separate active clusters).
- Added Data Affinity (co-location of related entries) feature.
- Added EC2 Auto Discovery for your Hazelcast cluster running on Amazon EC2 platform.
- Implemented Distributed CountDownLatch.
- Implemented Distributed Semaphore implementation.
- Hazelcast distribution now contains HTML and PDF documentation besides Javadoc.
- Better TCP/IP and multicast join support. Handling more edge cases like multiple nodes starting at the same time.
- Memcache protocol: Better integration between Java and Memcache clients. Put from memcache, get from Java client.
- Monitoring Tool is removed from the project.
- Re-implementation of distributed queue:
- Configurable backup count and synchronous backup.
- Persistence support based on backing MapStore.
- Auto-recovery from backing MapStore on startup.
- Re-implementation of distributed list supporting index based operations.
- Optimized IMap.putAll for much faster bulk writes.
- Added IMap.getAll for bulk reads which is calling MapLoader.loadAll if necessary.
- Added IMap.tryLockAndGet and IMap.putAndUnlock methods.
- Added IMap.putTransient API for storing only in-memory.
- Added IMap.addLocalEntryListener() for listening locally owned entry events.
- Added IMap.flush() for flushing the dirty entries into MapStore.
- Added MapLoader.getAllKeys API for auto-pre-populating the map when cluster starts.
- Support for minimum initial cluster size to enable equally partitioned start.
- Introduced graceful shutdown.
- Faster dead-member detection.
- Memcache interface support. Memcache clients written in any language can access Hazelcast cluster.
- RESTful access support, e.g. http://:5701/hazelcast/rest/maps/mymap/key1.
- Added split-brain (network partitioning) handling.
- Added LifecycleService API to restart, pause Hazelcast instances and listen for the lifecycle events.
- Added asynchronous put and get support for IMap via IMap.asyncPut() and IMap.asyncGet().
- Added AtomicNumber API; distributed implementation of java.util.concurrent.atomic.AtomicLong.
- Significant performance gain for multi-core servers. Higher CPU utilization and lower latency.
- Reduced the cost of map entries by 50 percent.
- Better thread management. No more idle threads.
- Added queue statistics API and the queue statistics panel on the Monitoring Tool.
- Monitoring Tool enhancements. More responsive and robust.
- Hazelcast distribution now contains hazelcast-all-<version>.jar to simplify the JAR dependency.
- Sorted index optimization for map queries.
- Added Hazelcast Cluster Monitoring Tool.
- Added Partition API. Partition and key owner, migration listeners.
- Added IMap.lockMap() method.
- Added Multicast and TCP/IP join feature. Try multicast first, if not found, try TCP/IP.
- Added Hazelcast.getExecutorService(name) API. You can have separate named executor services. Do not let your big tasks blocking your small ones.
- Added Logging API. Build your own logging. or simply use Log4j or get logs as LogEvents.
- Added MapStatistics API. Get statistics for your Map operations and entries.
- Hazelcast client now automatically updates the member list. There is no need to pass the list to all members.
- Added the ability to start the cluster members evenly partitioned. Hence, no migration.
- Added Java clients for accessing the cluster remotely.
- Added Distributed Query for maps. Both Criteria API and SQL are supported.
- Added Near Cache feature for distributed maps.
- Added TTL (time-to-live) property for each individual map entry.
- Improved the put operation: IMap.put(key,value, ttl, timeunit).
- Introduced the method IMap.putIfAbsent(key,value, ttl, timeunit).
- Now, you can have multiple Hazelcast members on the same JVM. Introduced HazelcastInstance API.
- Better API based configuration support.
- Smoother data migration enabling better response times during joins.
- Persistence via Loader/Store interface for distributed map.
- Added Socket level encryption feature. Both symmetric and asymmetric encryption are supported.
- Added support for JMX.
- Added support for Hibernate second level cache provider.
- Added instance events for getting notified when a data structure instance (map, queue, topic, etc.) is created or destroyed.
- Added eviction listener: EntryListener.entryEvicted(EntryEvent).
- Hazelcast is now fully "maven"ized.
- Added support for synchronous backups and configurable backup-count for maps.
- Added eviction support: Timed eviction for queues. LRU, LFU and time based eviction for maps.
- Added support for statistics/history for entries: create/update time, number of hits, cost.
- Implemented MultiMap structure. Similar to google-collections and apache-common-collections, but distributed and thread-safe.
- Now, you can destroy() the data structures when not needed anymore.
- Now, you can shutdown the local member using Hazelcast.shutdown().
- Now, you can get the list of all data structure instances via Hazelcast.getInstances().
- Full implementation of java.util.concurrent.BlockingQueue. Now, queues can have configurable capacity limits.
- Introduced Super Clients (a.k.a LiteMember): Members with no storage. If -Dhazelcast.super.client=true JVM parameter is set, that JVM will join the cluster as a 'super client' which will not be a 'data partition' (no data on that node) but will have super fast access to the cluster just like any regular member does.
- Added HTTP Session sharing support for Hazelcast Web Manager. Different web applications can share the same sessions.
- Added the ability to separate clusters by creating groups.
- Added java.util.logging support.
- Added the support for adding, removing and updating events for queue, map, set and list data structures.
- Introduced Distributed Topic for pub/sub messaging.
- Added integration with J2EE transactions via JCA complaint resource adapter.
- Added ExecutionCallback interface for distributed tasks.
- Introduced cluster-wide unique ID generator.
- Implemented Transactional Distributed Queue, Map, Set and List.
- Implemented Distributed Executor Service.
- Added support for multi member executions.
- Implemented key based execution routing.
- Added task cancellation support.
- Implemented Session Clustering with Hazelcast Webapp Manager.
- Added full TCP/IP clustering support.
- Introduced distributed implementation of java.util.{Queue,Map,Set,List}.
- Introduced distributed implementation of java.util.concurrency.Lock.
- Added support for retrieving cluster membership events.
- 1000+ commits 100+ bug fixes and several other enhancements.
