How does Neco compare to libcoroutine?

Neco offers a higher-level API with channels and generators similar to Go, while libcoroutine is more low-level. Neco is single-file and has better Posix integration, but libcoroutine might be more flexible for custom implementations.

Can Neco be used with multithreading?

Neco uses thread-local runtimes, so each thread has its own scheduler. Communication between threads requires I/O mechanisms like pipes, as pthread synchronization doesn't work well, limiting true parallel execution.

How to handle blocking I/O in Neco coroutines?

On Linux and BSD, use neco_wait() to poll file descriptors without blocking. Otherwise, rely on cooperative multitasking with neco_sleep() and other primitives, but avoid traditional blocking calls that stall the scheduler.

Is Neco good for embedded systems?

Yes, due to its small footprint and no dependencies, but be cautious of default stack sizes (e.g., 1MB on Windows/WebAssembly) and platform limitations on resource-constrained devices.

Neco or asyncio for C projects?

Neco provides coroutines with a Go-like model, ideal for single-threaded concurrency with simple APIs. Asyncio or other libraries might be better for event-driven architectures or if you need multithreading support.

How to create a TCP server with Neco?

Use neco_serve() to bind and listen on an address, then neco_accept() in a loop to handle connections, starting coroutines with neco_start() for each client, as shown in the echo server example.

What are the memory usage considerations for Neco?

Each coroutine has a stack; default sizes vary by platform (e.g., larger on Linux/BSD, 1MB on Windows/WebAssembly). Guards and gaps are not supported on all platforms, so monitor stack overflow risks in heavy workloads.

Open-Awesome

Neco

MITC

A lightweight C library for concurrency using stackful coroutines, designed for easy concurrent I/O and network programming.

GitHub

1.4k stars112 forks0 contributors

What is Neco?

Neco is a concurrency library for C that implements stackful coroutines, providing a simple way to write concurrent I/O and network applications. It solves the complexity of traditional threading by offering a lightweight, single-threaded runtime with a deterministic scheduler, making concurrent programming more accessible in C.

Target Audience

C developers building networked applications, embedded systems, or any project requiring efficient concurrent I/O without the overhead of multi-threading.

Value Proposition

Developers choose Neco for its minimal footprint, fast performance, and straightforward API that mirrors familiar concurrency patterns from Go, all while maintaining full compatibility with existing Posix functions.

Overview

Concurrency library for C (coroutines)

Use Cases

Best For

Building concurrent network servers like HTTP or TCP echo servers
Writing lightweight coroutine-based I/O handlers in C applications
Implementing generators or iterators using coroutines
Creating deterministic, single-threaded concurrent systems
Adding concurrency to embedded or resource-constrained environments
Prototyping concurrent algorithms with a simple synchronization model

Not Ideal For

Applications requiring true parallelism across multiple CPU cores
Projects heavily dependent on Windows or WebAssembly for full networking and I/O capabilities
Teams that prefer async/await syntax over coroutine-based concurrency models
Systems needing direct use of pthread synchronization primitives within coroutines

Pros & Cons

Pros

Lightning-Fast Context Switching

Uses assembly for user-space context switches, achieving ~11 nanoseconds per switch on modern hardware like AMD Ryzen, as benchmarked in the README.

Zero-Dependency Simplicity

Just drop neco.c and neco.h into your project with no external libraries or complex build steps, making integration trivial.

Posix Interoperability

Designed to work seamlessly with existing Posix file descriptors and functions, easing adoption in legacy C codebases.

Rich Synchronization Toolkit

Includes channels, generators, mutexes, and condition variables inspired by Go, providing robust tools for coroutine coordination.

Deterministic Scheduling

Features a fair scheduler that ensures predictable execution order, beneficial for debugging and deterministic systems.

Cons

Platform-Specific Limitations

On Windows and WebAssembly, key features like neco_wait() for file descriptor polling are missing, and networking support is incomplete, as admitted in the README.

Single-Threaded Runtime

Each thread has its own scheduler, and coroutines cannot span multiple threads without complex I/O workarounds like pipes, limiting scalability on multi-core systems.

No Native Multithreading

The library explicitly avoids multithreaded coroutine scheduling, making it unsuitable for applications that need to leverage multiple CPU cores directly.

Argument Scope Complexity

Coroutine arguments must be copied before the first neco_ function call, adding overhead and potential for use-after-free bugs if not handled carefully.

Frequently Asked Questions

Related Projects

concurrentqueue

A fast multi-producer, multi-consumer lock-free concurrent queue for C++11

Stars12,229

Forks1,916

Last commit25 days ago

Taskflow

A General-purpose Task-parallel Programming System in C++

Stars11,949

Forks1,396

Last commit2 days ago

ThreadPool

A simple C++11 Thread Pool implementation

Stars8,734

Forks2,352

Last commit1 year ago

ArrayFire

ArrayFire: a general purpose GPU library.

Stars4,883

Forks548

Last commit1 month ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub