EIPA

EIPA is a program suite inspired by LIPA, a program we were given in school to understand the core principle of how a "von Neumann" Computer works.

View the EIPA source code on my Forgejo instance

Whats LIPA?

LIPA basically is an emulator for a really simple CPU
In LIPA you are able to write "Assembly" code for that CPU. When you execute the Code you are shown a live spreadsheet of all the Memory Adresses and what value each adress contains
LIPA also has one output and one input function. Both of them open a dialog window where a number is displayed or you are prompted for input (respectively)
LIPA supports these instructions:

• INP input to memory adress
• OUT output from memory adress
• LDA load value from memory adress into accumulator
• STA store value from accumulator in memory adress
• INC increment value in accumulator
• DEC decrement value in accumulator
• JPP Jump if value in accumulator is positive
• JPZ Jump if value in accumulator is zero
• JPN Jump if value in accumulator is negative
• JPU Jump
• EOJ Exits execution

LIPA is really old tho, not really publically availble, not avaible for other OS'es (as it is closed source), and also has very limited debugging functionality, as you cannot even pause execution, you are just able to decrease the execution speed.
It isnt't nice to code in LIPA as it has bad error dectection, and you are also needed to prefix every line with the memory adress that that instruction is going to have later. As a program needs to be consisting of followning instructions, if you insert one line you need to rewrite all others as well. LIPA also only has 80 Memory adresses, which need to contain all the instruction + the data.

Whats EIPA?

EIPA is trying to be a modular and modern successor to LIPA. It is supposed to have the same functionality, but a better assembly syntax, debugging, more memory space and various other improvements.
EIPA will consist of 3 individual Parts:

The EIPA Assembler (Almost fully implemented)
The EIPA Assembler reads the EIPA Assembly file, and turns it into an EIPA Memory image. This memory image contains all the instructions from the Assembly file, in a binary form, which the EIPA CPU can understand and execute.
You can see a detailed descripiton on how the Assembler works and its source code here.

The EIPA CPU (not yet implemented)
The EIPA CPU loads an EIPA image into its RAM, and then executes the instructions.

The EIPA GUI (not yet implemented)
The EIPA GUI is a (optional) frontend, where you can write the EIPA Assembly, assemble and run the code with one click, debug the code (breakpoints, step by step, slow execution), visualizes errors graphically, ...
I actually do not know how to implement that best, but when I'm doing it, I'll hopefully find that out. My goal would be a fully featured program, but maybe it just ends u being a VSCode extention or a LSP Server...