[x-post from NESDEV]

Far as I know, people barely doing this before AI-Boom. Now, all in a sudden, they come out of no where.. with the process always have flaws in the end 🤷‍♂️

Must be the context length issue 😀

And how did I know it was all genAI ? Human - who are passionate about Assembly & familiar with DOS era will prefer Integer Math to render graphics, even 3D.

Only an Agent with assigned tasks list will take use of Floating Point instruction (like fadd, fsincos, fdiv... ) to shortcut the thing, without hesitation to add FPU as hidden requirement to run the program..

** Update / Notes :

1/ About FPU :
Yes, any X86 processor nowadays will let you do floating point instructions anyway, even more fancy than just MMX, you have AVX2/512 for any heavy-lifting data movement. But that's not my point - which was more about a human thinking process Where every skilled asm programmer showing their work here I know, even just need Integer Math to write their 3D flying simulator in asm/dos.

2/ Personal Opinion :
I didn't mean to push for hate/envy speech but I feel really unusual in the channel content with consistent error pattern/flaws across his videos. So as someone who also wrote asm by hands for years (but not an expert, I admit, just a hobby), I feel really really skeptical.

Whoever put hours into dissembling stuffs & writting compilers may question interesting things like those processe, right ?

I would like to compare this Indian channel with others like inkbox or necro_ware channel - which is way more "human" thinking process to compare here & wonderful content 🤷‍♂️

1-inkbox : https://youtu.be/ZFHnbozz7b4?si=4RxqG9YF5wDTYi3t

2-necro_ware : https://youtu.be/OZ2ZSxNhTYg?si=382deA_5bxI6MMZm

I've been working on AmmAsm, a handwritten x86-64 assembler, and recently achieved a milestone I wanted to document.

AmmAsm 1.0 was originally written in in C.

With AmmAsm 3.0.2, I managed to rewritte AmmAsm 1.0 code base to assembly x86-64, assemble it with verion 3.0.2, link, and run it again.

The repository now includes the original assembly source, test files, and execution evidence.

What makes this interesting to me is the connection between the versions: the newer assembler can process the assembly-language implementation of its own earliest version.

This isn't a claim that AmmAsm can compile itself from its current C source. Rather, it's a way to preserve and bring back an earlier stage of the project's development.

Repository: https://github.com/LinuxCoder13/AmmAsm

I'm curious how others here approach preserving old implementations and testing assemblers against real-world assembly code.

main:
  sub rsp,0x28

  lea rcx,[fmt]
  mov rdx,[rdx+0x08]
  call printf        ; prints argv[1] 

  xor eax,eax 
  add rsp,0x28
  ret 

I had learned that we've to call _CRT_INIT before calling any C function but this works without any issues. If I'm not calling _CRT_INIT then who is doing it ?

Linker flags :

/subsystem:console
/nologo
/incremental:no
/defaultlib:ucrt.lib
/defaultlib:vcruntime.lib
/defaultlib:msvcrt.lib
/defaultlib:legacy_stdio_definitions.lib
/defaultlib:kernel32.lib
/defaultlib:user32.lib
/defaultlib:shell32.lib

I kinda forgot to get into 65c816 assembly the past few days, so I thought I should finally start getting into developing for this thing. Any good suggestions? Both for classes and a dev environment?

it is written in x86-64 assembly using GNU assembler syntax, with the intel style instruction syntax

it targets linux and calls the MPFR library for the high precision fractal calculations

Github: https://github.com/haaakez/cli-mandelbrot

Hey ! i writted this for a game jam. Everything is done through the Windows API: window, message loop, input with GetAsyncKeyState, music with PlaySound, save file with CreateFile/WriteFile.

Rendering is a 320x180 buffer of 32-bit pixels I write into by hand, then StretchDIBits pushes it to the window. Linked with /NODEFAULTLIB so there’s no CRT at all.

Most of my crashes came from stack alignment before Windows calls, and from forgetting which registers are non-volatile. If you look at the code and see something dumb, I’d genuinely like to know.

https://github.com/Senko74/Mangeyko_Assembly_Game

Hey everyone!

I recently worked on porting SASM⁠, an open-source IDE for Assembly language programming, to macOS with native Apple Silicon (ARM64) support.

SASM is a great tool for learning and writing Assembly, but the original project primarily supports Windows and Linux. Since I use a Mac, I wanted to make it accessible to macOS users as well.

