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
yedf2 avatar

yedf2/handy

0
View on GitHub↗
4,653 stars·1,323 forks·C++·BSD-2-Clause·23 views

Handy

Handy is a C++11 network server framework and event-driven networking engine designed for building high-performance concurrent TCP and UDP servers. It functions as an asynchronous I/O library and an HTTP server implementation that separates asynchronous network I/O from synchronous business logic to simplify server development.

The framework distinguishes itself by utilizing platform-specific event notifications to manage millions of simultaneous network connections and providing an SSL/TLS network wrapper for encrypted asynchronous data transmission. It implements a half-sync/half-async processing model and an event-loop-based reactor to maintain high concurrency.

The project covers a broad range of networking capabilities, including path-based HTTP routing, custom binary protocol design via codec-based message framing, and thread-safe I/O task dispatching. It also includes utilities for connection lifecycle management, timer-wheel task scheduling for timed execution, and graceful shutdown coordination.

Features

  • Reactor Pattern Event Loops - Utilizes an event-loop-based reactor pattern to handle high-concurrency network I/O and connection events.
  • Event-Driven I/O - Utilizes a system-level event loop to asynchronously monitor network I/O and trigger callbacks for millions of concurrent connections.
  • Asynchronous Networking - Employs an asynchronous networking architecture that decouples data transmission from business logic.
  • Binary Protocols - Supports custom binary protocol design using codecs for efficient data framing and serialization.
  • Event-Driven Networking - Implements an event-driven networking engine using non-blocking I/O to handle massive concurrency.
  • High-Concurrency Networking - Designed for high-concurrency networking capable of managing millions of simultaneous connections.
  • HTTP Request Routing - Maps incoming HTTP URL paths to specific handler functions to generate and send responses to web clients.
  • Message Encoders and Decoders - Implements customizable encoders and decoders to convert raw byte streams into structured network messages.
  • TCP Server Frameworks - Provides a high-performance C++11 framework for building concurrent TCP and UDP servers.
  • Asynchronous I/O Libraries - Functions as an asynchronous I/O library providing a non-blocking interface for system network operations.
  • SSL/TLS Connection Security - Integrates security libraries to provide an SSL/TLS wrapper for encrypted asynchronous data transmission.
  • Half-Sync Half-Async Patterns - Implements a half-sync/half-async processing model to decouple network I/O from business logic.
  • OS-Specific Event Notifications - Leverages low-level OS notifications like epoll and kqueue to scale to millions of concurrent connections.
  • Timed Event Scheduling - Schedules and manages tasks to execute at specific intervals or after delays using internal timers.
  • Time Wheel Schedulers - Implements a timer-wheel scheduler for managing delayed or recurring tasks with constant-time complexity.
  • Codec-Based Message Framing - Uses codecs to automatically frame incoming data into structured messages and send them over a connection.
  • C++ HTTP Server Libraries - Implements C++ HTTP server functionality including route matching and request handling.
  • Incoming Message Processors - Handles incoming data as raw reads or decoded messages using customizable codecs to simplify protocol parsing.
  • Persistent Connection Enablements - Maintains open connections to remote servers using configurable timeouts to reduce latency.
  • TCP Transport Connections - Creates managed TCP transport connections to specified hosts and ports using smart pointers for memory management.
  • Connection Configuration Interceptors - Allows intercepting the connection acceptance process to configure specific settings or state for new client connections.
  • UDP Communication - Provides tools to send and receive data using the User Datagram Protocol for fast, connectionless transmission.
  • Idle Connection Pruning - Automatically terminates inactive network sockets based on timer thresholds to reclaim system resources.
  • Secure Network Communication - Integrates encryption libraries to provide secure, encrypted data transmission through secure sockets.
  • SSL-Enabled Socket Wrappers - Provides SSL-enabled socket wrappers to encrypt TCP, UDP, and HTTP data transfers.
  • Thread-Safe Dispatchers - Provides thread-safe dispatching to route tasks from worker threads back to the IO thread.
  • Connection Context Storage - Implements mechanisms for associating persistent state and metadata with specific network connections for retrieval during event callbacks.
  • HTTP Servers - Provides a core HTTP server engine for routing web traffic and managing request-response cycles.
  • Network Communication Libraries - Concise C++11 network framework for high-concurrency servers.
  • Network Frameworks - Simple C++11 network framework for high-concurrency server development.

