Having nothing better to do recently, I developed a simple assembly language and an online playground for it. If anyone fancies having a play, please do: https://www.compassion-in-business.co.uk/learning/assembler.php

queso is an arm disassembler prioritizing historical accuracy on older versions for emulation and retro computing. There are cli, web, vendorable Golang, and vendorable C versions available, hex string and file inputs, and a ton of customizable options including custom register names, address offsets, and arm versions (ARMv1 - ARMv5TE).

https://github.com/aabalke/queso

https://guacemulator.com/queso

A big thank you to everyone who documents, builds, and provides support!

Hello everyone! For the past few years I've been working on ASM editor (github), an IDE for assembly running completely on the web with many architectures available (x86, mips, risc-v, m68k, z80 and more to come) with a lot of debugging features like step by step execution, undo, memory and registers viewers, breakpoints, observability of what each instruction did and much more!

Recently I've added a feature I had dreamed of adding for a long time, C and C++ compilation! It allows you to write C and C++ code (with a subset of libc available), compile it to assembly to see how each line was compiled, to then execute it with all the debugging tools available in the IDE.

I've also added peripherals like a screen, terminal, keyboard, mouse and file system. All of them can also undo to previous steps.

The IDE is used by my university and a few others to teach low level programming and has a lot of useful tools to teach. I've also published a paper about it in an IEEE conference.

It can be embedded in other websites as part of interactive courses or be used to do exams in schools and universities.

I'd love to get opinions/suggestions/feedback about it, please let me know in the comments!

I am a Java programmer, and as a hobby, I want to learn C with a focus on operating systems—specifically to modify existing open-source operating systems like GNU/Linux or BSD.

However, I understand that before learning C, it is a good idea to learn some assembly language. What is the best way to learn x86_64 assembly?

I took an ARM assembly course that was taught at our university in 2023 and loved it. The course was taught really well. The tooling is just old. You SSH into a department server, assemble, run, and get "Segmentation fault (core dumped)" with no line number and no idea which instruction did it.

I ended up TAing it 2 years later, then head TAing it the following semester. In April I started writing an interpreter and a few weeks later it ran real programs.

The hard part was making everything around the instructions match the real server: printf, scanf, m4 macros, the assembler directives. One of my old profs suggested compiling C programs with gcc on the server and checking the playground prints the same thing. The first run passed 0 programs. Most of that was one bug with branches jumping to the wrong place. Now it matches on basically all of them.

You can step through a program one instruction at a time, forwards or backwards. When it crashes, it points at the instruction that did it. Click any instruction to see its 32 bits split into the fields from the ARM manual. There are lessons, and practice problems checked by running your code.

I'd appreciate it if yall could test it out and lmk what you think!

aarch64-playground.com

I started out writing C for the network processors in backbone routers. A lot of that job was not writing anything: it was reading a listing, watching registers, and working out which instruction was not doing what everyone believed it was doing. I liked it more than was reasonable.

I have built a game that is only that. A fictional load/store ISA, fourteen instructions, six registers, a memory grid, memory-mapped ports with settling time. A program written by someone who is now dead. A full recorded trace, which you can step, breakpoint and rewind, and which exists in its entirety the moment you open the case, so you can read the listing, form a theory and jump straight to the tick that proves it.

The design constraint I set myself was that you never write or change anything. The moment you can edit the program it stops being an investigation and becomes a puzzle box. So every tool is read-only, including the one that lets you re-run the tape against sensor values the machine never actually saw, which is marked off the record so it cannot corrupt what you are proving.

The part I would most like this sub's opinion on is the proof. Naming the faulty line is not enough. You also have to classify the mistake and point at the tick where the harm first shows in machine state. That third clause is where everyone struggles, and I am still not sure whether it is too much to ask or just badly explained.

Free, seven cases, about an hour, no download: https://endpaperdev.itch.io/faultfinder-demo

Steam: https://store.steampowered.com/app/5120330/Faultfinder_Demo/

I'm writing a custom assembler for CHIP-8 and just finished adding support for the DB/.byte directive so I can embed sprites in the ROM and finally get something drawn on the screen. It SHOULD support all OG CHIP-8 instructions, but still a ton of rough edges that I'm ironing out.

This is my first ever C++ project, just like the CHIP-8 emulator was my first ever C (and emudev) project. It's so satisfying to write assembly and have your program spit out a ROM that actually runs in the emulator you wrote.

All code is written by me (a lot of it livestreaming) as evident by the quality, no AI.

Repo: https://github.com/Tackx/c8-ass

Hi! has anyone followed the book learn to program with assembly by Jonathan Bartlett using mac silicon? the book said it can be followed using docker in appendix a, but im wondering if anyone here managed to get through with another way.

https://www.amazon.com/Learn-Program-Assembly-Foundational-Programmers/dp/1484274369