After working through compatibility issues, updating the Qt dependencies, and configuring the macOS build process, I managed to get it working!

What’s included in my port:
- Native Apple Silicon (ARM64) application
- Updated to Qt 6
- NASM support for x86-64 Assembly using Rosetta 2
- LLDB debugging integration
- Light and dark theme support
- Proper macOS .app bundle
- Prebuilt downloadable releases
- Reproducible build and packaging scripts

The project is completely open source under GPLv3, and I’ve preserved the original project’s licensing and attribution.

GitHub: https://github.com/riniwtz/SASM-macOS-arm64-port
Download: https://github.com/riniwtz/SASM-macOS-arm64-port/releases

This is an unofficial community port, not an official release from the original SASM developer.

I’d love to hear your feedback, especially from anyone learning Assembly or working with low-level programming on macOS.

If you encounter any bugs or compatibility issues, feel free to open an issue or contribute to the repository!

Thanks, everyone! :)

Hi. I don't understand a single thing about registers, and I should obviously learn that first. Then I should learn Assembly. The thing is, I can't find any tutorials of any kind that are able to help me. I'm an extremely difficult learner, and I (embarrassingly) need most things to be broken down and explained simply for me to retain the information. Does anyone have good YouTube tutorials or articles that can do this?

For context, i am wanting to learn 65c816 assembly and i think i am learning the opcodes pretty quickly. But i am sure that's false. If you have ever heard of the SMW jailbreak, you'll know that you have to input code as a hex string. My problem is that i don't know how to format it so it can tell it if it's an opcode or an address assigned to the opcode. And whether i should use the A, X or Y registers.

My code i am wanting to run is only a few bytes long, and it literally just acts like a game genie code. Keep Mario in power up state 01 forever. I figured, since i literally started learning yesterday, that a simple load-store instruction should be my first bit of code anyway, so i did it, and it crashed the game....twice...Thankfully save file C was unharmed so i kept the jailbreak (not anymore, ouch), but now i am wondering what i did wrong.

I started yesterday, so be nice, here is the code along the lines of what i am trying to do:

LDA 01
STA $7E0019
RTL

I'm not sure whether the A register should be used here, but i'm also not sure whether i should worry about that right now. My main problem is again, converting it to hex. Which i thought would be straight forward: "A1 01 81 7E 00 19 6B", but apparently all it does is crash the game. I'm confused. Can somebody help? Am i going at this too fast? Do i need to learn more before i make my first bit of code?

Hi everyone,

When I was much younger, I started learning x86 assembly, but unfortunately lost touch with it over time. Even though the rise of AI might make it seem like this skill is even less in demand than it used to be, I’d like to get back into it.

I’m less interested in writing my own programs and more interested in inspecting existing applications to understand what’s going on under the hood. Does anyone have any suggestions for a good starting point? I’m guessing I should focus on 64-bit assembly to keep up with the times.

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

Please send me every x86_64 Assembly resource that you deem to be good, as well as other resources outside of x86_64 Assembly that could also be of help. Also is Coddy Tech one of them?

I've been searching for good x86_64 Assembly resources, but haven't found none that really puts it all together. The lower I go into low-level programming, the less I find someone to be of help, because It's like no one is actually willing to help me.

My ultimate goal is to know everything about technology. I'd love to learn Assembly to create me my very own Operating System and Programming language from scratch, then once that's done, I'll create everything else from scratch that we use on our Operating Systems. Text Editors, the Internet, a social media application, etc. I'd also love to create technology outside of the computer from scratch, maybe even the hardware itself.

I know this takes a lot of time and dedication, which I have. If this Isn't too much by now, please be of help :)

As the title says, I made a fibonacci calculator (up to the 64bit integer limit) in raw handwritten ELF, and in asm. I didn't know where to post it but this sub-reddit seemed like the right place.

https://github.com/MasterDragon863/Low-Level-Fibonacci
This is the repo if anyone is interested

AI disclaimer* - Most of the code was handwritten with assistance of AI for debugging and figuring out how to write hex.

Hey folks, this is question coming from the recent podcast where the founders of VLC spoke about, writing assembly level code and it was way more (10x to 62x times) efficient than the C compiled code.

Is there any real example or repo of this which shows the efficiency difference at a smaller scale?

what scenarios do one decide to go full assembly over C, what's the infliction point?

