Vue is a progressive framework for building user interfaces. Unlike other monolithic frameworks, Vue is designed from the ground up to be incrementally adoptable. The core library is focused on the view layer only, and is easy to pick up and integrate with other libraries or existing projects.

Vue.js - The Progressive JavaScript Framework 

It's a JavaScript library for building reactive user interfaces in a way that doesn't force you into a particular framework's way of thinking. It takes a radically different approach to DOM manipulation - one that saves both you and the browser unnecessary work. Features include...
<ul>
<li>Data-binding, with a beautiful declarative syntax.</li>
<li>Event handling that doesn't make you tear your hair out.</li>
<li>Flexible and performant animations and transitions.</li>
<li>And much more!</li>
</ul>

It's a JavaScript library for building reactive user interfaces in a way that doesn't force you into a particular framework's way of thinking. It takes a radically different approach to DOM manipulation - one that saves both you and the browser unnecessary work.

Ractive - Next-generation DOM manipulation

A lightweight wrapper around SQLiteOpenHelper and ContentResolver which introduces reactive stream semantics to queries. SQL Brite's only responsibility is to be a mechanism for coordinating and composing the notification of updates to tables such that you can update queries as soon as data changes. This library is not an ORM. It is not a type-safe query mechanism. It won't serialize the same POJOs you use for Gson. It's not going to perform database migrations for you.

Sqlbrite - A lightweight wrapper around SQLiteOpenHelper which introduces reactive stream semantics to SQL operations

The Akka HTTP modules implement a full server- and client-side HTTP stack on top of akka-actor and akka-stream. It's not a web-framework but rather a more general toolkit for providing and consuming HTTP-based services. While interaction with a browser is of course also in scope it is not the primary focus of Akka HTTP. 
 
Akka HTTP follows a rather open design and many times offers several different API levels for "doing the same thing". You get to pick the API level of abstraction that is most suitable for your application. This means that, if you have trouble achieving something using a high-level API, there's a good chance that you can get it done with a low-level API, which offers more flexibility but might require you to write more application code.

The Akka HTTP modules implement a full server- and client-side HTTP stack on top of akka-actor and akka-stream. It's not a web-framework but rather a more general toolkit for providing and consuming HTTP-based services. While interaction with a browser is of course also in scope it is not the primary focus of Akka HTTP. 

Akka HTTP - The Streaming-first HTTP server/module of Akka

EventMachine is an event-driven I/O and lightweight concurrency library for Ruby. It provides event-driven I/O using the Reactor pattern, much like JBoss Netty, Apache MINA, Python's Twisted, Node.js, libevent and libev.

EventMachine - Fast, simple event-processing library for Ruby programs

Reactor is a fourth-generation Reactive library for building non-blocking applications on the JVM based on the Reactive Streams Specification.  Reactor is a fully non-blocking foundation with efficient demand management. It directly interacts with Java functional API, Completable Future, Stream and Duration. Reactor Operators and Schedulers can sustain high throughput rates on the order of 10's of millions of messages per second.

Project Reactor -  Create efficient Reactive systems

Quarkus is a Cloud Native, Container First framework for writing Java applications. A Kubernetes Native Java stack tailored for GraalVM &amp; OpenJDK HotSpot, crafted from the best of breed Java libraries and standards. Quarkus tailors your application for GraalVM and HotSpot. Amazingly fast boot time, incredibly low RSS memory (not just heap size!) offering near instant scale up and high density memory utilization in container orchestration platforms like Kubernetes. It allows developers to automatically generate Kubernetes resources including building and deploying container images without having to manually create YAML files.
Quarkus is based on a&nbsp;<a href="https://quarkus.io/version/main/guides/quarkus-reactive-architecture" target="_blank" rel="noopener">reactive core</a> allowing your application to mix reactive and imperative components. It helps to compose asynchronous operations and complete the result when everything is done without blocking the I/O threads using <a href="https://quarkus.io/version/main/guides/mutiny-primer" target="_blank" rel="noopener">Mutiny Reactive API</a>.&nbsp;&nbsp;

Quarkus is a Cloud Native, Container First framework for writing Java applications. A Kubernetes Native Java stack tailored for GraalVM & OpenJDK HotSpot, crafted from the best of breed Java libraries and standards. Quarkus tailors your application for GraalVM and HotSpot. Amazingly fast boot time, incredibly low RSS memory (not just heap size!) offering near instant scale up and high density memory utilization in container orchestration platforms like Kubernetes. 

Quarkus - Supersonic Subatomic Java

Vert.x is a tool-kit for building reactive applications on the JVM. Vert.x is event driven and non blocking. This means your app can handle a lot of concurrency using a small number of kernel threads. Vert.x lets your app scale with minimal hardware.Vert.x is incredibly flexible - whether it's simple network utilities, sophisticated modern web applications, HTTP/REST microservices, high volume event processing or a full blown back-end message-bus application.

Vert.x - Tool-kit for building reactive applications on the JVM

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences. It extends the observer pattern to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures.

RxJava - Reactive Extensions for the JVM

Functional enables “predictable” code, and Reactive enables “separated” code. Cycle.js apps are made of pure functions, which means you know they only take inputs and generate predictable outputs, without performing any I/O effects. The building blocks are reactive streams from libraries like xstream, RxJS or Most.js, which greatly simplify code related to events, asynchrony, and errors.

Cyclejs - A functional and reactive JavaScript framework for predictable code

RxDB is a realtime Database for the Web. It is reactive data-handling based on RxJS. It helps App to work even without internet. It supports Mango-Query, Encryption, Import/Export of database and lot more.

RxDB - A realtime Database for the Web

MobX is a battle tested, simple and scalable state management library transparently applying functional reactive programming (TFRP). The Mobx design principle is very simple: Anything that can be derived from the application state, should be derived. Automatically. This includes the UI, data serialization, server communication, etc.

MobX - Simple, scalable state management.

The Alpakka project is an open source initiative to implement stream-aware, reactive, integration pipelines for Java and Scala. It is built on top of Akka Streams, and has been designed from the ground up to understand streaming natively and provide a DSL for reactive and stream-oriented programming, with built-in support for backpressure. Akka Streams is a Reactive Streams and JDK 9+ java.util.concurrent.Flow-compliant implementation and therefore fully interoperable with other implementations.

Alpakka Kafka connector - Alpakka is a Reactive Enterprise Integration library for Java and Scala, based on Reactive Streams and Akka

A webapp for experimenting with diagrams of Rx Observables, for learning purposes. This is a Cycle.js app. It helps to visualize example diagrams for each operator in Rx. Drag an item ("marble") on an Observable to see how the operator reacts.



RxJs Marbles-  Interactive diagrams of Rx Observables

Helidon is a collection of Java libraries for writing microservices that run on a fast web core powered by Netty. It supports MicroProfile and provides familiar APIs like JAX-RS, CDI and JSON-P/B. Our MicroProfile implementation runs on fast Helidon Reactive WebServer. It can easily integrate with Prometheus, Jaeger/Zipkin and Kubernetes.

Helidon - Java libraries for writing Microservices

Discover open source projects across all platforms

Projects