simple.vm

It is always nice to see projects like this. Creating a simple interpreter isn't a hard job, but it's still pretty educational. One thing that you'll benefit from is documenting the instruction-set, and usage a little more clearly. For example my own toy language was written in C here: https://github.com/skx/simple.vm And I think I did a good job of showing how to use the instructions. Then for fun I rewrote it in golang https://github.com/skx/go.vm which showed some interesting differences. Your own tastes might differ, but I'd think after the interpreter a compiler/decompiler would be good next steps. Makes it a lot easier to write code/programs in your assembly!

http://emulator101.com/ is a good resource, as is https://www.reddit.com/r/emudev/. Or you can just cheat, design a "toy" instruction set, and write something to process it. A couple of years ago I did that, in C/Perl: * https://github.com/skx/simple.vm Later I rewrote the interpreter/emulator in go: * https://github.com/skx/go.vm The downside with my approach here is that I ignored graphcs, sound, & I/O. These days I'd recommend you write an emulator for the Chip-8 system..

JVM might be much more involved project but here is a simple virtual machine - https://github.com/skx/simple.vm

That's a great suggestion. I went one step lower and wrote a (perl-based) virtual-machine. As you suggested I did the bare minimum at first, for example when I see labels I just remember their locations. Later on I patch up the offsets in the code, to make jumps to them point to the correct location. The project seems reasonably popular, for reasons that I don't understand, but it is very simple: https://github.com/skx/simple.vm

Funny you mention that - I used that structure in my simple virtual machine (which includes a compiler, a decompiler, support for conditionals, and also an example of embedding): https://github.com/skx/simple.vm Rather than having an enum of opcodes I have a array of pointers to functions - one for each opcode I implement. It is a logical/clean way of implementing things, but i think it is not necessarily better. (In my case I lose due to inline strings, and variable length opcodes which make complications.)

Agreed. I wrote a simple virtual machine, and the most interesting thing was writing the compiler that would read my "assembly", and spit out the bytecode. Including handling labels and jumping instructions. My VM was very simple, and I've not touched it for a while, but the whole thought of how to handle branching was what made it more interesting than other similar toy systems. https://github.com/skx/simple.vm