Lightning - A Swift Multiplatform Single-threaded Non-blocking Web and Networking Framework

  •        71

Lightning is an HTTP Server and TCP Client/Server framework written in Swift and inspired by Node.js. It runs on both OS X and Linux. Like Node.js, Lightning uses an event-driven, non-blocking I/O model. In the same way that Node.js uses libuv to implement this model, Lightning uses libdispatch. This makes Lightning fast, efficient, and most crutially single-threaded by default. You simply do not need to worry about locks/mutexes/semaphores/etc if you have server-side state. Of course, Lightning applications can make use of libdispatch to easily offload heavy processing to a background thread if necessary.

https://github.com/skylab-inc/Lightning

Tags
Implementation
License
Platform

   




Related Projects

message-io - Fast and easy-to-use event-driven network library.

  •    Rust

message-io is a fast and easy-to-use event-driven network library. The library handles the OS socket internally and offers a simple event message API to the user. It also allows you to make an adapter for your own transport protocol following some rules, delegating the tedious asynchrony and thread management to the library. Managing sockets is hard because you need to fight with threads, concurrency, full duplex, encoding, IO errors that come from the OS (which are really difficult to understand in some situations), etc. If you make use of non-blocking sockets, it adds a new layer of complexity: synchronize the events that come asynchronously from the Operating System.

Redisson - Redis based In-Memory Data Grid for Java

  •    Java

Redisson - distributed Java objects and services (Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, Map Reduce, Publish / Subscribe, Bloom filter, Spring Cache, Executor service, Tomcat Session Manager, Scheduler service, JCache API) on top of Redis server. Rich Redis client.

Zio - A type-safe, composable library for async and concurrent programming in Scala

  •    Scala

ZIO is a zero-dependency Scala library for asynchronous and concurrent programming. It is powered by highly-scalable, non-blocking fibers that never waste or leak resources, ZIO lets you build scalable, resilient, and reactive applications that meet the needs of your business.

asynchbase - A fully asynchronous, non-blocking, thread-safe, high-performance HBase client.

  •    Java

A fully asynchronous, non-blocking, thread-safe, high-performance HBase client.

swift-nio - Event-driven network application framework for high performance protocol servers & clients, non-blocking

  •    Swift

SwiftNIO is a cross-platform asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients. It's like Netty, but written for Swift.


Project Reactor - Create efficient Reactive systems

  •    Java

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.

Mutiny - An Intuitive Event-Driven Reactive Programming Library for Java

  •    Java

Mutiny places events at the core of its design. With Mutiny, you observe events, react to them, and create elegant and readable processing pipelines. Mutiny is the perfect companion to tame the asynchronous nature of applications with non-blocking I/O. Declaratively compose operations, transform data, enforce progress, recover from failures and more.

elastic4s - Elasticsearch Scala Client - Non Blocking, Type Safe, HTTP, TCP

  •    Scala

Elastic4s is a concise, idiomatic, reactive, type safe Scala client for Elasticsearch. The client can be used over both HTTP and TCP by choosing either of the elastic4s-http or elastic4s-tcp submodules. The official Elasticsearch Java client can of course be used in Scala, but due to Java's syntax it is more verbose and it naturally doesn't support classes in the core Scala core library nor Scala idioms.Elastic4s's DSL allows you to construct your requests programatically, with syntactic and semantic errors manifested at compile time, and uses standard Scala futures to enable you to easily integrate into an asynchronous workflow. The aim of the DSL is that requests are written in a builder-like way, while staying broadly similar to the Java API or Rest API. Each request is an immutable object, so you can create requests and safely reuse them, or further copy them for derived requests. Because each request is strongly typed your IDE or editor can use the type information to show you what operations are available for any request type.

frdomain - Code repo for Functional and Reactive Domain Modeling

  •    Scala

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.

concurrencpp - Modern concurrency for C++

  •    C++

