An Atomix based cluster manager implementation for Vert.x 3.
Consul cluster manager.
Hazelcast cluster manager.
Ignite cluster manager.
Infinispan cluster manager.
JGroups cluster manager.
Zookeeper cluster manager.
The official Vert.x blog containing many tutorials and other information.
A group for Vert.x core *developers* and *contributors*.
Chat about any Vert.x-related topic.
Vert.x core issue tracker.
Discuss all user issues related to *using* Vert.x.
Contains useful information about Vert.x.
Asynchronous and non-blocking API to interact with Aerospike server. Uses AerospikeClient's async commands internally and handles the result on the Vert.x Context.
Non-blocking Bitsy Graph server integration.
A Vert.x client allowing applications to interact with a Cassandra service.
Asynchronous API to interact with Cassandra and Cassandra Mapping.
Client for Oracle, PostgreSQL, SQL Server, HyperSQL, etc. designed for security, correctness, and ease of use.
An example on how to build a Vert.x gRPC compliant client. Here targeting dgraph
Kotlin's Exposed on top of Vert.x Reactive SQL Client.
Asynchronous interface around a JDBC datasource.
Doing typesafe, asynchronous SQL and generate code using jOOQ.
Leverages the power of typesafe SQL from `jOOQ DSL` and uses the reactive and non-blocking SQL driver from Vert.x.
Asynchronous client for Marklogic Database Server.
An asynchronous client for interacting with a MongoDB database.
Pure functional and reactive MongoDB client on top of Vert.x Effect. Full support for retry, fallback and recovery operations.
Asynchronous Client for MySQL/PostgreSQL.
Non-blocking OrientDB server integration.
Reactive PostgreSQL Client.
High performance reactive SQL client.
Asynchronous API to interact with Redis.
Non-blocking Firestore SDK written in a reactive way.
Non-blocking SirixDB HTTP-server.
A Vert.x client for tapping into MySQL replication stream.
Non-blocking POJO mapping for MySQL and MongoDB.
Proven and opinionated programming, and configuration model for Java and Vert.x based applications. Inspired from ATG Nucleus, provides powerful layer base configuration management using simple properties file.
QBit works with Spring DI and Spring Boot (and of course Vert.x). Allows you to use QBit, Vert.x, Spring DI and Spring Boot in the same application.
Vert.x verticle factory for Spring DI injection.
Inject Vert.x objects as beans into your Spring application.
Vert.x integration with Eclipse SISU DI container.
Vert.x verticle factory for Guice dependency injection.
Vert.x verticle factory for HK2 dependency injection.
A Vert.x Verticle Factory that makes use of Spring to obtain and configure Verticles.
OpenAPI Generator allows generation of API client libraries (SDK generation), server stubs, documentation and configuration automatically given an OpenAPI Spec (v2, v3).
A template driven Vert.x project generator for different languages and build tools.
A Visual Studio Code (polyglot) plugin for Vert.x. Also available from the Marketplace.
Allows for remote health checking in Vert.x projects.
A Maven plugin for the hot-deploy of Maven Vert.x projects.
A simple livereload server for Vert.x applications.
Allows for interaction with Vert.x from the command line.
A browser-based project starter and project templates for Vert.x applications.
High performance PMML evaluator API based on Vert.x. Supports dynamic routing configuration for multiple PMML models via JSON.
An example Vert.x for deploying to a Cloud Foundry service provider.
Yet another Event Sourcing experiment. A project exploring Vert.x to develop Event Sourcing / CQRS applications.
Step by step example with wiki description showing how to connect Vert.x and Node using event bus and service proxies.
Todo MVC backend implementation with Vert.x + Groovy + some syntactic sugar + DSL routing facilities.
A simple demo, showing how HTTP/2 can drastically improve user experience when a huge latency is involved.
An example application on how to use Reactive Extensions Vert.x with Knative.
Kotlin implementation of the Todo MVC backend.
Scala implementation of the Todo MVC backend.
REST API Starter and Project Template ready to deploy with lots of plumbing code, examples, and documentation to quickly develope an API with almost no knowledge of vert.x and without any waste of time.
The official Vert.x blueprint showing how to build a distributed job processing application.
The official Vert.x blueprint showing how to build a complex microservice application.
The official Vert.x blueprint showing how to build a backend for a TODO application.
The official Vert.x examples including web examples, how to use the official database clients, etc.
Example of an RSS aggregator built using Vert.x, Gradle, MongoDB, Redis, Handlebars templates, AngularJS, the event bus and SockJS.
Example on how to build a template-based web server with Gentics Mesh and handlebars.
Java 8 starter application with example of using Vert.x with Gradle build system, profiles configuration and SLF4J.
Example on how to use service-proxy with Gradle.
An example application on how to build Vert.x applications with RxJava.
A starter to build a monolithic CRUD RESTful Web Service with Vert.x stack and PostgreSQL.
Pure Java 8 implementation of the Todo MVC backend. Uses a Vert.x LocalMap for storage.
Interact with AMQP 1.0 servers using the Vert.x Producer and Consumer APIs.
Bridge for sending/receiving messages to/from Apache Kafka using the AMQP 1.0 protocol.
Azure ServiceBus producer and consumer (fully async, doesn't use Microsoft Azure SDK).
Bosun client library for Vert.x.
Send and receive CloudEvents using the Vert.x HTTP Transport for CloudEvents.
Metrics implementation using DropWizard metrics.
Hawkular implementation of the Vert.x Metrics SPI.
Emits metrics for Hystrix Dashboard from a Vert.x application with Hystrix.
Java Connector Architecture Adaptor for the Vert.x event bus.
Java Easy SSE. A simple, lightweight implementation of SSE.
Kafka client for consuming and producing messages.
A Kafka client.
Meteor integration support through Vert.x event bus.
Metrics implementation using Micrometer metrics.
Provides two different components: an MQTT server for handling all the MQTT communication and messages exchanges with clients and an MQTT client for sending and receiving messages against an MQTT broker.
Send push notifications to (mobile/web) apps from your Vert.x application with OneSignal.
OpenAPI 3 request validator and router factory alternative.
OpenTsDb metrics client for Vert.x.
A RabbitMQ client (AMQP 0.9.1).
A highly scalable adapter for Retrofit with Vert.x.
A bi-directional bridge between the SaltStack event system and the Vert.x event bus.
Async SMTP client.
A Kafka client and server.
An asynchronous RabbitMQ (AMQP) client based on Kotlin coroutines.
Dart integration for Vert.x SockJS bridge and plain SockJS with use of dart:js.
Pure functional and reactive HTTP client using Vert.x Effect with OAuth support and retry, fallback and recovery operations.
Apache Kafka client for reading and sending messages from/to an Apache Kafka cluster.
TFTP client for Vert.x support download/upload files.
SMTP server bridging to EventBus.
Vert.x SSE implementation + event-bus SSE bridge.
A WAMP broker you can embed into your Vert.x application.
Brings the CDI programming model into the Vert.x ecosystem (register CDI observer methods as Vert.x message consumers, CDI-powered Verticles, define routes in a declarative way, etc.).
ZeroMQ Event Bus bridge.
Ceylon support.
EcmaScript >=6 (JavaScript) support.
Syntactic sugar + utilities (DSL builders, etc.) on top of vertx-lang-groovy.
Groovy support.
Vert.x main repository (including the Java API).
JavaScript support.
Kotlin support.
Php support.
Python support.
Ruby support.
Scala support.
ServiceComb Java Chassis is a Software Development Kit (SDK) for rapid development of microservices in Java, providing service registration, service discovery, dynamic routing, and service management features.
A toolkit for creating autonomous services. An architecture that leverages vert.x and nannoq-tools to provide an event-based reactive architecure without centralized components, neither for communication or data, providing a theoretically linear scalability across the architecture.
Vert.x Circuit Breaker.
Failsafe is a lightweight, *zero-dependency* library for handling failures in Java 8+. Concise API. Integration with libraries that use their own schedulers for async executions, such as Akka or Vert.x. Vert.x example
Resilience4j is a fault tolerance library designed for Java8 and functional programming. Resilience4j provides modules for Circuit Breaking, Rate Limiting, Bulkheading, Automatic retrying, Response caching and Metric measuring.
Vert.x Service Discovery.
Consul extension to Vert.x Service Discovery.
Docker extension to Vert.x Service Discovery.
Kubernetes extension to Vert.x Service Discovery.
Redis storage backend for Vert.x Service Discovery.
SmallRye Fault Tolerance is an implementation of Eclipse MicroProfile Fault Tolerance with additional features not defined by the specification. Native support of Vert.x and Mutiny.
GraphQL service discovery and querying for your Vert.x microservices.
Apache Camel component for bridging Camel with the Vert.x event bus.
Vert.x and Glue based microservice framework removing distinction between standalone and serveless application. All services can run in standalone server, but, if required, same codebase can be used to run any service as serverless application.
Middleware library based on Vert.x to build advanced JSON/REST communication servers.
An OSS API Platform including an API Gateway and an OAuth2 / OIDC authorization server based on Vert.x Core / Vert.x Web and other modules.
Generalized Diffie-Hellman key exchange Java library built on top of Vert.x.
An OpenStack Swift compatible distributed object storage server that can serve and securely store billions of large and small files using minimal resources implemented using Vert.x.
Deploying verticles from a HOCON configuration.
Spawn child process from Vert.x.
A highly scalable redis-persistent queuing system for Vert.x.
Send immutable and persistent JSON from json-values across the event bus.
Vert.x support for Kotlin coroutines.
Async typed actor-like lib that runs easily in Vert.x Async Callbacks. Callback management.
Vert.x Reactive Streams.
Intuitive event-driven reactive programming library for Java with bindings for Vert.x.
Pure functional and reactive library based on the IO Monad to implement any complex flow. Full support for retry, fallback and recovery operations.
Vert.x Reactive Extensions.
Vert.x fiber support.
Light weight promises & latches for Vert.x.
Utility library for Vert.X that allows using strong-typed interfaces in communication through EventBus.
Vert.x integration with Eclipse SISU DI container offering alternatives for `vertx-service-factory` and `vertx-maven-service-factory`.
Vert.x HTTP Service Factory.
Maven Vert.x Service Factory.
Vert.x Node.js Service Factory.
Vert.x Service Factory.
Time scheduler working on Vert.x event bus allowing for scheduling with *cron-style* and *interval* timers.
Mapped Diagnostic Context (MDC) that works with the Vert.x event-loop model.
Nannoq-Tools is a toolkit for constructing robust, scalable and distributed applications leveraging Vert.x including modules for authentication, cluster management, Firebase Cloud Messaging, DynamoDB, fully generic queries, REST, and more.
Portage of caolan/async nodejs module to Vert.x framework that provides helpers methods for common async patterns.
Schedule events with cron specifications. Has event bus and Observable versions.
An abstraction of cron-utils for the vertx scheduler. Unix, Cron4j and Quartz style expressions are supported.
Java port of Facebook Dataloader for Vert.x. Efficient batching and caching for your data layer.
A Vert.x Verticle intended to deploy verticles and their dependent verticles.
A route handler and Vert.x compatible interfaces to handle GraphQL queries in Vert.x and Vert.x Web.
JSON to JSON transformation tool based on the original bazaarvoice JOLT project. Helpful to transform different json structure into an expected json format.
A very basic implementation of JsonPath using Vert.x’s JsonObject and JsonArray, mimicking their getX, containsKey, put and remove methods.
Allows for mapping between standard JSON configuration and a (type-safe) configuration Java bean. Also allows the configuration bean to be validated through JSR 303.
A lightweight plugable scheduler based on plain Vert.x core without any external libs for scheduling with *cron-style* and *interval* timers with a detail *monitor* on both sync and async task.
A collection of Vert.x utility methods.
Just a simple handler to be used in Vert.x Web to generate access logs.
Event bus client for C99 using the TCP-based protocol.
Event bus client for C# using the TCP-based protocol.
C++11 event bus client.
Command-line binary client for Vert.x event bus - pipe in JSON, emit JSON.
Event bus support for Elixir apps using TCP socket.
Event bus client for Go-lang using the TCP-based protocol.
Java implementation of vertxbus.js.
Java and Android Event Bus Client.
Simple Java Event Bus Client using plain TCP socket I/O.
Event bus support in JavaScript through Java code.
JavaScript event bus client.
Event bus client for Python using the TCP-based protocol.
Event bus client for Rust applications through TCP.
Event bus client for Pharo Smalltalk using the TCP-based protocol.
Event bus client for Apple's Swift using the TCP-based protocol.
Realtime Client Server Framework for the JVM, supporting WebSockets and Server Sent Events with Cross-Browser Fallbacks.
Cloudopt Next is a very lightweight and modern, JVM-based, full stack kotlin framework designed for building modular, easily testable JVM applications with support for Java, Kotlin language, crafted from the best of breed Java libraries and standards.
Modern Clojure HTTP server and client built for ease of use and performance.
Open web framework for Vert.x.
Annotations-based configuration for Vert.x Web, with a controller framework and expressive APIs for REST.
A rack compatible Ruby HTTP server built on Vert.x 3.
Efficient & high-performance integration platform for modern websites built on Vert.x 3.
Invisible REST framework for Kotlin + Vert.x Web.
REST and WebSocket method call marshaling and reactive library.
Lightweight JAX-RS (RestEasy) like annotation processor for Vert.x verticals.
An open and easy-to-use web framework, most functions are based on annotations.
Allows you to quickly and easily set up a Vert.x-powered server using only route handler annotations.
Create JAX-RS Jersey resources in Vert.x.
Run Vaadin applications on Vert.x.
Full featured web toolkit for Vert.x.
Abstraction over resteasy-vertx to simplify writing a Vert.x REST application based on JAX-RS annotations.
Persistence for REST resources in the filesystem or a redis database.