July 13, 2026
C tries on Go’s concurrency costume
Go-Flavored Concurrency in C
One coder tried to give C Go-style multitasking, and the comments instantly started arguing
TLDR: A developer showed that C can copy some of Go’s multitasking style using standard Unix threads, but with clear limits. The comments quickly split between people impressed by the experiment and people saying the best parts of Go — cheap lightweight tasks and smarter coordination tools — still aren’t really there.
A developer set out to answer a very nerdy but surprisingly juicy question: can old-school C do the slick “do lots of things at once” magic people love in Go without dragging in a giant helper system behind the scenes? The answer from the post is basically: kind of, yes — but don’t kid yourself about the cost. Using standard Unix thread tools, the project gets part of the way there, and some pieces are impressively close. Tiny atomic operations, for example, seem to run about as fast as Go’s. But the bigger fantasy — the effortless, super-cheap flood of lightweight tasks — is where reality crashes the party.
And oh, the comment section pounced. One camp immediately went full history-teacher mode, with BoingBoomTschak dropping a classic “ackchyually” and reminding everyone that this whole idea has ancient roots in Plan 9, Limbo, and Alef. Another camp wasn’t impressed at all: “cool wrapper, but where’s the real magic?” Several readers argued that the best part of Go isn’t just starting lots of tasks — it’s the famous “select” feature for juggling them, plus the fact those tasks are absurdly cheap. Others side-eyed the whole project by saying, basically, “if you wanted proper lightweight threads in C, libraries already exist.” Cue shout-outs to libmill and libdill.
So the vibe is half admiration, half roast. People respect the honesty of the experiment, but the crowd’s hottest take is that imitating Go’s vibe isn’t the same as recreating Go’s superpower.
Key Points
- •The article examines implementing Go-like concurrency in C using POSIX threads while working on Solod, a Go subset that transpiles to plain C without a runtime or garbage collector.
- •So’s concurrency stack is built primarily on wrappers around `pthread_mutex_t` and `pthread_cond_t`, exposed as `sync.Mutex` and `sync.Cond`.
- •The transpiled C output is described as a near-mechanical translation of the So source, with little abstraction beyond wrappers around pthread calls.
- •So’s atomic types map directly to the C compiler’s `__atomic` builtins rather than to pthreads, and the article reports similar single-thread atomic operation timings to Go.
- •The article concludes that pthreads can support a substantial subset of Go-style concurrency, but with clear tradeoffs compared with lightweight goroutines and a runtime scheduler.