Displaying 1 to 20 from 38 results

Seastar - High performance server-side application framework

SeaStar is an event-driven framework allowing you to write non-blocking, asynchronous code in a relatively straightforward manner. It is based on futures. Seastar is the first framework to bring together a set of extreme architectural innovations, including Shared-nothing design, High-performance networking, Futures and promises, Message passing etc.

swoole-src - Event-driven asynchronous & concurrent & coroutine networking engine with high performance for PHP

Swoole is an event-driven asynchronous & concurrent networking communication framework with high performance written only in C for PHP.The network layer in Swoole is event-based and takes full advantage of the underlaying epoll/kqueue implementation, making it really easy to serve thousands of connections.

Twisted - Networking Engine in Python

Twisted is an event-driven networking engine written in Python. Twisted makes it easy to implement custom network applications, both servers and clients. It also supports many common network protocols, including SMTP, POP3, IMAP, SSHv2, DNS and lot more. The twisted.web webserver is a scalable, small-footprint web server that's easy to configure. It's efficient enough to serve a high-traffic website.

P - The P programming language.

P is a language for asynchronous event-driven programming. P allows the programmer to specify the system as a collection of interacting state machines, which communicate with each other using events. P unifies modeling and programming into one activity for the programmer. Not only can a P program be compiled into executable code, but it can also be validated using systematic testing. P has been used to implement and validate the USB device driver stack that ships with Microsoft Windows 8 and Windows Phone. P is also suitable for the design and implementation of networked, embedded, and distributed systems.Check the P manual.

libevent - an event notification library

The libevent API provides a mechanism to execute a callback function when a specific event occurs on a file descriptor or after a timeout has been reached. It is meant to replace the asynchronous event loop found in event-driven network servers.

Netty - Event-driven Asynchronous Network Application Framework

Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients. Netty is a NIO client server framework which enables quick and easy development of network applications such as protocol servers and clients. It greatly simplifies and streamlines network programming such as TCP and UDP socket server.

event-gateway - The Event Gateway combines both API Gateway and Pub/Sub functionality into a single event-driven experience

Use the Event Gateway right now, by running the Event Gateway Example Application locally, with the Serverless Framework. The Event Gateway is a L7 proxy and realtime dataflow engine, intended for use with Functions-as-a-Service on AWS, Azure, Google & IBM.

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

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.

Libev - High performance full-featured event loop written in C

Libev is a high-performance event loop, supporting eight event types (I/O, real time timers, wall clock timers, signals, child status changes, idle, check and prepare handlers). It uses a priority queue to manage timers and uses arrays as fundamental data structure. It has no artificial limitations on the number of watchers waiting for the same event.

mTCP - A Highly Scalable User-level TCP Stack for Multicore Systems

mTCP is a high-performance user-level TCP stack for multicore systems. Scaling the performance of short TCP connections is fundamentally challenging due to inefficiencies in the kernel. mTCP addresses these inefficiencies from the ground up - from packet I/O and TCP connection management all the way to the application interface. It translates expensive system calls to shared memory access between two threads within the same CPU core.

Lighttpd - Webserver optimized for speed

Lighttpd powers several popular Web 2.0 sites like YouTube, wikipedia and meebo. Its high speed io-infrastructure allows them to scale several times better with the same hardware than with alternative web-servers. Its features include small memory footprint, FastCGI, Output-Compression, URL-Rewriting and lot more. Its event-driven architecture is optimized for a large number of parallel connections (keep-alive) which is important for high performance AJAX applications.

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.

Node.JS - Builds Scalable Network Programs

Node.js is a server-side JavaScript environment that uses an asynchronous event-driven model. It could handle thousands of concurrent connections. This allows Node.js to get excellent performance based on the architectures of many Internet applications. It is an evented I/O for V8, which is Google's open source JavaScript engine.

Grizzly - NIO Event Development in Java

The Grizzly NIO framework has been designed to help developers to take advantage of the Java NIO API. Grizzlys goal is to help developers to build scalable and robust servers using NIO as well as offering extended framework components: Web Framework (HTTP/S), WebSocket, Comet, and more!

Apache MINA - A network application framework

Apache MINA is a network application framework which helps users develop high performance and high scalability network applications easily. It provides an abstract, event-driven, asynchronous API over various transports such as TCP/IP and UDP/IP via Java NIO.

DotNetty - a port of netty, event-driven asynchronous network application framework

DotNetty is a port of Netty, asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.

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.

Rusty - Light-weight, user-space, event-driven and highly-scalable TCP/IP stack

Rusty is a light-weight, user-space, event-driven and highly-scalable TCP/IP stack. It has been developed to run on a EZChip TILE-Gx36 processor. Rusty is a light-weight, user-space, event-driven and highly-scalable TCP/IP stack. It has been developed to run on a EZChip TILE-Gx36 processor. Rusty takes full control of cores it runs on.

scaleApp - scaleApp is a JavaScript framework for scalable and maintainable One-Page-Applications

scaleApp is a tiny JavaScript framework for scalable and maintainable One-Page-Applications / Single-Page-Applications. The framework allows you to easily create complex web applications. You can dynamically start and stop/destroy modules that acts as small parts of your whole application.