Evan Martin

Pet peeve: Rust projects whose repo is organized as a bunch of directories like
crates/$projectname_foo
crates/$projectname_bar

1) This is not organization! This is ravioli code. Directories and their nesting convey relationships.
2) You don't need to repeat the project name in every crate. In other words, the crate name is not required to match the directory name. If a project has a myproject-async-interp crate, it is easy to figure out that the path named async-interp is its home.

@thakis Thinking about it more: also I've mostly written Rust the last few years and Rust is a lot worse than C++ in a debugger. E.g. you can't evaluate any complex expressions, and even evaluating a reference like "foo.bar.baz" in Rust you have to manually change to "foo.bar->baz" depending on whether any of the intermediate components are references or not.

@thakis I think never before! I am so accustomed to debuggers never working that I don’t use them often, and then Mac makes everything worse by lldb being extra clunky. But also most of my emulator bugs of the past years have been bugs in my emulation, which is one level removed from the system debugger (until now!)

Anyway if you read the thread this far, here's a screenshot of the missing phase 2, now rendering properly.

Normally screwing up the stack pointer in this way makes things go immediately wrong elsewhere because it fails to return to the right address. But in this case, the function was using ebp to save/restore the stack pointer, totally masking that I had messed up the stack pointer -- except in how it was failing to preserve this register, the cause of this bug. This is the same masking @aaronsgiles wrote about in https://corteximplant.com/@aaronsgiles/116044322660755992 .

The culprit was a function that was using edi for its own purposes. It was correctly using push/pop edi to preserve the caller's value, but that was going wrong. The stdcall ABI used on Windows means the callee pops arguments off the stack. This means when the culprit function calls one of my functions and I had the arguments wrong, the stack pointer gets off by an entry or two. I've written this bug so many times! This meant the restored edi was instead some other garbage on the stack.

From there, I could see that phase2 was intended as a loop and that the loop was exiting. Again, because I have translated source code I could use my system debugger to step through it, though the control flow is harder than normal code. From there, I could see that edi was some sort of counter that started at 0, but after a single pass through the loop it had a garbage value. The system debugger's watch points tracked it down further, possibly the first time I've used those.

The first step was trying to isolate the problem. I disassembled enough of the code to figure out that the phases were (thankfully) pretty simple sequential code. The cool new thing about the static translation approach of Theseus is that I can modify the translated source code by hand, so it was easy to patch out the call to phase1 and panic in phase3, which reduced the problem to the program immediately entering and then leaving phase2.

This morning I tracked down an emulator bug that manifested as rendering the first scene of a demo and then skipping directly to the third. This kind of thing is brutal (and kind of fun, sometimes) to track down because it is very hard to pinpoint the point where things have gone wrong.

New blog post: Theseus unpacking
Revisiting unpacking executables.

https://neugierig.org/software/blog/2026/04/theseus-unpack.html

(A more structured description of my earlier ramble...)

(Code is not really up to my expectations for good shape for publishing, sorry in advance if you attempt to read it! Was a fun nerd snipe in any case.)

In any case, the flow looks like this: $ tc --exe chillin.exe --out exe/chillin-unpack ... WARN tc/src/traverse.rs:40 omitting 004085dd: block appears zero-filled (This shows the code jmp'd to 004085dd, but there was no code there -- that's where the unpacked code starts.) Then I can hand-write a file that provides that function, where it re-invokes the compiler: https://github.com/evmar/theseus/blob/9e2b135af2c32df73f0965c4f5f5159432fb80fe/exe/chillin-unpack/src/externs.rs Which means the whole do_unpack function ends up relatively tiny: https://github.com/evmar/theseus/blob/9e2b135af2c32df73f0965c4f5f5159432fb80fe/exe/chillin-unpack/src/main.rs

Unfortunately, I was so focused on how nifty this was that I overlooked the other reason to care about unpacking, which is loading the program in a tool like Ghidra. And for that I really do need an exe file.

The variation is: first run Theseus on the packed executable, producing a program that unpacks and then jumps to a dynamic address (the address of the unpacked code, which Theseus didn't see to translate). Then modify that program to implement that address, and implement it by a function that calls back into the Theseus compiler to generate source code directly. No intermediate exe serialization needed! The unpacker has the unpacked data in memory, so I can codegen directly from there.

One of the (private) responses I got to my post about Theseus was someone asking if it can handle packed executables. It can't, of course, because they unpack more code at runtime.

But they totally nerd sniped me because for a one-time unpack I could just as well run two phases: first use Theseus to run the unpacker, modified to write out an executable, then run Theseus again on that.

In fact, there's a cooler variation I thought of, which I implemented!

New blog post: Theseus, a static Windows emulator
An new old approach to emulation.

https://neugierig.org/software/blog/2026/04/theseus.html

Speaking of common names, we gave our son a pretty unique one: his mom's last name was already rare, and his is a common name from a different part of the world such that the two together are almost certainly globally unique.

On one hand, this is kind of nice, to not have the name conflicts I encounter so often. On the other, sometimes I think it's kind of nice that you can never be quite sure whether some fact is about me or about some doppelnamer. It's almost a kind of privacy.

@jyasskin https://en.wikipedia.org/wiki/Contronym