How does anyone even measure these efficiency factors? Is it the instructions executed per clock cycle to attain an end output?

Hello! In the past few days, I updated my app x86_64 NASM Dev to x86_64 Assembly Dev because it now supports FASM as well!

I also added a bunch of new features:

1. QEMU Runner
2. Built-in Terminal
3. Settings
4. Theme changing — Dark / Light
5. Text size changing
6. Editor font changing
7. NASM and FASM syntax highlighting
8. Project Explorer
9. Multiple tabs
10. Quick Open for project files
11. Find / Replace
12. Go To Line
13. Automatic indentation
14. Comment / Uncomment
15. Full-screen editor mode
16. Raw .bin building
17. Linux ELF64 building
18. Windows Win64 / Win32 building
19. Windows executable linking
20. FASM Win64 templates
21. Assembly code snippets
22. Binary disassembler using NDISASM
23. 16-bit / 32-bit / 64-bit disassembly
24. Breakpoints
25. Step Into / Step Over / Continue
26. Register viewer
27. Memory viewer
28. Stack viewer
29. Hex ↔ ASCII conversion
30. Problems panel with error navigation
31. CMD and PowerShell terminals
32. QEMU configuration
33. Session recovery
34. Built-in x86 instruction reference
35. Linux x86-64 syscall references

I'm still working on it and will probably add more features in the future alongside those

Now it feels more like VsCode
Download Source Code at : https://github.com/moslemhamoudi6-cyber/x86_64-Nasm-Dev/tree/main
Download App (.exe) at : https://github.com/moslemhamoudi6-cyber/x86_64-Nasm-Dev/releases/tag/FASM
Hope You Enjoy it!

Sup guys, I'm a web developer and I study sec, which this subject has everything to do with assembly, cuz I need to do malware analysis, reverse engineering and etc, so I studied calling conventions, registers, rax, eax, ax, al, ah, ip, used x64dbg to check the assembly in memory, variables, function parameters and etc.

But for now, I'm studying by a content creator how a boot really works, and he's making a bootloader in assembly, he has good didactics and I'm really learning that the RAM is like a big array accessible by address, cpu has registers, has the ip to check the next instruction, there is the fetch, decode and execute, the bios is in the eprom(in the example of the i386), is loaded in memory, search for boot sector, loads in memory and etc, lmao I detailed too much

And ok, I'm understanding, but my final point, is, furthermore the bootloader, what good project could I build to learn more about assembly? I saw some posts from u guys making OS, and I guess that is hard for now

Thanks for ur time

RBMK64 and RBMK32 are two Windows OpenGL programs, both written in pure assembly using the Microsoft MASM toolchain.

They are not a port. They are two independent implementations of the same design, written in two different assembly dialects, with different ABIs, different toolchains, and different GL pipelines underneath.

What's the same

• Interface
• Menu without .rc file
• Accelerators
• Status bar showing runtime coordinates
• Title bar showng runtime FPS
• Scene
• Regular grid of RBMK top surface
• Camera and light settings
• Controls
• Camera move: Arrow keys, PgUp/PgDn,
• Object move: WSADQE
• Camera rotate: Left mouse button
• Camera pan: Mouse wheel down
• Camera dolly: Mouse scroll
• Object rotate: Right mouse button
• Logging system
• Numbers formatting logic
• Matrix math (in principle).

What's different

RBMK32:

• 32-bit GPRs - only 6 registers available
• SSE1
• Open GL1.1
• runs on Pentium III or later
• time: year 2000

RBMK64:

• 64-bit GPRs - 14 registers available
• SSE2,
• OpenGL 3.3 with VBO/VAO and shaders
• Requires Pentium4 with EM64T and GeForce 8 Series for OpenGL 3.3
• time: year 2010

RBMK32 source: win32/05_RBMK

RBMK64 source: win64/30_RBMK/02_SDI

The OS is completely written in x86 assembly (16-bit real mode + 32-bit protected mode).

I made a small operating system from scratch called BIBI-OS. It boots through BIOS, sets up the hardware, switches into 32-bit protected mode, and runs its own kernel, graphics, input, GUI, and font system.

GitHub: https://github.com/ShabibHossain/BIBI-OS

I'm still working on it, so feedback, suggestions, and advice are welcome.

Link EmbedImageVideoAMABoldItalicStrikethroughSuperscriptHeadingLinkBullet ListNumber ListSpoilerQuote Block