Tokio - Platform for writing fast networking code in Rust.

  •        81

Tokio is a platform for writing fast networking code in Rust. Core I/O and event loop abstraction for asynchronous I/O in Rust built on futures and mio.

https://github.com/tokio-rs/tokio
https://tokio.rs/

Tags
Implementation
License
Platform

   




Related Projects

socket - Async, streaming plaintext TCP/IP and secure TLS socket server and client connections for ReactPHP

  •    PHP

Async, streaming plaintext TCP/IP and secure TLS socket server and client connections for ReactPHP. The socket library provides re-usable interfaces for a socket-layer server and client based on the EventLoop and Stream components. Its server component allows you to build networking servers that accept incoming connections from networking clients (such as an HTTP server). Its client component allows you to build networking clients that establish outgoing connections to networking servers (such as an HTTP or database client). This library provides async, streaming means for all of this, so you can handle multiple concurrent connections without blocking.

libuv - Cross platform Asynchronous I/O

  •    C

libuv is a multi-platform support library with a focus on asynchronous I/O. It was primarily developed for use by Node.js, but it’s also used by Luvit, Julia, pyuv, and others. Its feature includes event loop backed by epoll, kqueue, IOCP, event ports. Asynchronous TCP and UDP sockets, Asynchronous DNS resolution, Thread pool, Signal handling and lot more.

Seastar - High performance server-side application framework

  •    C++

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.

nanomsg - High Performance Messaging Library

  •    C

The nanomsg library is a simple high-performance implementation of several "scalability protocols". These scalability protocols are light-weight messaging protocols which can be used to solve a number of very common messaging patterns, such as request/reply, publish/subscribe, surveyor/respondent, and so forth. These protocols can run over a variety of transports such as TCP, UNIX sockets, and even WebSocket. It aims to make the networking layer fast, scalable, and easy to use.

tornado - Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed

  •    Python

Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed. By using non-blocking network I/O, Tornado can scale to tens of thousands of open connections, making it ideal for long polling, WebSockets, and other applications that require a long-lived connection to each user. This example does not use any of Tornado's asynchronous features; for that see this simple chat room.


Fast-Android-Networking - 🚀 A Complete Fast Android Networking Library that also supports HTTP/2 🚀

  •    Java

Fast Android Networking Library is a powerful library for doing any type of networking in Android applications which is made on top of OkHttp Networking Layer. Fast Android Networking Library takes care of each and everything. So you don't have to do anything, just make request and listen for the response.

tokio-core - I/O primitives and event loop for async I/O in Rust

  •    Rust

Core I/O and event loop abstraction for asynchronous I/O in Rust built on futures and mio.You can find extensive documentation and examples about how to use this crate online at https://tokio.rs as well as the examples folder in this repository. The API documentation is also a great place to get started for the nitty-gritty.

LibTML Messaging Suite - Network Messaging Library in C++

  •    C++

TML Messaging Suite is a network messaging library for rapid development of extensible and scalable interfaces. Based on the peer to peer standard protocol BEEP (Blocks Extensible Exchange Protocol), defined in RFC3080 and RFC3081 libTML is suitable for many use cases and communication patterns. The libtml-c project is a C++ implementation of a library with a C interface on top of the Vortex beepcore.

Twisted - Networking Engine in Python

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

Networking - Easy HTTP Networking in Swift a NSURLSession wrapper with image caching support

  •    Swift

Networking was born out of the necessity of having a simple networking library that doesn't have crazy programming abstractions or uses the latest reactive programming techniques, but just a plain, simple and convenient wrapper around NSURLSession that supports common needs such as faking requests and caching images out of the box. A library that is small enough to read in one go but useful enough to include in any project. That's how Networking came to life, a fully tested library for iOS, tvOS, watchOS and OS X that will always be there for you. Initializing an instance of Networking means you have to select a NSURLSessionConfiguration. The available types are Default, Ephemeral and Background, if you don't provide any or don't have special needs then Default will be used.

libsourcey - C++14 evented IO libraries for high performance networking and media based applications

  •    C++

LibSourcey is a collection of cross platform C++14 modules and classes that provide developers with an arsenal for rapidly developing high performance network based p2p and media streaming applications. Think of it as the power and performance of libuv combined with the features of FFmpeg, OpenCV and WebRTC, all integrated with the ease and readability of the stl (C++ Standard Library). Event-based IO — Core modules are built on top of libuv (the underlying C library that powers nodejs) and use event-based asynchronous IO throughout to maximize performance and minimize concurrency reliance for building mission critical native and server side apps.

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.

beast - HTTP and WebSocket built on Boost.Asio in C++11

  •    C++

Beast is a C++ header-only library serving as a foundation for writing interoperable networking libraries by providing low-level HTTP/1, WebSocket, and networking protocol vocabulary types and algorithms using the consistent asynchronous model of Boost.Asio. Symmetry: Algorithms are role-agnostic; build clients, servers, or both.

dyad - Asynchronous networking for C

  •    C

Dyad.c is an asynchronous networking library which aims to be lightweight, portable and easy to use. It can be used both to create small standalone servers and to provide network support to existing projects. The dyad.c and dyad.h files can be dropped into an existing project; if you're using Windows you will also have to link to ws2_32.

mioco

  •    Rust

This is repository for mioco before version 0.9. It's hear for historical reasons, while I've started reworking mioco in the original location: https://github.com/dpc/mioco . Sorry for all the confusion. Rust community decided that futures should be main Rust async IO story, so you might want to look at tokio-fiber: coroutines as Futures project, which should have mioco-like API and allow easily porting code using mioco.

tokio-proto - A network application framework for Rust

  •    Rust

tokio-proto makes it easy to implement clients and servers for request / response oriented protocols. It takes a transport and provides the request / response API. It is a part of the Tokio platform.You can find extensive examples and tutorials at https://tokio.rs.

Packet Rush Networking Framework

  •    

The Packet Rush Networking Framework (PRNF) provides a client/server networking layer that abstracts away from the underlying communication mechanism such as UDP or TCP.

linkerd-tcp - A TCP/TLS load balancer for the linkerd service mesh.

  •    Rust

A TCP load balancer for the linkerd service mesh.We ❤️ pull requests! See CONTRIBUTING.md for info on contributing changes.

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

  •    Swift

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.

nano - Lightweight, facility, high performance golang based game server framework

  •    Go

Nano is an easy to use, fast, lightweight game server networking library for Go. It provides a core network architecture and a series of tools and libraries that can help developers eliminate boring duplicate work for common underlying logic. The goal of nano is to improve development efficiency by eliminating the need to spend time on repetitious network related programming.Nano was designed for server-side applications like real-time games, social games, mobile games, etc of all sizes.





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.