Edit: I re-read this in the morning and realized there's a lot of context missing that to explain is outside the scope of this sub-reddit so I apologize for that. The tldr is an IDE that lets users write programs in assembly language by abstracting the common logic in ISA's into a visual representation (Scratch from MIT, Unreal Blueprints, etc.).

I'm sorry about the long post but I can't tldr it properly without sounding like "I just downloaded Unity, time to make an MMO". Opinions in this post are my own and don't represent those of my employer (safety stuff).

Summary

I'm looking into creating an IDE that lets users, ranging from school children to programmers, write and visualize assembly programs. I am researching this on the side for myself and my employer to see if it's feasible because it would be used as a daily driver internally as well by me. It makes a lot more sense to target the ISA itself than to target 2^"f\** me") software configurations on modern PC's.

Feature Summary

The first feature is that users can create assembly programs using a visual programming environment. Mnemonics are abstracted into their logical actions while the IDE provides a soft guidance for the user when creating code. At any point in time though, one can swap to the source file for a given ISA and updates there will update the visualization and translations in real-time. The internal text editor would likely use an LSP server for the source code highlighting, autocompletion type features. I would be looking into an AI-based import for x86 but for smaller ISA's a developer can implement a mnemonic logic mapping by filling out an "add mnemonic" form. The displayed operand order in the UI is syntax agnostic but the syntax mapping is specific (global setting though).

Edited for clarity:

The second is that the program and system it's running on have a full visual representation available to the developer. The system visualization is more of a generalized view instead of a literal schematic view.

Lastly, I am trying to keep the internal abstraction friendly with something like JSON-LD (or some RDF friendly format) for the assembly mapping so it only has to be done once. The implementation would initially be done in Unreal Engine and I would want to bootstrap it eventually.

The non-existent roadmap would say that the first thing to do is to get all the IDE features working for a small ISA and a few devices with somewhat related hardware (Commodore 64, Game Boy, and Game Gear for example). Once the bugs are worked out on the small scale, implement the x86 and ARM general purpose instructions.

The part where I am a little lost (probably very lost) is when moving into modern features (execution engines, micro-ops, pseudo-ops) and parallelization. Up until multi-core processors are popular, just about everything can be driven using the loop of "fetch->decode->execute". After those hit the market, emulating things start getting complicated (I think) because of timings (who accesses what, when, and where times too many) and new hardware features. Some hardware features (branch prediction for example) aren't necessary if the application is designed in a certain way or some unorthodox features are given a safe interface (like self-modifying code). By ignoring the now-unused hardware features (and throwing it into a "we don't simulate this" catch-all visualizer) it should reduce the complexity of the newer ISA implementations. Companies don't want to make hardware info publicly available so there are a lot of newer features that can't be implemented but for most regular programs this shouldn't be an issue.

Feedback

Any feedback is appreciated, the main thing that's concerning me is since I have not used raw assembly for a serious project, this looks "too good to be true". I'm the only one in the company (at the moment) that is able to bounce between our regular high-level projects and a super low-level one like this but I've hit my limit without writing code so I need to get more eyes on it.

​