Open-source alternatives to Smoltcp

This project is a comprehensive computer networking textbook and instructional resource. It serves as a technical guide for the design and implementation of network layers, protocols, and hardware architecture, covering the spectrum from physical links to application-layer protocols. The content provides a detailed study of standards for congestion control, reliable data delivery, and internetwork routing. It includes specialized technical material on network security, public-key infrastructure, and the operation of modern cloud infrastructure and data centers. The material covers a broad ra

Mongoose is an embedded networking library providing TCP/IP stacks, web server hosting, and IoT device connectivity. It enables microcontrollers and desktop systems to implement network protocols including HTTP, WebSocket, and MQTT. The project provides a bare-metal TCP/IP stack for environments without a native operating system and includes built-in TLS and ECC encryption to secure network traffic. It features a binary-embedded file system to serve web content directly from the executable and supports over-the-air firmware updates for managing device fleets. Additional capabilities cover as

OSV is a unikernel operating system and cloud-native execution environment designed to run as a secure microVM on hypervisors such as KVM, Firecracker, Xen, and VMware. It functions as a Linux binary compatible runtime, allowing unmodified Linux binaries to be executed as secure microVMs without requiring recompilation. The project distinguishes itself through its ability to package applications into minimal bootable images and its provide of a virtual machine management API. This REST interface enables remote monitoring of system health, management of execution traces, and control over guest

This project consists of technical instructional guides and a structured computer science curriculum designed to teach the construction of a full computing stack from transistors up to a web browser. It provides a 12-week educational course that covers the fundamental domains of computer architecture and digital logic design. The curriculum is distinguished by its first-principles approach, guiding the learner through the engineering of CPUs, FPGAs, and PCBs using digital logic and hardware description languages. It includes specific syllabi for building a hardware design, a TCP/IP network st

This project is a C++ TCP server framework and educational socket programming guide. It provides a high-performance network library focused on event-driven architecture, implementing a reactor pattern to handle thousands of simultaneous client connections. The framework is distinguished by its multi-threaded event loop, which utilizes a main-sub reactor coordination model to distribute network events across a worker thread pool. It includes an abstraction layer for non-blocking socket I/O and event multiplexing via the epoll system call, decoupling network transport from application business

POCO is a comprehensive C++ application framework that provides a cross-platform set of libraries for building network-centric applications. It offers a unified abstraction layer that wraps platform-specific APIs, enabling the same code to run across desktop, server, mobile, IoT, and embedded systems. The framework is organized into modular libraries that can be compiled and linked selectively, allowing developers to include only the components their application needs. The framework distinguishes itself through its broad coverage of application infrastructure needs, including threading and sy

Coost is a concurrent network framework and coroutine scheduler designed for building high-performance TCP, HTTP, and RPC services. It provides a set of tools for handling non-blocking IPv4 and IPv6 communication, integrating SSL encryption and a lightweight execution engine that manages concurrent tasks using shared stacks. The project features a specialized JSON RPC implementation for exchanging structured data over encrypted connections and a high-performance logging system. This logging infrastructure supports topic-based routing, frequency filtering, and automated stack trace capture for

TinyGo is a specialized compiler and development toolkit designed to bring the Go programming language to resource-constrained microcontrollers and WebAssembly environments. It provides a bare-metal runtime environment that enables high-level code execution without the need for a traditional operating system, utilizing an LLVM-based backend to generate efficient machine instructions. The project distinguishes itself through aggressive optimization techniques tailored for small hardware, including a static memory allocation strategy and whole-program dead code elimination that significantly re

MicroPython is a lean implementation of Python 3 optimized to run on microcontrollers and other resource-constrained systems. It serves as a cross-platform embedded runtime and hardware abstraction layer, providing a firmware framework that maps high-level software commands to specific microcontroller registers across diverse processor architectures. The project functions as an embedded language interpreter that enables rapid prototyping on hardware through an interactive read-eval-print loop. It supports a wide range of target environments, including ARM, ESP32, STM32, RISC-V, and WebAssembl

