go.vm

You might find something interesting if you were to look at virtual-machines - many are used for implementing scripting-languages, so while you'd not be writing assembly-code, you'd be writing "bytecode" programs. You could write bytecode for Lua, or bytecode for Python for example. I had a fun few weeks writing a simple virtual-machine, and a "compiler" which turns a simple assembly-language-like input into bytecodes which are then interpreted: https://github.com/skx/go.vm/ Other examples, along with lua/python which were already mentioned, might include "Writing a compiler in go" this turns a scripting-language into a set of opcodes which a VM executes: * https://compilerbook.com/

Virtual machines are definitely fun, and can be useful things to know about if you ever design/implement a scripting language or an emulator. I wrote a toy system a few years ago, a simple interpreter (C) along with a compiler/decompiler (Perl) to match it. Unfortunately my system didn't have a terribly well-designed instruction set. If I were to start over I'd probably implement 8086 instruction-set, or similar. That said even a toy system is fun, the biggest issue with writing your own instruction-set is that you have to write the actual programs too. Which is often less fun! I rewrote my interpreter in golang recently, keeping the same instruction-set but adding a better trap-system. Of course re-implementing it meant that I still have the problem of no real programs being written for the machine! https://github.com/skx/go.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..