libmill

libmill (https://github.com/sustrik/libmill) and libdill (https://github.com/sustrik/libdill) should be similar and probably mentioned. As far as I understand the differences between CspChan and libmill might be that libmill also implements lightweight tasks (coroutines) and everything that goes with it (IO multiplexing, async timers, etc), while CspChan uses OS threads?

https://github.com/sustrik/libmill/blob/e8937e624757663f5379... They wrote a macro (or in this case a set of macros) to transform that into valid C code.

Libmill is stack-unsafe https://github.com/sustrik/libmill/issues/167

I was confused -- how can a library add a keyword like "coroutine" to C. It didn't look like macros were powerful enough to do that (I expected to at least some context having to be passed to the worker, or so). It turns out that a coroutine is just a function that the compiler should not inline: https://github.com/sustrik/libmill/blob/master/libmill.h#L24...

I wasn't saying that either, I was saying libmill did not do it in (pure) C: https://github.com/sustrik/libmill/blob/master/libmill.h It only works with gcc and clang now, no longer with windows, and is sprinkled with asm()s. That doesn't fly with the CPython is portable. I don't know how these go-like features could be created with ANSI C, but I'd love to be proven wrong.

Also worthwhile mentioning is functionalC [0]. The blog mentioned on the Github page is down but the relevant URLs can be accessed from the wayback machine at [1] and [2]. GCC also supports nested functions [3] (as a GNU C extension). Unrelated, but [4] specifies a pure C implementation of Go channels and libmill [5] is a library that introduces Go-style concurrency to C. [0] https://github.com/cioc/functionalC [1] https://web.archive.org/web/20160406001106/http://blog.charl... [2] https://web.archive.org/web/20160304120857/http://blog.charl... [3] http://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html [4] https://github.com/tylertreat/chan [5] https://github.com/sustrik/libmill

How is this different from https://github.com/sustrik/libmill? It's from the same author.

Libmill could be worth a look. https://github.com/sustrik/libmill

One of the reasons goroutines are considered 'lightweight' is that they allocate a small stack to begin with which is reallocated and moved if more space is needed. Of course, stack-moving isn't possible in C for various reasons. What does libmill do here? Does it allocate a large stack right off the bat? What happens in a stack overflow, does it segfault or will it just trample over whatever is beneath it? Edit: an ounce of investigation is worth a pound of answered questions, or something like that. It appears stack sizes are configurable, but default to 256kb [1] (for scale, go defaults to 2k), and are retained in a cache of size 64 [#L72] (by default). Also the bottom page is used as a stack guard if posix and mprotect are available [#L90]. From a cursory glance there appears to be some data races in the stack allocation code, though

Sadly it doesn't have support for Windows MSVC yet: https://github.com/sustrik/libmill/issues/16

"choose" is a macro: https://github.com/sustrik/libmill/blob/8054d5024bf5824b8060...

Clever macro expansions: https://github.com/sustrik/mill/blob/c1c302f7edb3811d9098f7b...

You can check the project directly here: https://github.com/sustrik/mill