This project is a technical study and analysis guide focused on the internal architecture of Node.js. It provides an in-depth examination of the runtime, focusing on how the engine manages memory handles, executes asynchronous operations, and implements core module logic. The guide specifically analyzes the integration of native C++ classes and functions into JavaScript and documents the behavior of the libuv event loop. It includes detailed references for optimizing performance by identifying V8 compiler bailouts and profiling execution to improve resource efficiency. The material covers a

OpenThread is an open-source implementation of the Thread networking protocol stack. It provides a standard-compliant IPv6 mesh networking stack, integrating 6LoWPAN and IEEE 802.15.4 to enable secure, internet-connected communication for low-power wireless devices in smart home and industrial automation environments. The project includes a Thread Border Router, which acts as a networking gateway bridging low-power mesh networks to external IP networks such as Wi-Fi or Ethernet. It is designed for energy efficiency, featuring a low-power wireless mesh implementation that allows battery-operat

Pingora is a Rust-based framework for building high-performance network services, including HTTP reverse proxies, layer seven load balancers, and TLS termination proxies. It serves as an asynchronous network library designed to intercept and route HTTP, gRPC, and WebSocket traffic between clients and upstream backend servers. The project enables zero-downtime service updates by handing over listening sockets between processes during binary or configuration upgrades. It utilizes a programmable multi-phase pipeline to modify request and response bodies and headers, and it provides a pluggable T

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

CppGuide is a curated collection of educational resources and practical guides focused on C++ server development, Linux kernel internals, concurrent programming, network protocols, and security exploitation. It provides structured learning paths for backend developers, covering everything from interview preparation to building high-performance network servers and understanding operating system fundamentals. The guide distinguishes itself by offering in-depth, hands-on tutorials that walk through real-world implementations, including building a Redis-like server from scratch, designing custom

Node.js is an open-source, cross-platform JavaScript runtime environment built on the V8 engine, designed for executing JavaScript code outside a web browser. It operates as a server-side JavaScript platform with an event-driven, non-blocking I/O architecture that enables building scalable network applications and web servers. The runtime integrates the CommonJS module system for synchronous module loading and the npm ecosystem for sharing and reusing packages. The platform provides comprehensive capabilities for web server development, including creating HTTP and HTTPS servers, managing HTTP

yggdrasil-go is a self-organizing encrypted IPv6 overlay network. It implements a decentralized peer routing system that uses public-key-based addressing to link identity and location, allowing the network to automatically discover paths and manage connectivity without central authority. The system provides transport-agnostic peering and multi-circuit redundancy, maintaining several concurrent connections to a single peer to ensure high availability. It supports prefix-based route advertisement, which enables the routing of dedicated IPv6 subnets to non-participating devices through the encry

pysheeet is a technical reference library providing a curated collection of code snippets and implementation patterns for advanced Python development, system integration, and high-performance computing. It serves as a comprehensive guide for implementing low-level network programming, native C extensions, and asynchronous and concurrent programming. The project provides specialized frameworks for the development and deployment of large language models, including tools for distributed GPU inference and high-performance serving. It also includes detailed patterns for high-performance computing

Vector is a high-performance observability data pipeline designed to collect, transform, and route logs, metrics, and traces across distributed infrastructure. It functions as a modular engine that decouples data ingestion from processing and transmission, utilizing a component-based architecture to connect diverse sources to multiple destinations. The project distinguishes itself through a focus on reliability and flow control. It implements backpressure-aware data movement to prevent data loss during traffic spikes and utilizes disk-backed event buffering to ensure durability during network

