Thanks for the catch! You’re spot on about the missed wakeups. It's still a very early prototype—mainly just wanted to see if this whole architecture holds water. I'll definitely be adding the #StoreLoad fence and tightening up the memory ordering in the next push. Appreciate the feedback!
I didn't realize the mods had un-killed this post yesterday, so my apologies for the late replies. I'm very grateful to them for doing that—I just only now saw that it was live.
That is a fascinating comparison! History really does rhyme.
What you described—suspending with a flag and resuming with new values—is surprisingly similar to how the C++20 compiler transforms coroutines into a state machine under the hood.
In tiny_coro, the promise_type essentially manages that "inversion of control" you mentioned, but hides the manual state management behind the co_await syntax. It's really cool to see that these fundamental patterns for "stopping and resuming" computation have existed for so long, just in different forms.
You are absolutely right about the history (Conway coined the term in '63!).
The assembly stack-switching you mentioned is the classic "Stackful" approach (like Fibers or Boost.Context). C++20 went the "Stackless" route (compiler-generated state machines) to avoid the per-stack memory overhead, though it certainly makes the implementation mechanics trickier.
Lua is definitely a gold standard for asymmetric coroutines.
As for Felix—I actually wasn't familiar with it until you mentioned it. Thanks for the pointer! I'll definitely dig into their docs to see how they handle scheduling compared to the C++20 approach.
Haha, you have a really sharp eye!
1. The Baby Wireshark: Unfortunately, my previous GitHub account got flagged/shadowbanned (still not sure why, and the appeal didn't work), so I lost access to that repo. I had to start fresh with this new account.
2. The Tone: You caught me! English is not my first language. I do use LLMs to help polish my grammar because I want to ensure my technical points are clear and I don't accidentally sound rude due to language barriers.
Also, I learned most of my English from reading technical documentation and watching TED talks, so my "default" style tends to be a bit formal—just like an AI! :)
> Unfortunately, my previous GitHub account got flagged/shadowbanned
Oh! That sucks big time. Hope you had a local repo of everything.
BTW I don't think your tone is formal, just suspiciously congratulatory and polite :)
Do checkout Felix when you get time. It has done a lot with coroutines. You were asking about scheduling, it allows you to create more schedulers within the language.
Haha, point taken! I will try to dial down the "customer service mode" :)
Re: GitHub: Yeah, thankfully I had the local git history, so the code was safe. Just lost the community interactions (stars/issues), which was a bummer.
Re: Felix: That sounds exactly like what I need. Being able to define custom schedulers within the language is pretty much the holy grail I'm chasing here. I'll put it on my reading list for tonight.
Oh absolutely! Adam Dunkels' work is legendary.
It's kind of poetic that Protothreads achieved stackless concurrency via C preprocessor macros and Duff's device tricks, and now years later, C++20 finally baked that exact same "state machine via switch-case" logic directly into the compiler.
Same spirit, just less macro magic! :)
Thanks for the reference—I learned a lot from his work.
His use of macros to hide the switch statement is basically the spiritual ancestor of co_await. It is wild to think that C++20 essentially standardized that exact pattern, just moving the "state machine generation" from the preprocessor hacks to the compiler itself.
You hit the nail on the head. C++20 coroutines are indeed complex and the barrier to entry is high.
However, that complexity actually forced me to start from first principles. It drove me to tackle the essential problems from the ground up, which gave me a much deeper understanding of how coroutines truly work.
That is exactly why I built this project—I wanted to create a minimal "laboratory" to dissect stackless coroutines without the overhead of a massive framework like Seastar.
Regarding your point on Erlang/Go: That's actually the goal of this scheduler! It implements the M:N threading model (Work-Stealing) to simulate that kind of "lightweight process" concurrency, but giving you manual control over the mechanics.
Hope this helps you finally wrap your head around co_await!
I think there is some hope of a sane wrapper around C++20 coroutines that will make them easier to use. I saw a tutorial a while back mentioning that might eventually become part of the C++ standard. I once tried to use Boost coroutines but it was too much headache and I switched to a different approach.
Erlang's processes and Goroutines are stackful unlike C++ coroutines. Erlang also forbids observable data sharing between processes which avoids a lot of pitfalls. I don't think that can be enforced in C++ or Go.
GHC lightweight threads and its STM library (software transactional memory) could be another thing to look at. I wonder if a useful STM feature is feasible for tiny_coro.
You are spot on about the distinction. C++ chose the stackless path for "zero-overhead" efficiency, but it definitely shifts the burden of safety and usability onto the library developers.
Regarding safety and data sharing: You're right, C++ won't enforce isolation like Erlang. That's the trade-off we make for performance.
However, to address your point about "sane wrappers" and concurrency models: I actually implemented Go-style Channels (CSP) on top of this scheduler to bridge that gap.
It uses co_await to mimic Go's channel behavior, supporting Direct Handoff (skipping the buffer/queue if a receiver is waiting) and optimization via await_suspend returning false to avoid context switches on the fast path.
While a full-blown STM might be too heavy, I found that combining these Channels with Epoch-Based Reclamation (EBR) gives a pretty robust safety net without the overhead of heavy locking.
If you're interested, the Channel implementation is here: https://github.com/lixiasky-back/tiny_coro-build_your_own_MN...
Yes, Vanta currently relies on gopacket for packet capture and parsing. As a student, my main goal was to build something clear, functional, and real — rather than reinvent everything from scratch.
I'm actively learning the details of network protocols, and I do plan to write some custom parsers later, both for flexibility and personal understanding. But at this stage, I think it’s more important to deliver a meaningful tool than to prove I can reimplement low-level stacks.
In the long run, I may gradually replace parts of gopacket, but right now it's an important and reliable foundation for the project.
(And honestly — finishing something real matters more to me than perfection )
Totally fair! I really appreciate the honesty.
English isn't my native language, and most of the expressions I know come from TED talks, open source READMEs, and honestly... the kind of news clips our teachers play in class
So yeah, that probably shaped the way I wrote this.
You’re right though — reading it again, it does sound kinda overly polished.
I’ll try to keep future writing more personal and grounded.
Still learning — and thanks for reading it at all. That already means a lot!
Thanks a lot for sharing this — it's super helpful!
Yeah, I’m currently using gopacket mainly to get something working fast, but I’ve been thinking about writing my own parsers from scratch to understand the protocols better.
Your Hdr example is really clean — definitely saving this as reference! I love how direct and readable it is.
I’ll definitely try going lower level when I revisit the packet layer logic. Thanks again for the nudge
Great question! I chose Go mainly because it's simple, efficient, and widely used — and honestly, it's the language I'm most comfortable with right now.
I'm still a student, and I don’t have super big ambitions yet — I just wanted to build something I could actually finish and understand
Rust is amazing, but I haven’t started learning it seriously yet. It feels a bit overwhelming at this stage. Maybe one day, when I'm ready to dive deeper!
Good luck with your Burp project too — I’d love to see it if you share it someday!
reply