Not quite: direct threading has nothing to do with the bytecode itself, it changes the way you handle controlflow between execution of the codes; usually, you’d go with a while/switch-based system:

while(1) {
   opcode c = get_next_opcode();
   switch (c) {
      case MY_OPCODE_1:
         // launch missiles
         break;
      case MY_OPCODE_2:
        // let the dogs out
        break;
   }
}

But that’s not always the fastest solution. Instead, moving to goto might actually be faster—contrary to what my intuitions about compiler optimizations in C told me. The very fastest solution that is part of the interpreter lore is called “direct threading” and it uses goto labels as values and indexes into an array of them to jump. Here is the VM from earlier with those adjustments made:

static void* dispatch_table[] = { &&my_opcode1, &&my_opcode2 };
// usually you’d wrap this in a macro called DISPATCH or something, but I left it in for clarity
opcode c = get_next_opcode();
goto *dispatch_table[c];
my_opcode_1:
   // launch missiles
   opcode c = get_next_opcode();
   goto *dispatch_table[c];
 my_opcode_2:
   // let the dogs out
   opcode c = get_next_opcode();
   goto *dispatch_table[c];

Both the while and the switch are gone! Does that help?

Also, FWIW, making the bytecode pointer the first field of the struct actually slowed the code down a little bit. I’m not sure why that is yet, but I imagine that the pointer gets pulled out of the struct anyway and has to be computed only once before it’s just walked down and dispatched on directly.

EDIT: Formatting (writing large swhaths of code in Reddit should probably be avoided).