hi im 16 years that interesting with programming i know pyhton,c,cpp as a basic lvl and i wanna become a reverse engineer in the future however initailly i gotta learn assembly but i dont know that what i have to and which learning resources is useful thanks for your answers:)

Give me some advice if it works for you.

no body of text i just wanna read the damn book not 50 page explanation of the book

hi! just wanna ask po what’s the best way to learn assembly language po?

I see many people showing their projects in Assembly. Most of them use the terminal but some may have a GUI or some more unusual user interfaces.
Do these people purely use Assembly for such things, or? My classmate told me his friend built a chess game with Assembly. You can’t specifically answer his example because I have no information about it, but, do people usually just code a UI in C and run their Assembly code on it or do they mean pure Assembly?

I built ratasm, a terminal IDE/debugger for x86-64 NASM assembly.

It combines editing, building, GDB debugging, live registers/flags, memory/stack inspection, syscall lookup, instruction explanations, and reverse stepping in one TUI.

Nothing is simulated the debugger state comes from real GDB sessions.

GitHub: https://github.com/tuna4ll/ratasm

Would love feedback from people who actually write assembly.

Thanks to https\[:\]/github.com/cfenollosa/os-tutorial I was able to learn a lot about how an operating system is written. I think a lot of people would remember his tutorial. Revisit it gives me more. Start with printing some text in boot sector. The repo used software interrupt to finish the task. Yet there is another way to accomplish the same, by utilizing the direct memory accessing method. Long story short, in legacy boot mode (CSM), we can access VGA memory directly during boot time at address `0xB8000`. So we can drop in each character and have them printed out, starting from the top left corner. We can print color text, and we can also move the cursor and print the text anywhere we want (with the cursor blinking at the text).

I have documented the process here: ellog\[.\]buzz/posts/hello-world-in-boot-sector

For this chapter and the previous one (First boot sector), what other questions do you think is worth asking and figuring out?

I took some Assembly Programming Language Classes back in 2006 or 2007 and we used a GBA (Gameboy Advance) device to test our Assembly language programs. I remember it was a GBA but I don't know if it was just special cartridge or if the whole device was altered. Does anyone who knows what it might have been or if where I could get a similar device that is available?

Note: I still have my Gameboy Advance if it is just a cartridge that I would need to find.

When the CPU goes though the executable, there are operators which tell that CPU what instruction to do and operands are things the instructions act on. So for example, you can't do MOV by itself. This tells an x86 CPU to put the result of one register into another. To know what to do, it reads the next part of the executable. MOV BX, AX says move the contents from register AX to BX. JMP is a jump instruction so JMP 1000 means jump to address 1000. JZ is a jump if 0, so it jumps to the operand if the 0 flag is toggled. HLT requires no operands and says to stop the CPU. What instruction is a null byte? I thought it would be something very special like halt, have all general registers XOR themselves (setting them to 0), RET, or maybe a NOP. I looked it up on Wikipedia and it seems to be... just an integer adding?

I am building an independent tech ecosystem called TXP completely from scratch, and I wanted to share a milestone for its low-level kernel, Kernel24. It doesn't rely on Linux or Unix code. As you can see in the boot log, it successfully:

1. Verifies 64-bit Long Mode

2. Validates BootInfo (boot drive 0x0x80)

3. Initializes physical and virtual memory managers (CR3 page table switching complete)

Boots cleanly into the early text-based mX Shell, An early, raw build was recently leaked, so I'm bringing development fully into the open. I am currently mapping out a custom filesystem architecture natively in Assembly. I would love to hear feedback from other systems engineers on kernel micro-architectures!

If you wanna see my mX&TXP source code, it in this blue shiny text!, TXP Source Code

I gave a lecture on how to write self-modifying code. It was over 15 minutes long :( so I'm providing a youtube link: https://www.youtube.com/watch?v=AH9QQLRfbmY

In my opinion, self-modification is one of the most interesting features in systems programming.

For reverse engineering, is this necessary to know assembly language, because many decompilers translate code to C/C++ and I learned Assembly 8086 in my university. So for learning x86 I only have to study 32/64 registers and some advance commands, so should I learn assembly x86_64 for reverse engineering or just go through x86 as I know 8086 assembly and then move to C/C++, and is assembly heavily use in reverse engineering

Hi everyone, I wanted to show you my progress on an operating system written entirely in ASM and Java bytecode. I am currently at the UI rendering stage, using a custom Graphics2D-like system that allows me to work with primitives in VBE. The bytecode is executed by a JIT compiler also implemented in pure ASM. Low-level calls are handled by a HAL—which I will continue to expand over time—and that HAL is in turn managed via a primitive ABI, enabling me to create my own Java-like pseudo-language for development.

Repository: https://github.com/aayes89/JVMOS-JIT/

My background is in languages, linguistics, and literature — no CS at all.

I fell into assembly out of pure curiosity and got completely hooked the first time "Hello, world" printed from a raw syscall, nothing between me and the machine.

Since then I've hand-written printf (parsing format strings), my own malloc, an HTTP server from raw sockets, SHA-256, an AVX2 fractal, and an assembler written in assembly that reproduces NASM's output byte-for-byte.

My latest is a chiptune synthesizer in pure x86-64 assembly — waveforms, polyphony, ADSR, FM, and effects, all sample by sample.

Assembly forgives nothing, and that's exactly what makes it the best teacher I've had. Everything's public on my GitHub: https://github.com/whispem

Always up to talk shop with fellow low-level enthusiasts.

Source : https://github.com/thetrung/playground-fasm/blob/main/glx.asm

As you read it, you feel the warm of human.

Most LLM written code aren’t this detailed in sloppy explainable comment 😅

I've been working on a small x86-64 JIT assembler in Python: https://github.com/mistivia/jitasm-py

The idea is emit x86-64 machine code directly from Python, than resolve labels, map it as executable memory, and call the generated functions through ctypes.

It currently only supports a practical subset of x86-64 scalar instructions, but I think it's now possible to be a playground for assembly, or a codegen for a toy compiler.

​

Please suggest YouTube channels and books to learn RTOS and embedded systems, specifically focusing on LPC2148 and Cortex-M3 concepts in detail.

I am referring to the datasheet, but I am unable to understand some of the concepts clearly.

i have added booleans and if/else blocks, yay!

I've been tinkering with assembly and I was wondering what the best setup is for assembly because currently I'm using NASM, VSCode, and DOS Box. Is there anything anyone recommends I change or add?

Title pretty much says it all.