Table of ContentsBean Mapping, Build, Bytecode Manipulation, Caching, CLI, Cluster Management, Code Analysis, Code Coverage, Code Generators, Compiler-compiler, Computer Vision, Configuration, Constraint Satisfaction Problem Solver, CSV, Data Structures, Database, Date and Time, Dependency Injection, Development, Distributed Applications, Distributed Transactions, Distribution, Document Processing, Financial, Formal Verification, Functional Programming, Game Development, Geospatial, GUI, High Performance, HTTP Clients, Hypermedia Types, IDE, Imagery, Introspection, Job Scheduling, JSON, JVM and JDK, Logging, Machine Learning, Messaging, Microservice, Miscellaneous, Mobile Development, Monitoring, Native, Natural Language Processing, Networking, ORM, PaaS, PDF, Performance analysis, Apache Commons, Other, Processes, Reactive libraries, REST Frameworks, Science, Search, Security, Serialization, Server, Template Engine, Testing, BDD, Fixtures, Frameworks, Matchers, Miscellaneous, Mocking, Utility, Version Managers, Web Crawling, Web Frameworks,
Frameworks that ease bean mapping.
Code generator that simplifies mappings between different bean types, based on a convention-over-configuration approach.
Intelligent object mapping library that automatically maps objects to each other.
JavaBean-mapping framework that recursively copies (among other capabilities) data from one object to another.
Uses byte code manipulation for lightning-fast mapping. Supports annotations and API or XML configuration.
Annotation processor-based bean mapper.
Lambda and method handle-based mapping which requires code and not annotations if objects have different names.
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.
Tools that handle the build cycle and dependencies of an application.
Tool from Google that builds code quickly and reliably.
Incremental builds programmed via Groovy instead of declaring XML. Works well with Maven's dependency management.
Encourages the creation of small, reusable modules consisting of code and resources.
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.
Libraries to manipulate bytecode programmatically.
Java 8 Jar & Android APK reverse engineering suite. (GPL-3.0-only)
Further simplifies bytecode generation with a fluent API.
JVM reverse engineering toolkit, essentially an IDE for Java bytecode.
Bytecode generation library.
Tries to simplify bytecode editing.
Manipulate bytecode at runtime using real Java code.
Manipulate bytecode at runtime via DSL (rules); mainly for testing/troubleshooting. (LGPL-2.1-or-later)
Dynamically injects failure/latency at the bytecode level according to principles of chaos engineering.
Provides low level bytecode generation.
Libraries that provide caching facilities.
Libraries for everything related to the CLI.
ANSI colors and styles in usage help with annotation-based POSIX/GNU/any syntax, subcommands, strong typing for both options and positional args.
Easy console text-GUI library, similar to curses. (LGPL-3.0-only)
Command-line argument-parsing framework with custom types and validation via implementing interfaces.
Includes features from modern shells like completion or history.
ANSI escape codes to format console output.
Annotation-based framework for parsing Git-like command-line arguments.
Small library to parse command-line arguments.
Library to draw tables in ASCII.
Fluent parser that uses the POSIX#getopt and GNU#getopt_long syntaxes.
Aids the creation of full console-based applications.
Graphical primitives for the console.
Reflectionless command line parser.
Frameworks that can dynamically manage applications inside of a cluster.
Tools that provide metrics and quality measurements.
Provides Alibaba's coding guidelines for PMD, IDEA and Eclipse.
Modern static analysis tool for verifying the correctness of code.
Static analysis of coding conventions and standards. (LGPL-2.1-or-later)
Catches common programming mistakes as compile-time errors.
Source code analysis for finding bad coding practices.
Eliminates NullPointerExceptions with low build-time overhead.
Static analysis of bytecode to find potential bugs. (LGPL-2.1-only)
Library for analyzing and transforming Java source code.
Static analyzer for SonarQube & SonarLint. (LGPL-3.0-only)
Identifies and prioritizes God Classes and Highly Coupled classes.
Static code analysis with Neo4J-based query language. (GPL-3.0-only)
Error Prone extensions: extra bug checkers and a large battery of Refaster templates.
Frameworks and tools that enable code coverage metrics collection for test suites.
Framework that enables collection of code coverage metrics, using both offline and runtime bytecode instrumentation.
Relies on offline (or static) bytecode instrumentation and class loading to collect code coverage metrics. (GPL-2.0-only)
Relies on source-code instrumentation instead of bytecode instrumentation.
Tools that generate patterns for repetitive code in order to reduce verbosity and error-proneness.
Yeoman source code generator for Spring Boot and AngularJS.
Code generator that aims to reduce verbosity.
API to generate source files.
Generates factory, service, and value classes.
Annotation processors to generate simple, safe and consistent value objects.
Automatically generates the Builder pattern.
Companion builder class, withers and templates for Java records.
Simple and light code generator available as an Eclipse Plugin and also as a CLI.
Small framework that adds queryable properties to Java, enhancing JavaBeans.
JSR-269 code generator for algebraic data types.
Discovers files that need generated code, updates automatically and writes to the source with a convenient API.
Generates Lightweight JAX-RS style http servers using Javalin or Helidon (Nima) SE.
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.
Frameworks that help to create parsers, interpreters or compilers.
Libraries which seek to gain high level information from images and videos.
Libraries that provide external configuration.
Configuration library supporting Java properties, JSON or its human optimized superset HOCON.
High-level API for Apache ZooKeeper.
Reduces boilerplate of properties.
Highly-available version-controlled service configuration repository based on Git, ZooKeeper and HTTP/2.
Modern configuration library for distributed apps written in Java.
Configuration library with support for various configuration formats and transformations.
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.
Annotation-based configuration system for Java and Kotlin.
Twelve-factor configuration library which uses environment-specific files.
Loads yaml and properties files, supports dynamic configuration, plugins, file-watching and config event listeners.
Lightweight yet powerful configuration library which supports resolution of properties from external sources and an extensible post-processing/conversion mechanism.
Constraint Satisfaction Problem Solver
Libraries that help with implementing optimization and satisfiability problems.
Off-the-shelf constraint satisfaction problem solver that uses constraint programming techniques.
Flexible solver with Spring/Quarkus support and quickstarts for the Vehicle Routing Problem, Maintenance Scheduling, Employee Shift Scheduling and much more.
Includes an interface for the FlatZinc language, enabling it to execute MiniZinc models. (AGPL-3.0)
Business planning and resource scheduling optimization solver.
Frameworks and libraries that simplify reading/writing CSV data.
One of the fastest and most feature-complete parsers. Also comes with parsers for TSV and fixed-width records.
Powerful CSV parser with support for Dozer, Joda-Time and Java 8.
Performance-optimized, dependency-free and RFC 4180 compliant.
Jackson extension for reading and writing CSV.
Efficient and specific data structures.
Google's data interchange format.
Data interchange format that originated at Facebook.
Clean, lightweight protocol buffers.
Fast and efficient compressed bitmap.
Simple Binary Encoding, one of the fastest message formats around.
Data interchange format with dynamic typing, untagged data, and absence of manually assigned IDs.
Lightning-fast, transactional, file-based FIFO.
Columnar storage format based on assembly algorithms from Google's paper on Dremel.
Persistent and immutable analogue of the Java Collections Framework.
Fast and efficient columnar storage format for Hadoop-based workloads.
Fast and persistent queue based on memory-mapped files.
Probabilistic data structure for computing union, intersection, and set cardinality in loglog space.
Everything that simplifies interactions with the database.
Allows for distributed and scalable data structures on top of a Redis server.
High-performance JDBC connection pool.
High-performance SQL database for time series. Supports InfluxDB line protocol, PostgreSQL wire protocol, and REST.
High-performance, column-oriented, distributed data store.
Mobile database to run directly inside phones, tablets or wearables.
Small client for interaction with Redis, with methods for commands.
Low latency data streaming platform for change data capture.
Distributed SQL query engine for big data.
Simple database migration tool.
Distributed ID generate service.
Generates typesafe code based on SQL schema.
Lettuce is a scalable Redis client for building non-blocking Reactive applications.
Embedded database engine that provides concurrent collections backed on disk or in off-heap memory.
Typesafe unified queries.
Database-independent library for tracking, managing and applying database schema changes.
Dynamic data management framework. It contains many of the pieces that comprise a typical database management system.
Small SQL database notable for its in-memory functionality.
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.
Efficient, in-memory (opt. persisted to disk), off-heap key-value store.
Client for the Elasticsearch REST API.
Database access library that utilizes Java 8's Stream API for querying.
Convenient abstraction of JDBC.
Distributed, schema on-the-fly, ANSI SQL query engine for Big Data exploration.
Highly concurrent transactional schema-less and ACID-compliant embedded database.
Brings metrics and failover strategies to the most common connection pooling solutions.
High-performance relational database layer over HBase for low-latency applications.
Typesafe database queries via symbolic execution of Java 8 Lambdas (on top of JPA or jOOQ).
NoSQL document database and application platform. (LGPL-2.1-only)
Universal, flexible, high-performance distributed ID generator.
LDAPv3 compliant directory service, developed for the Java platform, providing a high performance, highly available, and secure store for the identities.
ArangoDB Java driver.
Client library for etcd.
JDBC connection pool library with advanced performance monitoring capabilities.
Allows you to use MongoDB query language to query your relational database.
Build JPA Criteria queries using a Stream-like API.
Lightweight ORM with database reverse engineering features.
Launcher for MariaDB that requires no installation or external dependencies.
Date and Time
Libraries related to handling date and time.
Parse and build iCalendar [RFC 5545](https://tools.ietf.org/html/rfc5545) data models.
Advanced date and time library. (LGPL-2.1-only)
Additional date-time classes that complement those in JDK 8.
Determines the holidays for a given year, country/name and eventually state/region.
Libraries that help to realize the [Inversion of Control](https://en.wikipedia.org/wiki/Inversion_of_control) paradigm.
Compile-time injection framework without reflection.
Lightweight and opinionated framework that completes Dagger.
Extensions and utilities that enhance Google Guice.
Ultra-lightweight, JSR-330-compliant dependency injection library.
Microservice-focused compile-time injection framework without reflection.
CDI extension framework.
Lightweight and dynamic dependency injection framework.
Lightweight dependency injection framework. (LGPL-3.0-only)
Augmentation of the development process at a fundamental level.
Parse, modify and generate Java code.
Unlimited runtime class and resource redefinition. (GPL-2.0-only)
Re-energizes Java with powerful features like type-safe metaprogramming, structural typing and extension methods.
JVM modification that allows unlimited redefinition of loaded classes at runtime. (GPL-2.0-only)
Seamless aspect-oriented programming extension.
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.
Allows checked exceptions in functional interfaces and converts exceptions to Optional return.
Ignores checked exceptions without bytecode manipulation. Can also be used inside Java 8 stream operations.
Enable infinite recursion using tail call optimization.
Libraries and frameworks for writing distributed and fault-tolerant applications.
Gateway service that provides dynamic routing, monitoring, resiliency, security, and more.
Coordination service with distributed configuration, synchronization, and naming registry for large distributed systems.
Functional fault tolerance library.
Realtime computation system.
Highly scalable in-memory datagrid with a free open-source version.
Lightweight threads and actors for the JVM.
Simple failure handling with retries and circuit breakers.
Fault-tolerant distributed coordination framework.
In-memory data management system that provides reliable asynchronous event notifications and guaranteed message delivery.
Toolkit for reliable messaging and cluster creation.
Embeddable Cluster-Membership library based on SWIM and gossip protocol.
High-performance reverse proxy server with specialized session management and credential replay functionality.
Circuit breaker design pattern for Dropwizard. (GPL-2.0-only)
Distributed transactions provide a mechanism for ensuring consistency of data updates in the presence of concurrent access and partial failures.
Delivers high performance and easy to use distributed transaction services under a microservices architecture.
Provides transactions for REST, SOA and microservices with support for JTA and XA.
Provides support for traditional ACID and compensation transactions, also complies with JTA, JTS and other standards. (LGPL-2.1-only)
Simple but complete implementation of the JTA 1.1 API.
Tools that handle the distribution of applications in native formats.
Packs JARs, assets and the JVM for native distribution on Windows, Linux and macOS.
Simple and powerful packaging and deployment. A fat JAR on steroids, or a "Docker for Java" that supports JVM-optimized containers.
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.
A system for deploying Java applications to end-user computers and keeping them up to date. Developed as an alternative to Java Web Start.
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.
Binary artifact management toolkit which hosts them on the file system or S3.
Deploy desktop apps as native Mac, Windows or Linux bundles.
Setup authoring tool for cross-platform deployments.
Maven plugin for making self-executing JARs.
Builds optimized runtimes over HTTP.
Libraries that assist with processing office document formats.
Create and manipulate Microsoft Open XML files.
Supports OOXML (XLSX, DOCX, PPTX) as well as OLE2 (XLS, DOC or PPT).
High performance library to read and write large Excel (XLSX) worksheets.
API for document format conversion using third-party converters such as MS Word.
Annotation-based API for reading data from Excel sheets into POJOs with focus on reduced overhead.
Libraries related to the financial domain.
Library for technical analysis.
Integration with the Stripe API.
Trading bot framework.
Platform for trading venues.
Low-latency financial information exchange.
Integration with the Square API.
Formal-methods tools: proof assistants, model checking, symbolic execution, etc.
Pluggable type systems. Includes nullness types, physical units, immutability types and more. (GPL-2.0-only WITH Classpath-exception-2.0)
JVM formal verification tool containing a model checker and more. Created by NASA.
Detects likely program invariants and generates JML specs based on those invariants.
Translates JML specifications into SMT-LIB format and passes the proof problems implied by the program to backend solvers. (GPL-2.0-only)
Concolic unit testing engine. Automatically generates unit tests using formal methods.
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)
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)
Libraries that facilitate functional programming.
Functional component library that provides persistent data types and functional control structures.
Enhances Java 8 Streams.
Extension to Java 8 that aims to fix gaps in lambda by providing numerous missing types and a rich set of sequential Stream API additions.
Implements numerous basic and advanced programming abstractions that assist composition-oriented development.
Monad and stream utilities, comprehensions, pattern matching, functional extensions for all JDK collections, future streams, trampolines and much more.
Java 8 annotation processor and framework for deriving algebraic data types constructors, pattern-matching and morphisms. (GPL-3.0-only)
Collection of stream utilities.
Frameworks that support the development of games.
All-round cross-platform, high-level framework.
Robust framework that abstracts libraries like OpenGL/CL/AL.
JavaFX Game Development Framework.
Game engine for modern 3D development.
Port of the renowned C++ 2D physics engine.
AWT-based, lightweight 2D game engine.
Beginner-friendly, master-ready framework for rapidly prototyping and building 2D games.
High-level 2D game engine with built-in physics based on Swing.
Libraries for working with geospatial data and algorithms.
Road-routing engine. Used as a Java library or standalone web service.
Library that provides tools for geospatial data. (LGPL-2.1-only)
Map rendering based on OpenStreetMap data. (LGPL-3.0-only)
General-purpose spatial/geospatial library.
GeoHash utilities in Java.
Spatial extension of the H2 database. (LGPL-3.0-only)
Library for developing geospatial applications.
Library for using the GeoHash algorithm.
Everything about high-performance computation, from collections to specific libraries.
Inter-thread messaging library.
Concurrency tools currently missing from the JDK.
Data structures and utility methods that are common in high-performance applications.
Collections framework inspired by Smalltalk.
Fast and compact type-specific collections.
Carefully designed extension of the Java Collections Framework with primitive specializations and more.
Libraries that assist with creating HTTP requests and/or binding responses.
Typesafe REST client.
HTTP client binder inspired by Retrofit, JAXRS-2.0, and WebSocket.
Asynchronous HTTP and WebSocket client library.
Client-side IPC library that is battle-tested in the cloud.
Simplified, lightweight HTTP client library.
A toolset of low-level Java components focused on HTTP and associated protocols.
Pluggable HTTP transport abstraction with support for java.net.HttpURLConnection, Apache HTTP Client, Android, Google App Engine, XML, Gson, Jackson and Protobuf.
Client-side response routing for Spring's RestTemplate.
HTTP client extensions library.
A wrapper on JDK 11's HttpClient that adds Feign-like interface among other enhancements.
Integrated development environments that try to simplify several aspects of development.
Libraries that assist with the creation, evaluation or manipulation of graphical images.
Multi-format 1D/2D barcode image processing library.
High-quality thumbnail generation library.
Collection of plugins that extend the number of supported image file formats.
JNA wrapper for Tesseract OCR API.
Simple, efficient and hardware-accelerated image-scaling library implemented in pure Java 2D.
Library that compares 2 images with the same sizes and shows the differences visually by drawing rectangles. Some parts of the image can be excluded from the comparison.
Libraries that help make the Java introspection and reflection API easier and faster to use.
Reflections scans your classpath, indexes the metadata, allows you to query it on runtime and may save and collect that information for many modules within your project.
jOOR stands for jOOR Object Oriented Reflection. It is a simple wrapper for the java.lang.reflect package.
ClassGraph (formerly FastClasspathScanner) is an uber-fast, ultra-lightweight, parallelized classpath scanner and module scanner for Java, Scala, Kotlin and other JVM languages.
ReflectASM is a very small Java library that provides high performance reflection by using code generation.
Allows dynamic instantiation without default constructor, e.g. constructors which have required arguments, side effects or throw exceptions.
Mirror was created to bring light to a simple problem, usually named ReflectionUtil, which is on almost all projects that rely on reflection to do advanced tasks.
Libraries for scheduling background jobs.
Feature-rich, open source job scheduling library that can be integrated within virtually any Java application.
Makes sure that your scheduled tasks are executed at most once at the same time. If a task is being executed on one node, it acquires a lock which prevents execution of the same task from another node or thread.
Job scheduling library which utilizes lambdas for fire-and-forget, delayed and recurring jobs. Guarantees execution by single scheduler instance using optimistic locking. Has features for persistence, minimal dependencies and is embeddable.
Persistent and cluster-friendly scheduler.
Set up batch jobs with simple processing pipelines. Records are read in sequence from a data source, processed in pipeline and written in batches to a data sink.
Lightweight framework to simply define jobs, define triggers and start the scheduler.
Simple library with minimal footprint and straightforward API.
Libraries for serializing and deserializing JSON to and from Java objects.
Very fast processor with no additional dependencies and full data binding.
Serializes objects to JSON and vice versa. Good performance with on-the-fly usage.
Modern JSON library, less opinionated and uses built-in types like List and Map.
Similar to GSON, but offers performance gains if you need to instantiate the library more often.
Extract data from JSON using XPATH-like syntax.
JSON parsing and serializing library based on Jackson's streaming API. Outperforms GSON & Jackson's library.
Fast and flexible library with iterator and lazy parsing API.
JSON to JSON transformation tool.
JSON library with advanced compile time databinding.
High-performance JSON parser, 2x faster than Jackson.
Set of Jackson modules for Java 8 datatypes and features.
Convert Java to JSON. Convert JSON to Java. Pretty print JSON. Java JSON serializer.
Streaming JsonPath processor dedicated to processing big and complicated JSON data.
Open-source Jackson module to support JSON serialization and deserialization of JavaMoney data types.
Powerful and easy-to-use Java-to-JSON conversion library.
Binding layer between classes and JSON documents similar to JAXB.
Reflection-free Json binding via source code generation with Jackson-like annotations.
JVM and JDK
Current implementations of the JVM/JDK.
Polyglot embeddable JVM. (GPL-2.0-only WITH Classpath-exception-2.0)
Open JDK community home. (GPL-2.0-only WITH Classpath-exception-2.0)
Downstream version of OpenJDK optimized for online e-commerce, financial, logistics applications.
High performance, enterprise-calibre, flexibly licensed, openly-governed cross-platform JVM extending and augmenting the runtime technology components from the Eclipse OMR and OpenJDK project.
Community-driven OpenJDK builds, including both HotSpot and OpenJ9.
No-cost, multiplatform, production-ready distribution of OpenJDK by Amazon. (GPL-2.0-only WITH Classpath-exception-2.0)
VM with non-blocking, concurrent GC for iOS. (GPL-2.0-only WITH Classpath-exception-2.0)
JVM with JIT, AOT modes and iOS port.
SAP's no-cost, rigorously tested and JCK-verified OpenJDK friendly fork. (GPL-2.0-only WITH Classpath-exception-2.0)
Built from OpenJDK, thoroughly tested and passed the JCK. (GPL-2.0-only WITH Classpath-exception-2.0)
OpenJDK builds for Windows, Linux, and macOS. (GPL-2.0-only WITH Classpath-exception-2.0)
Libraries that log the behavior of an application.
Analyzes and visualizes log files. Some features require payment.
Tool for managing log files.
Open-source aggregator suited for extended role and permission management. (GPL-3.0-only)
Complete rewrite with a powerful plugin and configuration architecture.
Robust logging library with interesting configuration options via Groovy.
Abstraction layer/simple logging facade.
Enables logging for all JDBC transactions without changes to the code.
Extensible, open-source library for HTTP request and response logging.
Lightweight logging framework with static logger class.
Collection of libraries that build on top of OpenTracing and provide extensions and plugins to existing instrumentations.
API designed around structured logging, rich context, and conditional logging. There are Logback and Log4J2 implementations, but Echopraxia's API is completely dependency-free, meaning it can be implemented with any logging API.
Tools that provide specific statistical algorithms for learning from data.
Fast, reliable, large-scale data processing engine.
Distributed and multi-threaded deep learning library.
Analytics engine for statistics over big data.
Statistical Machine Intelligence and Learning Engine provides a set of machine learning algorithms and a visualization library.
High-level and engine-agnostic framework for deep learning.
CLI tool to transpile models into native code.
Scalable algorithms focused on collaborative filtering, clustering and classification.
Framework for building real-time, large-scale machine learning applications. Includes end-to-end applications for collaborative filtering, classification, regression, and clustering.
Cloud native streaming and complex event processing engine.
Provides tools for classification, regression, clustering, model development and interfaces with other libraries such as scikit-learn, pytorch and TensorFlow.
Provides several algorithms and pre-trained models for natural language processing.
Algorithms for pre-processing, classification, regression, and clustering with support for multi-threaded execution. (GPL-3.0-only)
High-performance mathematics, linear algebra and optimisation needed for data science, machine learning and scientific computing.
Collection of algorithms for data mining tasks ranging from pre-processing to visualization. (GPL-3.0-only)
Seamlessly integrate with remote deep learning and language models programmatically.
Tools that help send messages between clients to ensure protocol independency.
High-throughput distributed messaging system.
Simple publish/subscribe event bus.
Fast, reliable, and scalable distributed messaging platform.
Distributed pub/sub-messaging system.
Efficient, reliable, unicast and multicast message transport.
Glues together different transport APIs via Enterprise Integration Patterns.
Cross-platform XMPP client library.
Implementation of ZeroMQ.
Message broker that implements JMS and converts synchronous to asynchronous communication.
Provides a RESTful API on top of Kafka.
Fast and reliable message broker built on top of Kafka.
Apache Qpid makes messaging tools that speak AMQP and support many languages and platforms.
Simple, lightweight, and performant dispatch library for decoupling messages (requests and events) and message handlers.
Tools for creating and managing microservices.
Dynamic service discovery, configuration and service management platform for building cloud native applications.
Flow control component enabling reliability, resilience and monitoring for microservices.
Kubernetes stack tailored for the HotSpot and Graal VM.
REST-based service registry for resilient load balancing and failover.
Modern full-stack framework with focus on modularity, minimal memory footprint and startup time.
Asynchronous RPC/REST client/server library built on top of Java 8, Netty, HTTP/2, Thrift and gRPC.
Java libraries for using OpenAI's GPT-3 API.
Wrapping of the Discord REST API and its WebSocket events.
Two-style approach for writing microservices: Functional-reactive and as an implementation of MicroProfile.
Client provides access to the full Kubernetes & OpenShift REST APIs via a fluent DSL.
Libraries for writing composable microservices.
Lightweight and fast library for complex high-load distributed applications and Memcached-like solutions.
Client for the Consul API: a distributed, highly available and datacenter-aware registry/discovery service.
Implementation and explanation of the most common design patterns.
No-nonsense implementation of FizzBuzz made by serious businessmen for serious business purposes. (No explicit license)
Popular Java 8 guide.
Tool for working with messy data: cleaning, transforming, extending it with web services and linking it to databases.
Java-to-Objective-C translator for porting Android libraries to iOS.
Browser extension which allows to navigate through code on GitHub more efficiently.
In-memory file system.
High performance HTTP proxy atop Netty's event-based networking library.
Wrapper around AWS' API.
Library for the Svix API to send webhooks and verify signatures.
Ultra-fast, SQL-like queries on Java collections.
Analogue of Gradle Wrapper for Maven, allows building projects without installing maven.
Feature Flags for Java.
Framework for building chatbots. (GPL-3.0-only)
Mailing with a clean and fluent API.
Static website generator.
Implementation of the Feature Toggles pattern.
Extensions for Maven 3.3.1+ that allows writing the POM model in dialects other than XML.
Basic currency and money classes and algorithms not provided by the JDK.
Tools for resolving generic types.
Simple wrapper for the org.w3c.dom package, to allow for fluent XML document creation and manipulation with an API inspired by jQuery.
Open-source, reverse-proxy framework.
Framework for fragment-based message processing. (Apache-2.0 OR LGPL-3.0-or-later)
Small utility library for using handlers and commands with pipelines.
Detect uses of legacy Java APIs.
Obfuscation via renaming and shrinking.
JCuda offers Java bindings for CUDA and CUDA-related libraries.
Lightweight, small and customizable FTP server.
Processes XML by using annotations or XPath within code.
RR4J is a tool that records java bytecode execution and later allows developers to replay locally.
Source code obfuscator.
Tools for creating or managing mobile applications.
Tools that monitor applications in production.
Distributed tracing system which gathers timing data needed to troubleshoot latency problems in microservice architectures.
Open-source APM tool.
Expose metrics via JMX or HTTP and send them to a database.
Dynamic and observable thread pool framework.
Real-time monitoring system with custom-monitor and agentless.
Performance monitoring and profiling.
Provides a multi-dimensional data model, DSL, autonomous server nodes and much more.
Open-source performance monitoring and transaction tracing for JVM apps.
Connect to multiple JVMs and query them for their attributes via JMX. Its query language is based on JSON, which allows non-Java programmers to access the JVM attributes. Supports different output writes, including Graphite, Ganglia, and StatsD.
Open-source Java APM.
Integration with [Sentry](https://github.com/getsentry/sentry), an application error tracking and performance analysis platform.
JMX over REST.
Combines the power of AOP with monitoring and/or logging tools.
Captures detailed run-time information via hooks that can be changed on the fly. It supports tracing over multiple systems via the OpenTracing API and can correlate the data with end user monitoring.
Modern monitoring & analytics.
Lightweight platform monitoring tool for Java VMs.
Remote developer console from the browser for Java 8 via bytecode injection.
Out of the box monitoring of Failsafe Circuit Breaker in Spring-Boot environment.
Performance monitor with distributing transaction tracing for JVM apps.
For working with platform-specific native libraries.
Work with native libraries without writing JNI. Also provides interfaces to common system libraries.
Provides efficient and easy access to native C++.
Work with native libraries without writing JNI. Also provides interfaces to common system libraries. Same goals as JNA, but faster, and serves as the basis for the upcoming [Project Panama](http://openjdk.java.net/projects/panama).
Converts bytecode to OpenCL which allows execution on GPUs.
Natural Language Processing
Libraries that specialize in processing text.
Provides a set of fundamental tools for tasks like tagging, named entity recognition, and sentiment analysis. (GPL-3.0-or-later)
Provides common annotators for plain text input. (Research and Academic Use License)
Collection of reusable NLP tools for linguistic pre-processing, machine learning, lexical resources, etc.
Libraries for building network servers.
High-performance RPC framework.
Framework for building high-performance network applications.
RPC framework based on protobuf and HTTP/2.
Web server providing both blocking and non-blocking APIs based on NIO. Used as a network layer in WildFly. (LGPL-2.1-only)
Programmatically use SSH, SCP or SFTP.
Provides a clean and simple API for efficient TCP and UDP client/server network communication using NIO and Kryo.
Abstract, event-driven async I/O API for network operations over TCP/IP and UDP/IP via Java NIO.
Framework built on Netty with APIs tailored to specific protocols and support for multiple programming paradigms.
Integrates standard Java web-related APIs with Quasar fibers and actors.
Easy-to-use, annotation-based library for creating Thrift clients and serializable types.
Implements a ByteChannel interface over SSLEngine, enabling easy-to-use (socket-like) TLS.
High throughput data ingestion logger to Fluentd and Fluent Bit.
NIO framework. Used as a network layer in Glassfish.
Represent, parse and encode URNs, as in RFC 2141. (GPL-3.0-only)
Client for server-sent events (SSE).
APIs that handle the persistence of objects.
Couples objects with stored procedures or SQL statements.
Robust and widely used, with an active community. (LGPL-2.1-only)
Provides simple and fast data access.
ActiveRecord ORM for rapid development and convention over configuration.
Simple database and CSV mapper.
Database access framework that verifies and generates source code at compile time using annotation processing as well as native SQL templates called two-way SQL.
Language-natural persistence layer.
Provides a clean, static API for data access. Also includes a GUI Modeler for working with database mappings, and DB reverse engineering and generation.
Supports a number of persistence standards: JPA, JAXB, JCA and SDO.
Java platform as a service.
Tools to help with PDF files.
Open-source iText fork. (LGPL-3.0-only & MPL-2.0)
Toolbox for creating and manipulating PDFs.
XML/XHTML and CSS 2.1 renderer. (LGPL-2.1-or-later)
Properly supports modern PDF standards based on flyingsaucer and Apache PDFBox.
Extracts tables from PDF files.
Creates PDF files programmatically.
Complex reporting engine. (LGPL-3.0-only)
Report engine for creating PDF and other formats (DOCX, XLSX, HTML, etc) using Eclipse-based visual editor.
Abstraction layer to JasperReports. (LGPL-3.0-only)
Simplifies JasperReports. (LGPL-3.0-only)
Creates PDFs from XSL-FO.
Tools for performance analysis, profiling and benchmarking.
Analyze the JIT compiler optimisations made by the HotSpot JVM.
Harness for building, running, and analysing nano/micro/milli/macro benchmarks written in Java and other languages targeting the JVM. (GPL-2.0 only WITH Classpath-exception-2.0)
Low-overhead, bias-free sampling profiler.
Logs and records platform JVM stalls.
Utilities for latency measurement and reporting.
Reusable, open source Java software.
Provides extra functionality for classes in java.lang.
Collection of I/O utilities.
Extends or augments the Java Collections Framework.
Lightweight, self-contained mathematics and statistics components.
Generic object pooling component.
General encoding/decoding algorithms, e.g. phonetic, base64 or URL.
JDBC helper library.
Component for reading and writing comma separated value files.
Database connection pooling services.
Command-line arguments parser.
Defines an API for working with tar, zip and bzip2 files.
Easy-to-use wrappers around the Java reflection and introspection APIs.
Collection of network utilities and protocol implementations.
Byte Code Engineering Library - analyze, create, and manipulate Java class files.
File upload capability for your servlets and web applications.
Virtual File System component for treating files, FTP, SMB, ZIP and such like as a single logical file system.
Framework to define validators and validation rules in an xml file.
Reading of configuration/preferences files in various formats.
Expression language which extends the Expression Language of the JSTL.
Wrapper around a variety of logging API implementations.
Library for sending e-mail from Java.
API for dealing with external process execution and environment management in Java.
Java Caching System.
Alternative invocation mechanism for unix-daemon-like java code.
Object-graph navigation language.
Chain of Responsibility pattern implementation.
XML-to-Java-object mapping utility.
Commons Rng provides implementations of pseudo-random numbers generators.
Implementation of the State Chart XML specification aimed at creating and maintaining a Java SCXML engine.
Common implementation of RDF 1.1 that could be implemented by systems on the JVM.
Utilities for manipulating Java Beans using the XPath syntax.
General purpose graph APIs and algorithms.
Library for creating dynamic proxies.
Bean Scripting Framework - interface to scripting languages, including JSR-223.
Function that can be manipulated as an object, or an object representing a single, generic function.
Provides an easy way to enhance (weave) compiled bytecode.
XML based scripting and processing engine.
Java Compiler Interface.
Other kinds of platforms
Fast, lightweight and productive microservices framework with built-in [security](https://github.com/networknt/light-oauth2/).
High-level framework for developing enterprise applications with a rich web interface, based on Spring, EclipseLink and Vaadin.
Open-source business application platform for rapid configuration/development of CRM, ERP, LMS and other applications.
Libraries that help the management of operating system processes.
Libraries for developing reactive applications.
Allows for composing asynchronous and event-based programs using observable sequences.
Polyglot event-driven application framework.
Toolkit and runtime for building concurrent, distributed, fault-tolerant and event-driven applications.
Library for building reactive fast-data applications.
Provides a standard for asynchronous stream processing with non-blocking backpressure.
Frameworks specifically for creating RESTful services.
Sinatra inspired framework.
Opinionated framework for setting up modern web applications with Jetty, Jackson, Jersey and Metrics.
Automates the generation of API documentation using Spring Boot projects.
Framework for building robust, scalable RESTful architectures using typesafe bindings and asynchronous, non-blocking IO with an end-to-end developer workflow that promotes clean practices, uniform interface design and consistent data modeling.
Simple, secure and extremely fast framework consisting of an embedded HTTP server, GUI components and dependency injection.
Fully certified and portable implementation of the JAX-RS specification.
Opinionated framework for JSON- or GraphQL-APIs based on a JPA data model.
Convenient, extensible microservices plugin system for Spring & Spring Boot. With more than 30 plugins and growing, it supports both micro-monolith and pure microservices styles.
Thin wrapper on the JBoss Netty HTTP stack that provides scaling and performance.
JAX-RS reference implementation.
Pioneering framework with powerful routing and filtering capabilities, and a unified client and server API.
Implementation of the JSON API specification to build resource-oriented REST endpoints with sorting, filtering, paging, linking, object graphs, type-safety, bulk updates, integrations and more.
Libraries for scientific computing, analysis and visualization.
Includes a data-frame, an embedded column store, and hundreds of methods to transform, summarize, or filter data.
Graph library that provides mathematical graph-theory objects and algorithms.
Light-weight library for plotting data. Many customizable chart types are available.
2D chart library for Swing, JavaFX and server-side applications. (LGPL-2.1-only)
Library for visualizing (mainly Swing) and interacting with node-edge graphs.
Facilitates processing biological data by providing algorithms, file format parsers, sequencing and 3D visualization commonly used in bioinformatics.
Scientific charting library with focus on performance optimised real-time data visualisation at 25 Hz update rates for large data sets.
Library for modeling and analyzing dynamic graphs.
Provides a versatile two-dimensional memory efficient tabular data structure called a DataFrame to enable efficient in-memory analytics for scientific computing on the JVM.
Modular, light and easy graph framework for theoretic algorithms.
Library for creating, manipulating and solving Boolean and Pseudo-Boolean formulas.
Generates a wide variety of 3D charts that can be displayed with Swing and JavaFX or exported to PDF, SVG, PNG and JPEG. (GPL-3.0-only)
Library for geophysical scientific computation, visualization and digital signal analysis.
Engines that index documents for search and analysis.
Distributed, multitenant-capable, full-text search engine with a RESTful web interface and schema-free JSON documents.
High-performance, full-featured, cross-platform, text search engine library.
Enterprise search engine optimized for high-volume traffic.
Simple and light full text indexing and searching library.
Libraries that handle security, authentication, authorization or session management.
Integrated SSO and IDM for browser apps and RESTful web services.
Provides a simple and misuse-proof API for common cryptographic tasks.
Multiplatform, transparent, client-side encryption of files in the cloud. (GPL-3.0-only)
JSON web token for Java and Android.
Detects publicly disclosed vulnerabilities contained within a project's dependencies.
Performs authentication, authorization, cryptography and session management.
System for distributing and managing secrets.
All-purpose cryptographic library and JCA provider offering a wide range of functions, from basic helpers to PGP/SMIME operations.
Multi-platform high-level cryptographic library provides easy-to-use encryption for protecting sensitive data: secure messaging with forward secrecy, secure data storage (AES256GCM); suits for building end-to-end encrypted applications.
Fine-grained authorization for applications with support for RBAC, ABAC, and ReBAC.
Access management solution that includes authentication, SSO, authorization, federation, entitlements and web services security.
High-level SSL context builder for configuring HTTP clients with SSL/TLS.
User-friendly cryptographic library that supports Argon2, Bcrypt, Scrypt, PBKDF2 and various other cryptographic hash functions.
Advanced password strength estimation.
Enforce password policy by validating candidate passwords against a configurable rule set.
Runtime application that repels application security risks included in the OWASP Top 10, including SQL injection, cross-site scripting, cross-site request forgery, data tampering, and brute force attacks.
Binding for the Networking and Cryptography (NaCl) library.
JSON Web Key Set parser.
One-time password generator library according to RFC 4226 (HOTP) and RFC 6238 (TOTP).
Provides permission-based authorization services.
Fluent Builder API for JCA and JSSE classes and especially X.509 certificates.
Easily create and parse JSON Web Tokens and create customized JWT validators using a fluent API.
Libraries that handle serialization with high efficiency.
Memory-efficient serialization library that can access serialized data without unpacking and parsing it.
Fast and efficient object graph serialization framework.
A blazing fast multi-language serialization framework powered by jit and zero-copy.
JDK-compatible, high-performance object graph serialization.
Efficient binary serialization format.
Serializing objects in the PHP serialization format.
Servers specifically used to deploy applications.
Robust, all-round server for Servlet and JSP.
Tiny, easily embeddable HTTP server.
Provides a Web server and javax.servlet container, plus support for HTTP/2, WebSocket, OSGi, JMX, JNDI, JAAS and many other integrations.
Formerly known as JBoss and developed by Red Hat with extensive Java EE support. (LGPL-2.1-only)
Tomcat plus Java EE.
Tools that substitute expressions in a template.
Aims to be a substitute for JSP and works for XML files.
Logicless and semantic Mustache templates.
Inspired by Twig and separates itself with its inheritance feature and its easy-to-read syntax. It ships with built-in autoescaping for security and it includes integrated support for internationalization.
Library to generate text output (HTML web pages, e-mails, configuration files, source code, etc.) based on templates and changing data.
Template engine for generating source code, web pages, emails, or any other formatted text output.
Implementation of Pug (formerly known as Jade).
Optimized, memory efficient and speedy template engine producing statically typed, plain objects.
Compiles to classes, and uses an easy syntax, several features to make development easier and provides fast execution and a small footprint.
Modular, configurable and fully tested template engine.
Typesafe Mustache templating engine.
Tools that test from model to the view.
Testing for the software development process that emerged from TDD and was heavily influenced by DDD and OOAD.
Provides a way to describe features in a plain language which customers can understand.
Automated Acceptance testing and reporting library that works with Cucumber, JBehave and JUnit to make it easier to write high quality executable specifications.
Provides a fluent API which allows for simpler composition.
Aims to provide a fluent API to write tests in long and descriptive sentences that read like plain English.
Extensively configurable framework that describes stories.
Collection of Gherkin steps for REST-service testing using Cucumber.
Follows a Jasmine-like syntax.
Everything related to the creation and handling of random data.
Port of Ruby's fake data generator.
Fake data generator.
Automates data setup in unit tests by generating fully-populated, reproducible objects. Includes JUnit 5 extension.
Another fake data generator.
Generates fake objects from a template.
JUnit test runner and plugins for running JUnit tests with pseudo-randomness.
Sets up beans from YAML fixtures.
Provide environments to run tests for a specific use case.
Functional testing and performance measurements.
Load testing tool designed for ease of use, maintainability and high performance.
Common testing framework.
Test library for specifying and asserting architecture rules.
Fast mutation-testing framework for evaluating fault-detection abilities of existing JUnit or TestNG test suites.
Consumer-driven contract testing.
Engine for property-based testing built on JUnit 5.
Integration testing framework that focuses on both client- and server-side messaging.
Integration and functional testing platform for Java EE containers.
Libraries that provide custom matchers.
Google's fluent assertion and proposition framework.
Fluent assertions that improve readability.
Matchers that can be combined to create flexible expressions of intent.
Simplifies testing JSON strings.
Library that simplifies JSON comparison in tests.
Simplifies testing for XML output.
Other stuff related to testing.
Provides throwaway instances of common databases, Selenium web browsers, or anything else that can run in a Docker container.
Captures log entries for unit testing purposes.
TestNG-like data provider/runner for JUnit.
Reports whether instances of a given class are immutable.
Tests if a request/response matches a given RAML definition.
Automatically performs tests on basic POJO methods. (LGPL-3.0-only)
Captures console output for unit testing purposes.
Captures log entries and provides assertions for unit and integration testing.
Tools which mock collaborators to help testing single, isolated units.
Mocking framework that lets you write tests with a clean and simple API.
Stubs and mocks web services.
Allows mocking of systems integrated with HTTPS.
Concise web services for stubs and mocks.
Mocks static methods, constructors, final classes and methods, private methods, and removal of static initializers.
Integration testing, API mocking and faking, and code coverage.
Libraries which provide general utility functions.
Collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, and more.
Allows to troubleshoot production issues for applications without modifying code or restarting servers.
Cross-platform for visualizing and manipulating large graph networks. (GPL-3.0-only)
Library that helps with constructing difficult regular expressions.
Rate limiting library based on token-bucket algorithm.
Bulk data loader that helps data transfer between various databases, storages, file formats, and cloud services.
Java/JavaFX tool capable of powerful ETL and data visualization.
Utilities for text or data comparison and patching.
Provides simple APIs to access any Amazon S3-compatible object storage server.
Provides a shell into a JVM that's running CRaSH. Used by Spring Boot and others. (LGPL-2.1-or-later)
Provides an ontology editor and a framework to build knowledge-based systems.
Collection of object-oriented primitives.
Port of Underscore.js functions.
Lightweight, pure Java library implementing the Git version control system.
Generates postman collection, environment and integration tests from java code.
Micro library to watch for directory file system changes, simplifying java.nio.file.WatchService.
Utilities that help create the development shell environment and switch between different Java versions.
Java Version Manager inspired by RVM and rbenv. Supports UNIX-based platforms.
Java Version Manager inspired by rbenv. Can configure globally or per project. Tested on Debian and macOS.
Java Version Manager inspired by nvm. Supports macOS, Linux and Windows.
Libraries that analyze the content of websites.
Scalable crawler with downloading, url management, content extraction and persistent.
Scrapes, parses, manipulates and cleans HTML.
Simple and lightweight web crawler.
Highly extensible, highly scalable web crawler for production environments.
SDK for building low-latency and scalable web crawlers.
Frameworks that handle the communication between the layers of a web application.
Built on Akka, it provides predictable and minimal resource consumption (CPU, memory, threads) for highly-scalable applications in Java and Scala.
Microframework for web applications.
Lightweight, modular framework that aims to be elegant and simple.
Set of libraries that facilitate fast, efficient, evolvable and well-tested HTTP applications.
Full-stack web framework.
Event-driven framework that uses standard web components. Server-side architecture with Ajax on the client side.
JSF framework with both free and commercial/support versions and frontend components.
Scalable, fast and modular micro-framework that offers multiple programming models.
Minimally opinionated framework for runnable apps.
Small, highly modularized, Sinatra-like framework.
Opinionated web framework which is built around the concepts of True Object-Oriented Programming and immutability.
Lightweight asynchronous framework built from the ground up for developing high-performance web applications.
Component-based web application framework similar to Tapestry, with a stateful GUI.
Asynchronous framework for rapid development of high-performance web application.
Component-oriented framework for creating dynamic, robust, highly scalable web applications.