Star history

Star history chart for yedf2/handyStar history chart for yedf2/handy

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.

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

Projects sharing features with Handy

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

    ithewei/libhv

    7,521View on GitHub↗

    libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP, WebSocket, and MQTT clients and servers. It provides a non-blocking event loop for managing network sockets, timers, and system signals across multiple threads. The project is distinguished by its integrated support for specialized network roles, including a full HTTP web server with RESTful routing and middleware, an MQTT messaging client for IoT communication, and the ability to implement SOCKS5 and HTTP proxies. It also features a reliable UDP implementation to ensure ordered

    Ccurlepollhttp-client
    View on GitHub↗7,521
  • chenshuo/muduochenshuo avatar

    chenshuo/muduo

    16,157View on GitHub↗

    Muduo is a C++11 event-driven network library and framework designed for building high-concurrency Linux servers. It provides a toolkit for implementing scalable network services and socket communication using non-blocking I/O and asynchronous event processing. The framework implements a multi-threaded TCP server architecture that distributes connection handling across multiple CPU threads to maximize server throughput. This is achieved through a one-loop-per-thread model and a reactor pattern implementation, which dispatch network events from a central demultiplexer to registered handler fun

    C++
    View on GitHub↗16,157
  • eventmachine/eventmachineeventmachine avatar

    eventmachine/eventmachine

    4,283View on GitHub↗

    EventMachine is a reactor-pattern network framework for Ruby that provides an asynchronous I/O library for performing non-blocking network and file operations. It functions as a network server framework used to build scalable TCP and UDP servers and clients that process multiple simultaneous requests. The framework implements a concurrency model that dispatches network events to registered handlers using a single-threaded event loop. This approach allows for the management of high-concurrency network connections without the overhead of multi-threaded programming. The library covers the devel

    Ruby
    View on GitHub↗4,283
  • ldcsaa/hp-socketldcsaa avatar

    ldcsaa/HP-Socket

    6,132View on GitHub↗

    HP-Socket is a networking library for building scalable TCP, UDP, and HTTP servers and clients with event-driven I/O and SSL encryption. It provides a high-performance TCP server framework, an HTTP request handler that parses incoming requests and generates responses, and a UDP communication library for low-latency data transfer, all with optional SSL encryption for secure communication. The library is built on a completion-port-based I/O architecture that uses Windows I/O Completion Ports for scalable asynchronous socket operations. It features a connection-pooled agent architecture for mana

    Candroidccpp
    View on GitHub↗6,132
Compare all 30 related projects→

Frequently asked questions

What does yedf2/handy do?

Handy is a C++11 network server framework and event-driven networking engine designed for building high-performance concurrent TCP and UDP servers. It functions as an asynchronous I/O library and an HTTP server implementation that separates asynchronous network I/O from synchronous business logic to simplify server development.

What are the main features of yedf2/handy?

The main features of yedf2/handy are: Reactor Pattern Event Loops, Event-Driven I/O, Asynchronous Networking, Binary Protocols, Event-Driven Networking, High-Concurrency Networking, HTTP Request Routing, Message Encoders and Decoders.

Which projects share features with yedf2/handy?

Projects with overlapping indexed features include: ithewei/libhv — libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP,… chenshuo/muduo — Muduo is a C++11 event-driven network library and framework designed for building high-concurrency Linux servers. It… eventmachine/eventmachine — EventMachine is a reactor-pattern network framework for Ruby that provides an asynchronous I/O library for performing… ldcsaa/hp-socket — HP-Socket is a networking library for building scalable TCP, UDP, and HTTP servers and clients with event-driven I/O… yjhjstz/deep-into-node — This project is a technical study and analysis guide focused on the internal architecture of Node.js. It provides an… warmcat/libwebsockets — libwebsockets is an event-driven networking framework written in C. It provides a suite of tools for implementing HTTP…