I guess this is cool. It works by copying the current coroutine's stack into a memory buffer when the coroutine yields, and copying the next coroutine's memory buffer into the main stack, rather than having separate stacks for each coroutine and juggling the hardware stack pointer. Obviously the copying adds overhead but for small coroutines it will not be too bad. In return you get rid of the need to pre-allocate memory for each stack, and if a coroutine never blocks, it runs like a normal subroutine, no stack juggling.

It would be great if the post included some suggested applications. I also found the benchmark graphs hard to read. A table with numbers would have been easier.

This is mostly of interest for very low memory systems, right? Otherwise it's easier to use conventional stackful coroutines or multitasking. Even the traditional tiny Forth multitaskers were stackful, I think.

In this environment the stack size of a coroutine should be about constant at the yield points, or else maybe you want to allocate the copy buffers on the heap? Also if the coroutines don't persist, you may need a way to free their storage. Alternatively, maybe you can GC the memory buffer once in a while, by collapsing out unused parts.