A developer shares progress on Ekto, an embeddable typed language influenced by Lua, Koka, and Erlang, discussing implementation challenges around reference counting, memory management, and delimited continuations for the Casper VM.
<p>What are you doing this week? Feel free to share!</p>
<p>Keep in mind it’s OK to do nothing at all, too.</p>
# What are you doing this week?
Source: [https://lobste.rs/s/hqvxoj/what_are_you_doing_this_week](https://lobste.rs/s/hqvxoj/what_are_you_doing_this_week)
I'm continuing work on Ekto's VM\.
Ekto will be an easily embeddable, typed, effect managed language influenced by Lua, Koka, and Erlang\. Today, it's a half\-comprehensible spec and a half\-built VM called Casper\.
I actually really like Casper's design so far, but I'm about to bite off the two "hard" bits\. First, Ekto is refcounted and I need a representation of how to trace data structures to recursively drop them\. Originally, I took a shortcut and assumed I could just monomorphize and emit drop code per type\. I knew the monomorphization was maybe a little ambitious, but what I didn't expect at first was how that would fall apart on the second hard bit\.
The second hard bit is implementing delimited continuations as "slices" into the VM state\. Originally, I was planning on following Xie & Leijen's 2021 "Generalized Evidence Passing" technique that compiles all of this down to closure capture, but I thought that since I've got a VM I might as well exploit that\.
Unfortunately, if I want full generalized delimited continuations like this, I need to have a memory management story for the captured resumptions\. This means I still have to go at least halfway toward capturing each of these resumptions as a closure: I need to a trace of what registers are heap pointers available at every potential yield point\.
\(This isn't as bad as it seems under the general assumption that most yield points are "tail resumptive" and don't actually need a continuation capture at all\.\)
So, now I'm eyeballing ideas like using run\-length encoding to create compressed traces of "live" registers and storing one per yield point\. And I'm also seriously reconsidering whether I shouldn't just fully closure convert \(really: contify\) these yield points\.
A blog post presents a toy language that enforces borrow-checking at runtime without static typing, using cheap reference-counting on the stack to enable interior pointers and single ownership in a dynamically-typed setting.
A detailed technical post on optimizing an AST-walking interpreter for Zef, a dynamically-typed language, achieving 16x speedup through value representation, inline caching, object model improvements, and other optimization techniques to reach performance levels competitive with Lua, QuickJS, and CPython.
A TokioConf 2026 talk/blog post explores pushing safe Rust to its limits by implementing tracing garbage collection for complex pointer structures, sharing techniques for circular references and raw-pointer GC design.