concurrencpp is a tasking library for C++ allowing developers to write highly concurrent applications easily and safely by using tasks, executors and coroutines. By using concurrencpp applications can break down big procedures that need to be processed asynchronously into smaller tasks that run concurrently and work in a co-operative manner to achieve the wanted result. concurrencpp also allows applications to write parallel algorithms easily by using parallel coroutines. concurrencpp is a task-centric library. A task is an asynchronous operation. Tasks offer a higher level of abstraction for concurrent code than traditional thread-centric approaches. Tasks can be chained together, meaning that tasks pass their asynchronous result from one to another, where the result of one task is used as if it were a parameter or an intermediate value of another ongoing task. Tasks allow applications to utilize available hardware resources better and scale much more than using raw threads, since tasks can be suspended, waiting for another task to produce a result, without blocking underlying OS-threads. Tasks bring much more productivity to developers by allowing them to focus more on business-logic and less on low-level concepts like thread management and inter-thread synchronization.

sockets - 🔌 Non-blocking TCP socket layer, with event-driven server and client.

  •    Swift

At the request of the original authors, we ask you to please help us make the community a better place by abiding to this Code of Conduct during your interactions surrounding this project.

reactor-core - Non-Blocking Reactive Foundation for the JVM

  •    Java

Non-Blocking Reactive Streams Foundation for the JVM both implementing a Reactive Extensions inspired API and efficient event streaming support. Reactor 3 requires Java 8 or + to run.

swift-tips - A collection useful tips for the Swift language

  •    Swift

The following is a collection of tips I find to be useful when working with the Swift language. Asynchronous functions are a great way to deal with future events without blocking a thread. Yet, there are times where we would like them to behave in exactly such a blocking way.

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

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

ReactiveMongo - Asynchronous and Non-Blocking Scala Driver for MongoDB

  •    Scala

ReactiveMongo is a scala driver that provides fully non-blocking and asynchronous I/O operations. It allows you to stream data both into and from your MongoDB servers.

Mio - Metal IO library for Rust

  •    Rust

Mio is a lightweight I/O library for Rust with a focus on adding as little overhead as possible over the OS abstractions. This is a low level library, if you are looking for something easier to get started with Tokio. Its feature include Non-blocking TCP and UDP, I/O event queue backed by epoll, kqueue, and IOCP.

Ratpack - A toolkit for JVM web applications

  •    Java

Ratpack is a set of Java libraries for building modern HTTP applications. It provides just enough for writing practical, high performance, apps. It is built on Java 8, Netty and reactive principles. It is similar to NodeJS, helps to implement non blocking HTTP apps in Java.

reactive-streams-jvm - Reactive Streams Specification for the JVM

  •    Java

The purpose of Reactive Streams is to provide a standard for asynchronous stream processing with non-blocking backpressure. Handling streams of data—especially “live” data whose volume is not predetermined—requires special care in an asynchronous system. The most prominent issue is that resource consumption needs to be carefully controlled such that a fast data source does not overwhelm the stream destination. Asynchrony is needed in order to enable the parallel use of computing resources, on collaborating network hosts or multiple CPU cores within a single machine.

Drogon - C++14/17 based HTTP Web Application Framework

  •    C++

Drogon is a C++14/17-based HTTP application framework. Drogon can be used to easily build various types of web application server programs using C++.It uses Use a non-blocking I/O network lib based on epoll high-concurrency, high-performance network IO, Completely asynchronous programming mode, HTTPS, WebSocket, Json format, gzip, brotli compression and lot more.

node-mariasql - A node.js binding to MariaDB's non-blocking (MySQL-compatible) client library

  •    C++

A node.js binding to MariaDB's non-blocking (MySQL-compatible) client library.This binding is different from a vanilla libmysqlclient binding in that it uses the non-blocking functions available in MariaDB's client library. As a result, this binding does not use multiple threads to achieve non-blocking behavior.






We have large collection of open source products. Follow the tags from Tag Cloud >>


Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.