Awesome java Page

Awesome Java

Return to Java, Awesome JVM, Awesome Python, Awesome Java DevOps, Java Bibliography, Java DevOps, Java DevOps Bibliography, and Awesome lists

A curated list of awesome Java frameworks, Java libraries and Java software.

* Bean Mapping: Java Bean Mapping
* Build: Java build
* Bytecode Manipulation: Java bytecode manipulation
* Caching: Java caching
* CLI: Java cli
* Cluster Management: Java cluster management
* Code Analysis: Java code analysis
* Code Coverage: Java code coverage
* Code Generators: Java code generators
* Compiler compiler: Java compiler compiler
* Computer Vision: Java computer vision
* Configuration: Java configuration
* Constraint Satisfaction Problem Solver: Java constraint satisfaction problem solver
* CSV: Java csv
* Data Structures: Java data structures
* Database: Java database
* Date and Time: Java date and time
* Dependency Injection: Java dependency injection
* Development: Java development
* Distributed Applications: Java distributed applications
* Distributed Transactions: Java distributed transactions
* Distribution: Java distribution
* Document Processing: Java document processing
* Financial: Java financial
* Formal Verification: Java formal verification
* Functional Programming: Java functional programming
* Game Development: Java game development
* Geospatial: Java geospatial
* GUI: Java gui
* High Performance: Java high performance
* HTTP Clients: Java http clients
* Hypermedia Types: Java hypermedia types
* IDE: Java ide
* Imagery: Java imagery
* Introspection: Java introspection
* Job Scheduling: Java job scheduling
* JSON: Java json
* JVM and JDK: Java jvm and jdk
* Logging: Java logging
* Machine Learning: Java machine learning
* Messaging: Java messaging
* Microservice: Java microservice
* Miscellaneous: Java miscellaneous
* Mobile Development: Java mobile development
* Monitoring: Java monitoring
* Native: Java native
* Natural Language Processing: Java natural language processing
* Networking: Java networking
* ORM: Java orm
* PaaS: Java paas
* PDF: Java pdf
* Performance analysis: Java performance analysis
* Platform: Java platform
* Processes: Java processes
* Reactive libraries: Java reactive libraries
* REST Frameworks: Java rest frameworks
* Science: Java science
* Search: Java search
* Security: Java security
* Serialization: Java serialization
* Server: Java server
* Template Engine: Java template engine
* Testing: Java testing
* Utility: Java utility
* Version Managers: Java version managers
* Web Crawling: Java web crawling
* Web Frameworks: Java web frameworks
* Workflow Orchestration Engines: Java workflow orchestration engines
* Resources: Java resources
* Related Awesome Lists: Java awesome lists
* Communities: Java communities
* Frontends: Java frontends
* Influential Books: Java influential books
* Podcasts and Screencasts: Java podcasts and screencasts
* People: Java people
* Websites: Java websites

Bean Mapping

Java Bean Mapping - Java Frameworks that ease Java bean mapping

