Good call! (Whether it's a directly threaded, indirectly threaded, subroutine threaded, token threaded, Huffman threaded, or string threaded call.)

https://en.wikipedia.org/wiki/Threaded_code#Token_threading

Mitch Bradley created OpenFirmware, which was originally called ForthMacs or Sun Forth, running on Sun 68k, SPARC, and Amiga. It was based on Langton and Perry Forth 83, and has a metacompiler that can target and cross compile to many platforms, word sizes, cpus, and threading models, produce stripped ROMable images, etc.

The metacompiler made it possible to support different target platforms and interpreter styles, running native CPU, Direct Threaded Code, and bytecode like FCode simultaneously.

So the core of the Forth system runs fast native code with 32 bit threaded code field address pointers, and it can also run portable FCode on the ROMS of expansion cards.

The FCode gets re-tokenized at boot/probe time into the live native DTC dictionary.

https://github.com/MitchBradley

https://github.com/MitchBradley/openfirmware

At the time the Forth bytecode was developed, Sun had different instruction sets (68k, SPARC, x86) that they wanted to support with the same peripherals (typically SBus, like the Sun386i "Roadrunner"). But later it became an IEEE standard that other platforms adopted, like PowerPC Macs, and the OLPC.

Interview with Mitch Bradley (he's like the Woz of Forth):

https://web.archive.org/web/20120118132847/http://howsoftwar...

Years before OpenFirmware bytecode, Mitch also developed an extremely portable C-Forth, which uses token threaded interpreter (16 or 32 bit configurable) using a switch statement + a small, hand-rolled FFI built around a fixed-arity argument-marshalling trampoline:

https://github.com/MitchBradley/cforth

OpenFirmware even has its own song:

https://www.youtube.com/watch?v=b8Wyvb9GotM

More on Mitch and OpenFirmware:

https://news.ycombinator.com/item?id=21822840

https://news.ycombinator.com/item?id=33681531

https://news.ycombinator.com/item?id=38689282

Since we're bringing up ACPI, let's not forget about EFI!

https://uefi.org/specs/UEFI/2.10/22_EFI_Byte_Code_Virtual_Ma...

That goes back to Ken Thompson's NFA regex interpreter from 1968 [1], [2], [3]. Note: that whole regex series by Russ Cox [4] is great.

[1] https://dl.acm.org/doi/10.1145/363347.363387 -- Programming Techniques: Regular expression search algorithm

[2] https://swtch.com/~rsc/regexp/regexp1.html -- Regular Expression Matching Can Be Simple And Fast

[3] https://swtch.com/~rsc/regexp/regexp2.html -- Regular Expression Matching: the Virtual Machine Approach

[4] https://swtch.com/~rsc/regexp/ -- Implementing Regular Expressions

All regular expressions are deterministic final automata https://en.wikipedia.org/wiki/Deterministic_finite_automaton (finally, a use for my CS course); the extent to which that counts as a virtual machine varies. Some of the regex syntaxes extend it in ways which don't fit in a DFA and do count as a VM; Perl-compatible RE used to be popular (e.g. in Exim).

Interesting. Not that surprising that it works like this. But isn't it a little surprising that things like regexes, printf syntax and other DSLs aren't mostly handled and parsed at compile time in 2026?

VM for obfuscation is a whole thing. Denuvo has a particularly complicated one https://connorjaydunn.github.io/blog/posts/denuvo-analysis/

Other game examples using VMs not for obfuscation: Z-machine and SCUMM-VM.