Smallchat is a minimal implementation of a concurrent network server and TCP-based chat system designed as a demonstration of C socket programming. It provides a basic server and client architecture that enables real-time text communication between multiple connected users. The project focuses on the implementation of a networked chat server that handles simultaneous client sessions. It utilizes a centralized broadcasting model to route incoming text from one client to all other active participants. The system manages concurrent client connections and session tracking using socket descriptor

This project is a collection of minimal operating systems, bootloaders, and hardware drivers used to demonstrate low-level x86 system programming and hardware interfacing. It serves as a kernel development toolkit and a system programming lab designed for testing architecture concepts and hardware behavior within a system emulator. The repository provides reference implementations for creating bootable disk images and loading kernel stages. It includes guides for implementing protected mode transitions, memory paging, interrupt descriptor tables, and symmetric multiprocessing on x86 hardware.

Embassy is an asynchronous framework for microcontrollers that provides a runtime for cooperative multitasking. It enables the execution of multiple concurrent tasks to maximize energy efficiency and CPU usage, utilizing an async executor that puts the processor to sleep when idle. The framework includes a comprehensive set of embedded components, featuring a hardware abstraction layer for peripherals like GPIO, SPI, I2C, and UART, alongside a TCP/IP network stack and a USB device stack. It also provides a Bluetooth Low Energy host stack for wireless communication and a bootloader framework t

Robyn is a high-performance asynchronous web framework and server for Python that utilizes a Rust-powered runtime to execute code. It functions as an asynchronous Python web server designed to handle many concurrent requests efficiently through a multithreaded execution model. The project includes specialized capabilities for AI agent request routing, managing communication between agents and external tools. It also serves as a WebSocket communication server, maintaining persistent bidirectional channels for real-time data exchange. The framework covers a broad range of web infrastructure, i

This project is an embedded C++ development kit and hardware abstraction layer that enables the Arduino programming environment to target ESP8266 WiFi microcontrollers. It provides a comprehensive framework for compiling and flashing code to microcontroller memory via serial or wireless interfaces. The system includes a specialized WiFi microcontroller framework for managing TCP/IP stacks and internet connectivity. It features a dedicated over-the-air firmware update system that allows software updates to be delivered to remote hardware without a physical cable connection. The kit covers emb

f-stack is a kernel-bypass framework and user-space TCP/IP stack designed to increase packet processing speeds and overall throughput. It utilizes DPDK to route network traffic directly to user space and integrates a transplanted FreeBSD network stack to handle transport and network layer protocols outside of the host operating system. The project provides a socket API compatibility layer that allows standard network applications to run on a high-performance backend without requiring code changes. It also features a coroutine-based network API and micro-threading interface to manage asynchron

IncludeOS is a unikernel operating system that bundles application code with only the necessary kernel drivers into a single bootable image. It functions as a resource-efficient cloud service virtual machine and a lightweight serverless runtime environment designed to minimize memory footprints and boot times. The project provides a Linux compatibility layer via a C library, allowing applications written for Linux to be compiled and executed within the unikernel environment. It also serves as a network appliance framework for building high-performance firewalls and load balancers using config

Skynet is a distributed game server framework designed for building scalable online game backends. It utilizes distributed actor-based clusters and real-time network communication to manage high-concurrency session coordination across multiple nodes. The framework includes a cluster management orchestrator for coordinating services via cluster-wide messaging and dynamic configuration updates. It features a multi-protocol network gateway supporting TCP, UDP, and WebSockets, alongside a data encoding layer using BSON and Sproto serialization for efficient information transfer between distribute

NuttX is a POSIX-compliant real-time operating system designed for microcontrollers ranging from 8-bit to 64-bit architectures. It provides a deterministic execution environment with a real-time task scheduler and a POSIX embedded kernel to ensure portable code execution across diverse hardware targets. The project distinguishes itself through a comprehensive hardware abstraction layer that provides standardized drivers for I2C, SPI, CAN, and USB across various semiconductor chipsets. It also features an embedded networking stack supporting TCP, UDP, IPv4, and IPv6, alongside industrial proto