awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
tidwall avatar

tidwall/evio

0
View on GitHub↗

Evio

Evio is a high-performance networking library for Go that provides a non-blocking socket framework. It utilizes an event loop to process TCP, UDP, and Unix domain socket traffic through a low-level asynchronous protocol interface.

The project functions as a multi-core network load balancer, distributing connections across multiple CPU cores using round-robin or least-connections strategies. It supports socket reuse, allowing multiple sockets on a single host to bind to the same port.

The library covers a broad range of socket management and packet processing capabilities, including multi-protocol listening on a single port and multi-interface serving. Performance is optimized through shared-buffer packet allocation and a callback-driven connection lifecycle to minimize memory overhead and latency.

The system also includes utilities for periodic task scheduling to trigger recurring background events or system heartbeats.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Non-Blocking Event Loops - Provides a non-blocking event loop architecture to process network traffic with minimal system overhead.
  • Event Loop Load Balancers - Distributes incoming network traffic across multiple internal event loops using round-robin or least-connections strategies.
  • Round-Robin Load Balancers - Implements a system for distributing network connections across multiple CPU cores using round-robin scheduling.
  • Connection Lifecycle Events - Implements a callback system to manage connection states and data flow during network event transitions.
  • High-Performance Networking - Designed for building scalable, low-latency network applications in Go that handle massive concurrent traffic.
  • Protocol-Agnostic Interfaces - Provides a protocol-agnostic interface for handling TCP, UDP, and Unix domain sockets via asynchronous callbacks.
  • Multi-Threaded Packet Processing - Distributes network traffic across multiple CPU cores using event loops to maximize throughput.
  • Go Event-Driven Networking Frameworks - A high-performance Go library providing a non-blocking networking framework for TCP and UDP servers.
  • Socket Event Handling - Implements a callback-driven system for processing asynchronous read, write, and error events on network sockets.
  • Non-Blocking Socket I/O - Provides a framework for non-blocking socket I/O to handle concurrent connections with minimal latency.
  • Multi-Core Scaling - Distributes network processing across multiple event loops to maximize throughput on multi-core systems.
  • Custom Protocol Implementations - Provides the low-level primitives necessary for implementing specialized network protocols with fine-grained socket control.
  • Socket Buffer Management - Manages network connection lifecycles and data buffers to reduce memory allocation and processing delays.
  • Multi-Protocol Server Implementations - Enables the creation of servers that handle both TCP and UDP traffic on a single port.
  • Network Socket Bindings - Enables listeners to bind to several network interfaces or socket types simultaneously using a single event loop.
  • Port Sharing - Supports socket reuse allowing multiple sockets on a single host to bind to the same port.
  • Socket Port Reuse - Supports socket reuse allowing multiple sockets on the same host to bind to a single port.
  • Shared Buffer Allocations - Reduces memory overhead by reusing a single input packet buffer across multiple concurrent network connections.
  • Packet Processing Frameworks - Utilizes a high-performance event loop mechanism for efficient network packet processing.
  • TCP and Unix Socket Listeners - Accepts incoming traffic through both standard TCP ports and local Unix domain sockets.
  • Connection State Management - Tracks and manages the active state and lifecycle of network connections via event outcomes.
  • Stream Buffer Allocators - Utilizes a specialized memory management strategy that shares a single input packet buffer across multiple connections.
  • Multi-Protocol Listeners - Allows a single port to listen for and handle both TCP and UDP network traffic simultaneously.
6,034 stars·494 forks·Go·MIT·23 views

Star history

Star history chart for tidwall/evioStar history chart for tidwall/evio

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Projects sharing features with Evio

These projects share indexed features with Evio. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • cloudwego/netpollcloudwego avatar

    cloudwego/netpoll

    4,583View on GitHub↗

    Netpoll is an event-driven network framework and non-blocking I/O library designed to manage concurrent TCP and Unix domain socket connections. It utilizes a non-blocking event loop to monitor file descriptors and trigger callbacks for read and write events, serving as a high-performance socket manager and TCP network poller. The framework optimizes throughput across CPU cores by distributing incoming network connections across multiple pollers. It implements zero-copy networking primitives, using linked buffers and specialized memory management to read and write data while minimizing memory

    Go
    View on GitHub↗4,583
  • panjf2000/gnetpanjf2000 avatar

    panjf2000/gnet

    11,186View on GitHub↗

    gnet is a high-performance event-driven networking framework for Go, designed for building scalable TCP, UDP, and Unix socket servers. It functions as a non-blocking socket manager and multi-reactor network engine that handles thousands of simultaneous connections with low memory overhead. The framework distinguishes itself by using a multi-reactor architecture that distributes I/O across multiple event loops pinned to operating system threads to minimize context switching. It employs edge-triggered polling to reduce system call frequency and utilizes elastic ring-buffers to minimize allocati

    Go
    View on GitHub↗11,186
  • riba2534/tcp-ip-networknoteriba2534 avatar

    riba2534/TCP-IP-NetworkNote

    2,505View on GitHub↗

    TCP-IP-NetworkNote is a comprehensive technical reference and guide for implementing network communication using TCP and UDP sockets in C and C++. It provides a detailed manual for using the POSIX socket API and covers the implementation of network protocols, synchronous and asynchronous I/O patterns, and concurrent programming models. The project is distinguished by its focus on cross-platform networking, offering a detailed comparison of socket implementation details and adaptation utilities between Linux and Windows Winsock environments. It specifically addresses the differences in header

    C
    View on GitHub↗2,505
  • apple/swift-nioapple avatar

    apple/swift-nio

    8,477View on GitHub↗

    Swift NIO is a low-level, event-driven network framework for the Swift language. It serves as an asynchronous network protocol stack and I/O library designed to build high-performance network servers and clients that handle thousands of simultaneous connections. The framework functions as a high-concurrency network engine that dispatches events across multiple CPU cores. It enables the implementation of custom network protocols by processing raw bytes through a sequence of reusable data transformation handlers. The system provides capabilities for non-blocking I/O multiplexing, asynchronous

    Swiftasynchronous-ioevent-drivenhigh-performance
    View on GitHub↗8,477
Compare all 30 related projects→

Frequently asked questions

What does tidwall/evio do?

Evio is a high-performance networking library for Go that provides a non-blocking socket framework. It utilizes an event loop to process TCP, UDP, and Unix domain socket traffic through a low-level asynchronous protocol interface.

What are the main features of tidwall/evio?

The main features of tidwall/evio are: Non-Blocking Event Loops, Event Loop Load Balancers, Round-Robin Load Balancers, Connection Lifecycle Events, High-Performance Networking, Protocol-Agnostic Interfaces, Multi-Threaded Packet Processing, Go Event-Driven Networking Frameworks.

Which projects share features with tidwall/evio?

Projects with overlapping indexed features include: cloudwego/netpoll — Netpoll is an event-driven network framework and non-blocking I/O library designed to manage concurrent TCP and Unix… panjf2000/gnet — gnet is a high-performance event-driven networking framework for Go, designed for building scalable TCP, UDP, and Unix… riba2534/tcp-ip-networknote — TCP-IP-NetworkNote is a comprehensive technical reference and guide for implementing network communication using TCP… apple/swift-nio — Swift NIO is a low-level, event-driven network framework for the Swift language. It serves as an asynchronous network… ithewei/libhv — libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP,… me-no-dev/espasyncwebserver — ESPAsyncWebServer is an asynchronous web server designed for ESP32 and ESP8266 microcontrollers. It enables these…