pulsar - Fibers, Channels and Actors for Clojure

---

Pulsar wraps the Quasar library with a Clojure API that's very similar to Erlang.Java 7 and up and Clojure 1.5 and up are required to run Pulsar.

fibers actors jvm concurrency

Orbit - Build Distributed and Scalable Online Services in JVM languages

---

Orbit is a modern framework for JVM languages that makes it easier to build and maintain distributed and scalable online services. It helps to write distributed systems using virtual actors.

concurrency distributed scalable framework java-framework

Eta - A powerful language for building scalable systems on the JVM

---

Eta is a pure, lazy, strongly typed functional programming language on the JVM. It is a dialect of Haskell on the JVM. It is pure by default which means that calling a function with the same arguments will yield the same results every time. It is lazy by default which means that data stays in unevaluated state until a function needs to peek inside.

programming-language functional-language jvm-language concurrency functional-programming

Akka - Build Concurrent and Scalable Applications

---

Akka is the platform for the next generation event-driven, scalable and fault-tolerant architectures on the JVM. It helps to write simpler correct concurrent applications using Actors, STM & Transactors. It could scale out on multi-core or multiple nodes using asynchronous message passing. For fault-tolerance it adopts the Let it crash or Embrace failure model to build applications that self-heals, systems that never stop.

concurrency scalable fault-tolerance event-driven parallelism messaging high-availability

akka - Build highly concurrent, distributed, and resilient message-driven applications on the JVM

---

We believe that writing correct concurrent & distributed, resilient and elastic applications is too hard. Most of the time it's because we are using the wrong tools and the wrong level of abstraction. Akka is here to change that.

reactive distributed-systems concurrency high-performance akka actor-model distributed-actors

Venice - Coroutines, structured concurrency and CSP for Swift on macOS and Linux.

---

Venice provides structured concurrency and CSP for Swift.Venice wraps a fork of the C library libdill.

coroutines venice server-side-swift server csp swift swiftpm structured-concurrency green-threads fibers performance synchronous non-blocking

JCTools - Java Concurrency Tools for the JVM

---

Java Concurrency Tools for the JVM. This project aims to offer some concurrent data structures currently missing from the JDK.

concurrency data-structures queues lock-free wait-free awesome collections java-collection data-structure

Zewo - Lightweight library for web server applications in Swift on macOS and Linux powered by coroutines

---

Zewo is a lightweight library for web applications in Swift.Zewo is not a web framework. Zewo is a lightweight library for web applications in Swift. Most server-side Swift projects use Grand Central Dispatch (GCD) as the concurrency library of choice. The drawback of using GCD is that its APIs are asynchronous. With async code comes callback hell and we all know it, it's no fun.

swift coroutines synchronous-apis server-side-swift zewo swiftenv concurrency xcode heroku swiftpm slack buildpack non-blocking fibers green-threads

quasar-play - Quasar Framework Showcase App http://quasar-framework.org

---

Quasar Framework Showcase webiste/app; Used on official documentation too. Currently only on Google Play BUT way outdated (uses very old Quasar v0.13). Requiring funding to pay fees on Apple Store and release the iOS counterpart too. Help here.

quasar-framework quasar-play vuejs

quasar - Quasar Framework

---

Build responsive Single Page Apps, SSR Apps, PWAs, Hybrid Mobile Apps and Electron Apps, all using the same codebase!, powered with Vue. Quasar Framework is an MIT-licensed open source project. Its ongoing development is made possible thanks to the support by these awesome backers. If you'd like to join them, check out Quasar Framework's Patreon campaign.

quasar-framework vuejs vuejs2 vue vue-component ios android electron material vue-components material-theme material-design material-components vue2 pwa quasar js phone tablet desktop spa website

Gpars - Groovy parallel systems

---

Gpars is a framework which provides straightforward Java or Groovy-based APIs to declare, which parts of the code should be performed in parallel. Collections can have their elements processed concurrently, closures can be turned into composable asynchronous functions and run in the background on your behalf, mutable data can be protected by agents or software transactional memory.

concurrency scalable event-driven parallelism messaging

JRuby - The Ruby Programming Language on the JVM

---