* dOOv - (https://github.com/doov-io/doov) - Provides fluent API for typesafe domain model validation and mapping. It uses annotations, code generation and a type safe DSL to make bean validation and mapping fast and easy.
* JMapper - (https://github.com/jmapper-framework/jmapper-core) - Uses byte code manipulation for lightning-fast mapping. Supports annotations and API or XML configuration.
* MapStruct - (https://github.com/mapstruct/mapstruct) - Code generator that simplifies mappings between different bean types, based on a convention-over-configuration approach.
* ModelMapper - (https://github.com/modelmapper/modelmapper) - Intelligent object mapping library that automatically maps objects to each other.
* Orika - (https://github.com/orika-mapper/orika) - JavaBean-mapping framework that recursively copies (among other capabilities) data from one object to another.
* reMap - (https://github.com/remondis-it/remap) - Lambda and method handle-based mapping which requires code and not annotations if objects have different names.
* Selma - (https://github.com/xebia-france/selma) - Annotation processor-based bean mapper.

Build

Java Build - Java Tools that handle the build cycle and dependencies of an application

* Apache Maven - (https://maven.apache.org) - Declarative build and dependency management that favors convention over configuration. It might be preferable to Apache Ant, which uses a rather procedural approach and can be difficult to maintain.
* Bazel - (https://bazel.build) - Tool from Google that builds code quickly and reliably.
* Buck - (https://github.com/facebook/buck) - Encourages the creation of small, reusable modules consisting of code and resources.
* Gradle - (https://gradle.org) - Incremental builds programmed via Groovy instead of declaring XML. Works well with Maven's dependency management.

Bytecode Manipulation

Java Bytecode Manipulation - Java Libraries to manipulate bytecode programmatically

* ASM - (https://asm.ow2.io) - All-purpose, low-level bytecode manipulation and analysis.
* Byte Buddy - (https://bytebuddy.net) - Further simplifies bytecode generation with a fluent API.
* bytecode-viewer - (https://github.com/Konloch/bytecode-viewer) - Java 8 Jar & Android APK reverse engineering suite. (GPL-3.0-only)
* Byteman - (https://byteman.jboss.org) - Manipulate bytecode at runtime via DSL (rules); mainly for testing/troubleshooting. (LGPL-2.1-or-later)
* cglib - (https://github.com/cglib/cglib) - Bytecode generation library.
* Javassist - (https://github.com/jboss-javassist/javassist) - Tries to simplify bytecode editing.
* Mixin - (https://github.com/SpongePowered/Mixin) - Manipulate bytecode at runtime using real Java code.
* Perses - (https://github.com/nicolasmanic/perses) - Dynamically injects failure/latency at the bytecode level according to principles of chaos engineering.

Caching

Java Caching - Java Libraries that provide caching facilities

* cache2k - (https://cache2k.org) - In-memory high performance caching library.
* Caffeine - (https://github.com/ben-manes/caffeine) - High-performance, near-optimal caching library.
* Ehcache - (http://www.ehcache.org) - Distributed general-purpose cache.
* Infinispan - (https://infinispan.org) - Highly concurrent key/value datastore used for caching.

CLI

Java CLI - Java Libraries for everything related to the CLI

* ASCII Table - (https://github.com/vdmeer/asciitable) - Library to draw tables in ASCII.
* Airline - (https://github.com/airlift/airline) - Annotation-based framework for parsing Git-like command-line arguments.
* args4j - (http://args4j.kohsuke.org) - Small library to parse command-line arguments.
* Jansi - (https://github.com/fusesource/jansi) - ANSI escape codes to format console output.
* Java ASCII Render - (https://github.com/indvd00m/java-ascii-render) - Graphical primitives for the console.
* JCommander - (http://jcommander.org) - Command-line argument-parsing framework with custom types and validation via implementing interfaces.
* jbock - (https://github.com/jbock-java/jbock) - Reflectionless command line parser.
* Jexer - (https://gitlab.com/klamonte/jexer) - Advanced console (and Swing) text user interface (TUI) library, with mouse-draggable windows, built-in terminal window manager, and sixel image support. Looks like [Turbo Vision]] - (https://en.wikipedia.org/wiki/Turbo_Vision).
* JLine - (https://github.com/jline/jline3) - Includes features from modern shells like completion or history.
* JOpt Simple - (https://jopt-simple.github.io/jopt-simple) - Fluent parser that uses the POSIX#getopt and GNU#getopt_long syntaxes.
* picocli - (https://picocli.info) - ANSI colors and styles in usage help with annotation-based POSIX/GNU/any syntax, subcommands, strong typing for both options and positional args.
* Text-IO - (https://github.com/beryx/text-io) - Aids the creation of full console-based applications.
* Lanterna - (https://github.com/mabe02/lanterna) - Easy console text-GUI library, similar to curses. (LGPL-3.0-only)

Cluster Management

Java Cluster Management - Java Frameworks that can dynamically manage applications inside of a cluster

* Apache Aurora - (https://aurora.apache.org) - Mesos framework for long-running services and cron jobs.
* Singularity - (http://getsingularity.com) - Mesos framework that makes deployment and operations easy. It supports web services, background workers, scheduled jobs, and one-off tasks.

Code Analysis

Java Code Analysis - Java Tools that provide metrics and quality measurements

* Checkstyle - (https://github.com/checkstyle/checkstyle) - Static analysis of coding conventions and standards. (LGPL-2.1-or-later)
* Error Prone - (https://github.com/google/error-prone) - Catches common programming mistakes as compile-time errors.
* Infer - (https://github.com/facebook/infer) - Modern static analysis tool for verifying the correctness of code.
* jQAssistant - (https://jqassistant.org) - Static code analysis with Neo4J-based query language. (GPL-3.0-only)
* NullAway - (https://github.com/uber/NullAway) - Eliminates NullPointerExceptions with low build-time overhead.
* PMD - (https://github.com/pmd/pmd) - Source code analysis for finding bad coding practices.
* SonarJava - (https://github.com/SonarSource/sonar-java) - Static analyzer for SonarQube & SonarLint. (LGPL-3.0-only)
* Spoon - (https://github.com/INRIA/spoon) - Library for analyzing and transforming Java source code.
* Spotbugs - (https://github.com/spotbugs/spotbugs) - Static analysis of bytecode to find potential bugs. (LGPL-2.1-only)

Code Coverage

Java Code Coverage - Java Frameworks and tools that enable code coverage metrics collection for test suites

* Clover - (https://www.atlassian.com/software/clover) - Relies on source-code instrumentation instead of bytecode instrumentation.
* Cobertura - (https://cobertura.github.io/cobertura) - Relies on offline (or static) bytecode instrumentation and class loading to collect code coverage metrics. (GPL-2.0-only)
* JaCoCo - (https://www.eclemma.org/jacoco) - Framework that enables collection of code coverage metrics, using both offline and runtime bytecode instrumentation.

Code Generators

Java Code Generators - Java Tools that generate patterns for repetitive code in order to reduce verbosity and error-proneness

* ADT4J - (https://github.com/sviperll/adt4j) - JSR-269 code generator for algebraic data types.
* Auto - (https://github.com/google/auto) - Generates factory, service, and value classes.
* Bootify - (https://bootify.io) - Browser-based Spring Boot app generation with JPA model and REST API.
* FreeBuilder - (https://github.com/inferred/FreeBuilder) - Automatically generates the Builder pattern.
* Geci - (https://github.com/verhas/javageci) - Discovers files that need generated code, updates automatically and writes to the source with a convenient API.
* Immutables - (https://immutables.github.io) - Annotation processors to generate simple, safe and consistent value objects.
* JavaPoet - (https://github.com/square/javapoet) - API to generate source files.
* JHipster - (https://github.com/jhipster/generator-jhipster) - Yeoman source code generator for Spring Boot and AngularJS.
* Joda-Beans - (https://www.joda.org/joda-beans) - Small framework that adds queryable properties to Java, enhancing JavaBeans.
* JPA Buddy - (https://www.jpa-buddy.com) - Plugin for IntelliJ IDEA. Provides visual tools for generating JPA entities, Spring Data JPA repositories, Liquibase changelogs and SQL scripts. Offers automatic Liquibase/Flyway script generation by comparing model to DB, and reverse engineering JPA entities from DB tables.
* Lombok - (https://projectlombok.org) - Code generator that aims to reduce verbosity.
* Record-Builder - (https://github.com/Randgalt/record-builder) - Companion builder class, withers and templates for Java records.
* Telosys - (https://www.telosys.org) - Simple and light code generator available as an Eclipse Plugin and also as a CLI.

Compiler

Java Compiler - Java Frameworks that help to create parsers, interpreters or compilers

* ANTLR - (https://www.antlr.org) - Complex full-featured framework for top-down parsing.
* JavaCC - (https://javacc.github.io/javacc) - Parser generator that generates top-down parsers. Allows lexical state switching and permits extended BNF specifications.
* JFlex - (https://jflex.de) - Lexical analyzer generator.

Computer Vision

Java Computer Vision - Java Libraries which seek to gain high level information from images and videos

* BoofCV - (https://boofcv.org) - Library for image processing, camera calibration, tracking, SFM, MVS, 3D vision, QR Code and much more.
* ImageJ - (https://imagej.net/ImageJ) - Medical image processing application with an API.
* JavaCV - (https://github.com/bytedeco/javacv) - Java interface to OpenCV, FFmpeg, and much more.

Configuration

Java Configuration - Java Libraries that provide external configuration

* centraldogma - (https://github.com/line/centraldogma) - Highly-available version-controlled service configuration repository based on Git, ZooKeeper and HTTP/2.
* cfg4j - (https://github.com/cfg4j/cfg4j) - Modern configuration library for distributed apps written in Java.
* config - (https://github.com/lightbend/config) - Configuration library supporting Java properties, JSON or its human optimized superset HOCON.
* Configurate - (https://github.com/SpongePowered/Configurate) - Configuration library with support for various configuration formats and transformations.
* dotenv - (https://github.com/shyiko/dotenv) - Twelve-factor configuration library which uses environment-specific files.
* ini4j - (http://ini4j.sourceforge.net) - Provides an API for handling Windows' INI files.
* KAConf - (https://github.com/mariomac/kaconf) - Annotation-based configuration system for Java and Kotlin.
* microconfig - (https://microconfig.io) - Configuration system designed for microservices which helps to separate configuration from code. The configuration for different services can have common and specific parts and can be dynamically distributed.
* owner - (https://github.com/lviggiano/owner) - Reduces boilerplate of properties.

Constraint Satisfaction Problem Solver

Java Constraint Satisfaction Problem Solver - Java Libraries that help with implementing optimization and satisfiability problems

* Choco - (https://choco-solver.org) - Off-the-shelf constraint satisfaction problem solver that uses constraint programming techniques.
* JaCoP - (https://github.com/radsz/jacop) - Includes an interface for the FlatZinc language, enabling it to execute MiniZinc models. (AGPL-3.0)
* OptaPlanner - (https://www.optaplanner.org) - Business planning and resource scheduling optimization solver.

CSV

Java CSV - Java Frameworks and libraries that simplify reading/writing CSV data

* FastCSV - (https://github.com/osiegmar/FastCSV) - Performance-optimized, dependency-free and RFC 4180 compliant.
* jackson-dataformat-csv - (https://github.com/FasterXML/jackson-dataformat-csv) - Jackson extension for reading and writing CSV.
* opencsv - (http://opencsv.sourceforge.net) - Simple CSV parser.
* Super CSV - (https://super-csv.github.io/super-csv) - Powerful CSV parser with support for Dozer, Joda-Time and Java 8.
* uniVocity-parsers - (https://github.com/uniVocity/univocity-parsers) - One of the fastest and most feature-complete parsers. Also comes with parsers for TSV and fixed-width records.

Data Structures

Java Data Structures - Java Efficient and specific data structures

* Apache Avro - (https://avro.apache.org) - Data interchange format with dynamic typing, untagged data, and absence of manually assigned IDs.
* Apache Orc - (https://orc.apache.org) - Fast and efficient columnar storage format for Hadoop-based workloads.
* Apache Parquet - (https://parquet.apache.org) - Columnar storage format based on assembly algorithms from Google's paper on Dremel.
* Apache Thrift - (https://thrift.apache.org) - Data interchange format that originated at Facebook.
* Big Queue - (https://github.com/bulldog2011/bigqueue) - Fast and persistent queue based on memory-mapped files.
* HyperMinHash-java - (https://github.com/LiveRamp/HyperMinHash-java) - Probabilistic data structure for computing union, intersection, and set cardinality in loglog space.
* Persistent Collection - (https://github.com/hrldcpr/pcollections) - Persistent and immutable analogue of the Java Collections Framework.
* Protobuf - (https://github.com/protocolbuffers/protobuf) - Google's data interchange format.
* RoaringBitmap - (https://github.com/RoaringBitmap/RoaringBitmap) - Fast and efficient compressed bitmap.
* SBE - (https://github.com/real-logic/simple-binary-encoding) - Simple Binary Encoding, one of the fastest message formats around.
* Tape - (https://github.com/square/tape) - Lightning-fast, transactional, file-based FIFO.
* Wire - (https://github.com/square/wire) - Clean, lightweight protocol buffers.

Database

Java Database - Java Everything that simplifies interactions with the database

* Apache Calcite - (https://calcite.apache.org) - Dynamic data management framework. It contains many of the pieces that comprise a typical database management system.
* Apache Drill - (https://drill.apache.org) - Distributed, schema on-the-fly, ANSI SQL query engine for Big Data exploration.
* Apache Phoenix - (https://phoenix.apache.org) - High-performance relational database layer over HBase for low-latency applications.
* ArangoDB - (https://github.com/arangodb/arangodb-java-driver) - ArangoDB Java driver.
* Chronicle Map - (https://github.com/OpenHFT/Chronicle-Map) - Efficient, in-memory (opt. persisted to disk), off-heap key-value store.
* Debezium - (https://debezium.io) - Low latency data streaming platform for change data capture.
* druid - (https://druid.apache.org) - High-performance, column-oriented, distributed data store.
* eXist - (https://github.com/eXist-db/exist) - NoSQL document database and application platform. (LGPL-2.1-only)
* FlexyPool - (https://github.com/vladmihalcea/flexy-pool) - Brings metrics and failover strategies to the most common connection pooling solutions.
* Flyway - (https://flywaydb.org) - Simple database migration tool.
* H2 - (https://h2database.com) - Small SQL database notable for its in-memory functionality.
* HikariCP - (https://github.com/brettwooldridge/HikariCP) - High-performance JDBC connection pool.
* JDBI - (http://jdbi.org) - Convenient abstraction of JDBC.
* Jedis - (https://github.com/xetorthio/jedis) - Small client for interaction with Redis, with methods for commands.
* Jest - (https://github.com/searchbox-io/Jest) - Client for the Elasticsearch REST API.
* jetcd - (https://github.com/justinsb/jetcd) - Client library for etcd.
* Jinq - (https://github.com/my2iu/Jinq) - Typesafe database queries via symbolic execution of Java 8 Lambdas (on top of JPA or jOOQ).
* jOOQ - (https://www.jooq.org) - Generates typesafe code based on SQL schema.
* Leaf - (https://github.com/Meituan-Dianping/Leaf) - Distributed ID generate service.
* Liquibase - (http://www.liquibase.org) - Database-independent library for tracking, managing and applying database schema changes.
* MapDB - (http://www.mapdb.org) - Embedded database engine that provides concurrent collections backed on disk or in off-heap memory.
* MariaDB4j - (https://github.com/vorburger/MariaDB4j) - Launcher for MariaDB that requires no installation or external dependencies.
* Modality - (https://github.com/arkanovicz/modality) - Lightweight ORM with database reverse engineering features.
* Spring Data JPA MongoDB Expressions - (https://github.com/mhewedy/spring-data-jpa-mongodb-expressions) - Allows you to use MongoDB query language to query your relational database.
* Trino - (https://trino.io) - Distributed SQL query engine for big data.
* QuestDB - (https://github.com/questdb/questdb) - High-performance SQL database for time series. Supports InfluxDB line protocol, PostgreSQL wire protocol, and REST.
* QueryStream - (https://github.com/querystream/querystream) - Build JPA Criteria queries using a Stream-like API.
* Querydsl - (http://www.querydsl.com) - Typesafe unified queries.
* Realm - (https://github.com/realm/realm-java) - Mobile database to run directly inside phones, tablets or wearables.
* Redisson - (https://github.com/redisson/redisson) - Allows for distributed and scalable data structures on top of a Redis server.
* requery - (https://github.com/requery/requery) - Modern, lightweight but powerful object mapping and SQL generator. Easily map to or create databases, or perform queries and updates from any Java-using platform.
* Speedment - (https://github.com/speedment/speedment) - Database access library that utilizes Java 8's Stream API for querying.
* Vibur DBCP - (https://www.vibur.org) - JDBC connection pool library with advanced performance monitoring capabilities.
* Xodus - (https://github.com/JetBrains/xodus) - Highly concurrent transactional schema-less and ACID-compliant embedded database.

Date and Time

Java Date and Time - Java Libraries related to handling date and time

* Almanac Converter - (https://github.com/chrisengelsma/almanac-converter) - Simple conversion between different calendar systems.
* iCal4j - (https://github.com/ical4j/ical4j) - Parse and build iCalendar [RFC 5545]] - (https://tools.ietf.org/html/rfc5545) data models.
* Jollyday - (https://github.com/svendiedrichsen/jollyday) - Determines the holidays for a given year, country/name and eventually state/region.
* ThreeTen-Extra - (https://github.com/ThreeTen/threeten-extra) - Additional date-time classes that complement those in JDK 8.
* Time4J - (https://github.com/MenoData/Time4J) - Advanced date and time library. (LGPL-2.1-only)

Dependency Injection

Java Dependency Injection - Java Libraries that help to realize the Inversion of Control paradigm - (https://en.wikipedia.org/wiki/Inversion_of_control)

* Apache DeltaSpike - (https://deltaspike.apache.org) - CDI extension framework.
* Dagger - (https://dagger.dev) - Compile-time injection framework without reflection.
* Feather - (https://github.com/zsoltherpai/feather) - Ultra-lightweight, JSR-330-compliant dependency injection library.
* Governator - (https://github.com/Netflix/governator) - Extensions and utilities that enhance Google Guice.
* Guice - (https://github.com/google/guice) - Lightweight and opinionated framework that completes Dagger.
* HK2 - (https://javaee.github.io/hk2) - Lightweight and dynamic dependency injection framework.
* JayWire - (https://github.com/vanillasource/jaywire) - Lightweight dependency injection framework. (LGPL-3.0-only)

Development

Java Development - Java Augmentation of the development process at a fundamental level

* AspectJ - (https://www.eclipse.org/aspectj) - Seamless aspect-oriented programming extension.
* DCEVM - (https://dcevm.github.io) - JVM modification that allows unlimited redefinition of loaded classes at runtime. (GPL-2.0-only)
* Faux Pas - (https://github.com/zalando/faux-pas) - Library that simplifies error handling by circumventing the issue that none of the functional interfaces in the Java Runtime is allowed by default to throw checked exceptions.
* HotswapAgent - (https://github.com/HotswapProjects/HotswapAgent) - Unlimited runtime class and resource redefinition. (GPL-2.0-only)
* JavaParser - (https://github.com/javaparser/javaparser) - Parse, modify and generate Java code.
* JavaSymbolSolver - (https://github.com/javaparser/javasymbolsolver) - Symbol solver.
* Manifold - (https://github.com/manifold-systems/manifold) - Re-energizes Java with powerful features like type-safe metaprogramming, structural typing and extension methods.
* NoException - (https://noexception.machinezoo.com) - Allows checked exceptions in functional interfaces and converts exceptions to Optional return.
* SneakyThrow - (https://github.com/rainerhahnekamp/sneakythrow) - Ignores checked exceptions without bytecode manipulation. Can also be used inside Java 8 stream operations.
* Tail - (https://kag0.github.io/tail) - Enable infinite recursion using tail call optimization.

Distributed Applications

Java Distributed Applications - Java Libraries and frameworks for writing distributed and fault-tolerant applications

* Apache Geode - (https://geode.apache.org) - In-memory data management system that provides reliable asynchronous event notifications and guaranteed message delivery.
* Apache Storm - (https://storm.apache.org) - Realtime computation system.
* Apache ZooKeeper - (https://zookeeper.apache.org) - Coordination service with distributed configuration, synchronization, and naming registry for large distributed systems.
* Atomix - (https://atomix.io) - Fault-tolerant distributed coordination framework.
* Axon - (https://axoniq.io) - Framework for creating CQRS applications.
* Dropwizard Circuit Breaker - (https://github.com/mtakaki/dropwizard-circuitbreaker) - Circuit breaker design pattern for Dropwizard. (GPL-2.0-only)
* Failsafe - (https://github.com/jhalterman/failsafe) - Simple failure handling with retries and circuit breakers.
* Hazelcast - (https://github.com/hazelcast/hazelcast) - Highly scalable in-memory datagrid with a free open-source version.
* JGroups - (http://www.jgroups.org) - Toolkit for reliable messaging and cluster creation.
* Quasar - (http://docs.paralleluniverse.co/quasar) - Lightweight threads and actors for the JVM.
* resilience4j - (https://github.com/resilience4j/resilience4j) - Functional fault tolerance library.
* ScaleCube Services - (https://github.com/scalecube/scalecube-services) - Embeddable Cluster-Membership library based on SWIM and gossip protocol.
* Zuul - (https://github.com/Netflix/zuul) - Gateway service that provides dynamic routing, monitoring, resiliency, security, and more.

Distributed Transactions

Java Distributed Transactions - Java Distributed transactions provide a mechanism for ensuring consistency of data updates in the presence of concurrent access and partial failures

* Atomikos - (https://www.atomikos.com) - Provides transactions for REST, SOA and microservices with support for JTA and XA.
* Bitronix - (https://github.com/bitronix/btm) - Simple but complete implementation of the JTA 1.1 API.
* Narayana - (https://narayana.io) - Provides support for traditional ACID and compensation transactions, also complies with JTA, JTS and other standards. (LGPL-2.1-only)
* Seata - (https://github.com/seata/seata) - Delivers high performance and easy to use distributed transaction services under a microservices architecture.

Distribution

Java Distribution - Java Tools that handle the distribution of applications in native formats

* Artipie - (https://github.com/artipie/artipie) - Binary artifact management toolkit which hosts them on the file system or S3.
* Boxfuse - (https://boxfuse.com) - Deployment of JVM applications to AWS using the principles of immutable infrastructure.
* Capsule - (https://github.com/puniverse/capsule) - Simple and powerful packaging and deployment. A fat JAR on steroids, or a "Docker for Java" that supports JVM-optimized containers.
* Central Repository - (https://search.maven.org) - Largest binary component repository available as a free service to the open-source community. Default used by Apache Maven, and available in all other build tools.
* Cloudsmith - (https://cloudsmith.io) - Fully managed package management SaaS with support for Maven/Gradle/SBT with a free tier.
* Getdown - (https://github.com/threerings/getdown) - A system for deploying Java applications to end-user computers and keeping them up to date. Developed as an alternative to Java Web Start.
* IzPack - (http://izpack.org) - Setup authoring tool for cross-platform deployments.
* JavaPackager - (https://github.com/fvarrui/JavaPackager) - Maven and Gradle plugin which provides an easy way to package Java applications in native Windows, Mac OS X or GNU/Linux executables, and generate installers for them.
* jlink.online - (https://github.com/cilki/jlink.online) - Builds optimized runtimes over HTTP.
* Nexus - (https://www.sonatype.com) - Binary management with proxy and caching capabilities.
* packr - (https://github.com/libgdx/packr) - Packs JARs, assets and the JVM for native distribution on Windows, Linux and macOS.
* really-executable-jars-maven-plugin - (https://github.com/brianm/really-executable-jars-maven-plugin) - Maven plugin for making self-executing JARs.

Document Processing

Java Document Processing - Java Libraries that assist with processing office document formats
* Apache POI - (https://poi.apache.org) - Supports OOXML (XLSX, DOCX, PPTX) as well as OLE2 (XLS, DOC or PPT).
* documents4j - (https://documents4j.com/#) - API for document format conversion using third-party converters such as MS Word.
* docx4j - Create and manipulate Microsoft Open XML files
* fastexcel - (https://github.com/dhatim/fastexcel) - High performance library to read and write large Excel (XLSX) worksheets.
* zerocell - (https://github.com/creditdatamw/zerocell) - Annotation-based API for reading data from Excel sheets into POJOs with focus on reduced overhead.

Financial

Java Financial - Java Libraries related to the financial domain

* Cassandre - (https://github.com/cassandre-tech/cassandre-trading-bot) - Trading bot framework.
* Parity - (https://github.com/paritytrading/parity) - Platform for trading venues.
* Philadelphia - (https://github.com/paritytrading/philadelphia) - Low-latency financial information exchange.
* Square - (https://github.com/square/connect-java-sdk) - Integration with the Square API.
* Stripe - (https://github.com/stripe/stripe-java) - Integration with the Stripe API.
* ta4j - (https://github.com/ta4j/ta4j) - Library for technical analysis.

Formal Verification

Java Formal Verification - Java Formal-methods tools - proof assistants, model checking, symbolic execution, etc

* CATG - (https://github.com/ksen007/janala2) - Concolic unit testing engine. Automatically generates unit tests using formal methods.
* Checker Framework - (https://checkerframework.org) - Pluggable type systems. Includes nullness types, physical units, immutability types and more. (GPL-2.0-only WITH Classpath-exception-2.0)
* Daikon - (https://plse.cs.washington.edu/daikon) - Detects likely program invariants and generates JML specs based on those invariants.
* Java Path Finder (JPF) - (https://github.com/javapathfinder/jpf-core) - JVM formal verification tool containing a model checker and more. Created by NASA.
* JMLOK 2.0 - (https://massoni.computacao.ufcg.edu.br/home/jmlok) - Detects inconsistencies between code and JML specification through feedback-directed random tests generation, and suggests a likely cause for each nonconformance detected. (GPL-3.0-only)
* KeY - (https://www.key-project.org) - Formal software development tool that aims to integrate design, implementation, formal specification, and formal verification of object-oriented software as seamlessly as possible. Uses JML for specification and symbolic execution for verification. (GPL-2.0-or-later)
* OpenJML - (http://www.openjml.org) - Translates JML specifications into SMT-LIB format and passes the proof problems implied by the program to backend solvers. (GPL-2.0-only)