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

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

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

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

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

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).

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

vert.x - Vert.x is a tool-kit for building reactive applications on the JVM

---

This is the repository for Vert.x core.Vert.x core contains fairly low-level functionality, including support for HTTP, TCP, file system access, and various other features. You can use this directly in your own applications, and it's used by many of the other components of Vert.x.

vertx netty reactive jvm http2 concurrency high-performance nio non-blocking event-loop

akka.net - Port of Akka actors for .NET

---

Akka.NET is a community-driven port of the popular Java/Scala framework Akka to .NET.If you are interested in helping porting Akka to .NET please take a look at Contributing to Akka.NET.

akka actor-model concurrency cluster actor reactive distributed-programming

pykka - Pykka is a Python implementation of the actor model, which makes it easier to build concurrent applications

---

Pykka is a Python implementation of the actor model. The actor model introduces some simple rules to control the sharing of state and cooperation between execution units, which makes it easier to build concurrent applications. An actor is an execution unit that executes concurrently with other actors.

actor-model concurrency

Stact - An early actor framework for .NET, long since abandoned by me.

---

NOTE: If you are looking at the source - please run build.bat before opening the solution. It creates the SolutionVersion.cs file that is necessary for a successful build. Developing concurrent applications requires an approach that departs from current software development methods, an approach that emphasizes concurrency and communication between autonomous system components. The actor model defines a system of software components called actors that interact with each other by exchanging messages (instead of calling methods on interfaces in an object-oriented design), producing a system in which data (instead of control) flows through components to meet the functional requirements of the system.

Atomix - Scalable, fault-tolerant distributed systems protocols and primitives for the JVM

---

Atomix is an event-driven framework for coordinating fault-tolerant distributed systems built on the Raft consensus algorithm. It provides the building blocks that solve many common distributed systems problems including group membership, leader election, distributed concurrency control, partitioning, and replication.

raft consensus consensus-algorithm raft-protocol raft-consensus-algorithm distributed-systems leader-election distributed-lock data-structures

Quasar E1 interface board driver

---

I stoped driver development here. This project contains outdated version of the driver just for the reference, please visit Parabel ltd. site for the driver updates and support. Linux 2.6.x Zaptel driver for the 2,4 and 8 E1 ports Parabel Quasar E1 PCI/PMC interface board. This driver allows to use board as the hardware for the Asterisk(tm) project.