JRuby is an implementation of the Ruby language using the JVM. It aims to be a complete, correct and fast implementation of Ruby, at the same time as providing powerful new features such as concurrency without a global-interpreter-lock, true parallelism, and tight integration to the Java language to allow you to use Java classes in your Ruby program and to allow JRuby to be embedded into a Java application.

programming-language jvm-language language

ea-async - EA Async implements async-await methods in the JVM.

---

EA Async implements async-await methods in the JVM. It allows programmers to write asynchronous code in a sequential fashion.

async async-await ea-async concurrency asynchronous jvm

frdomain - Code repo for Functional and Reactive Domain Modeling

---

Code repo for Functional and Reactive Domain Modeling.Functional and Reactive Domain Modeling teaches you how to think of the domain model in terms of pure functions and how to compose them to build larger abstractions. You will start with the basics of functional programming and gradually progress to the advanced concepts and patterns that you need to know to implement complex domain models. The book demonstrates how advanced FP patterns like algebraic data types, typeclass based design, and isolation of side-effects can make your model compose for readability and verifiability. On the subject of reactive modeling, the book focuses on higher order concurrency patterns like actors and futures. It uses the Akka framework as the reference implementation and demonstrates how advanced architectural patterns like event sourcing and CQRS can be put to great use in implementing scalable models. You will learn techniques that are radically different from the standard RDBMS based applications that are based on mutation of records. You'll also pick up important patterns like using asynchronous messaging for interaction based on non blocking concurrency and model persistence, which delivers the speed of in-memory processing along with suitable guarantees of reliability.

orleans - Orleans - Distributed Virtual Actor Model

---

Orleans is a framework that provides a straight-forward approach to building distributed high-scale computing applications, without the need to learn and apply complex concurrency or other scaling patterns.It was created by Microsoft Research implementing the Virtual Actor Model and designed for use in the cloud.

actor-model distributed-actors distributed-systems cloud-computing scalability reactive concurrency orleans

avout - Avout: Distributed State in Clojure

---

Avout brings Clojure's in-memory model of state to distributed application development by providing a distributed implementation of Clojure's Multiversion Concurrency Control (MVCC) STM along with distributable, durable, and extendable versions of Clojure's Atom and Ref concurrency primitives. Avout enables techniques that require synchronous, coordinated (i.e. transactional) management of distributed state (see also JavaSpaces), complementing approaches that focus on asynchronous, uncoordinated communication between distributed components, e.g. message queues (0MQ, RabbitMQ, HornetQ), event-driven approaches (Netty, Aleph), and actors (Erlang, Akka).

yew - Rust framework for building client web apps

---

Yew is a modern Rust framework inspired by Elm and ReactJS for creating multi-threaded frontend apps with WebAssembly. NEW! The framework supports multi-threading & concurrency out of the box. It uses Web Workers API to spawn actors (agents) in separate threads and uses a local scheduler attached to a thread for concurrent tasks.

web gui jsx elm web-framework wasm asmjs emscripten concurrency multithreading webworkers

node-fibers - Fiber/coroutine support for v8 and node.

---

Fibers, sometimes called coroutines, are a powerful tool which expose an API to jump between multiple call stacks from within a single thread. This can be useful to make code written for a synchronous library play nicely in an asynchronous environment. Note: node-fibers uses node-gyp for building. To manually invoke the build process, you can use node-gyp rebuild. This will put the compiled extension in build/Release/fibers.node. However, when you do require('fibers'), it will expect the module to be in, for example, bin/linux-x64-v8-3.11/fibers.node. You can manually put the module here every time you build, or you can use the included build script. Either npm install or node build -f will do this for you. If you are going to be hacking on node-fibers, it may be worthwhile to first do node-gyp configure and then for subsequent rebuilds you can just do node-gyp build which will be faster than a full npm install or node-gyp rebuild.

fiber fibers coroutine thread async parallel worker future promise

comsat - Fibers and actors for web development

---

The full testsuite can be run with gradle build.A Gradle template project and a Maven archetype using various integration modules and featuring setup with both Dropwizard and standalone Tomcat are also available for jumpstart and study. Both have a without-comsat branch which is useful to clearly see the (minimal, if any) porting effort required (branches comparison works very well for this purporse).

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

---

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.

reactive reactive-programming asynchronous events async streaming