frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

Let's Learn x86-64 Assembly (2020)

https://gpfault.net/posts/asm-tut-0.txt.html
209•90s_dev•8h ago•41 comments

Show HN: Refine – A Local Alternative to Grammarly

https://refine.sh
24•runjuu•1h ago•5 comments

Show HN: Ten years of running every day, visualized

https://nodaysoff.run
347•friggeri•3d ago•144 comments

OpenCut: The open-source CapCut alternative

https://github.com/OpenCut-app/OpenCut
291•nateb2022•9h ago•85 comments

Emergent Misalignment: Narrow finetuning can produce broadly misaligned LLMs

https://arxiv.org/abs/2502.17424
88•martythemaniak•7h ago•25 comments

A Century of Quantum Mechanics

https://home.cern/news/news/physics/century-quantum-mechanics
19•bookofjoe•3d ago•4 comments

The underground cathedral protecting Tokyo from floods (2018)

https://www.bbc.com/future/article/20181129-the-underground-cathedral-protecting-tokyo-from-floods
97•barry-cotter•3d ago•30 comments

How does a screen work?

https://www.makingsoftware.com/chapters/how-a-screen-works
396•chkhd•16h ago•79 comments

APKLab: Android Reverse-Engineering Workbench for VS Code

https://github.com/APKLab/APKLab
89•nateb2022•9h ago•4 comments

Black hole merger challenges our understanding of black hole formation

https://gizmodo.com/astronomers-detect-a-black-hole-merger-thats-so-massive-it-shouldnt-exist-2000628197
36•Bluestein•6h ago•31 comments

Show HN: FFmpeg in plain English – LLM-assisted FFmpeg in the browser

https://vidmix.app/ffmpeg-in-plain-english/
73•bjano•3d ago•15 comments

Myanmar’s proliferating scam centers

https://asia.nikkei.com/static/vdata/infographics/myanmar-scam-centers/
50•WaitWaitWha•2h ago•6 comments

A technical look at Iran's internet shutdowns

https://zola.ink/blog/posts/a-technical-look-at-irans-internet-shutdown
153•znano•14h ago•64 comments

Hypercapitalism and the AI talent wars

https://blog.johnluttig.com/p/hypercapitalism-and-the-ai-talent
76•walterbell•10h ago•25 comments

The North Korean fake IT worker problem is ubiquitous

https://www.theregister.com/2025/07/13/fake_it_worker_problem/
258•rntn•18h ago•273 comments

The Scourge of Arial (2001)

https://www.marksimonson.com/notebook/view/the-scourge-of-arial/
25•andsoitis•6h ago•15 comments

Burning a Magnesium NeXT Cube (1993)

https://simson.net/ref/1993/cubefire.html
24•leoapagano•3d ago•4 comments

Stellantis declares bankruptcy in China, with $1B in debts

https://www.italpassion.fr/en/stellantis/stellantis-declares-bankruptcy-in-china-with-1-billion-in-debts/
81•teleforce•4h ago•54 comments

James Webb, Hubble space telescopes face reduction in operations

https://www.astronomy.com/science/james-webb-hubble-space-telescopes-face-reduction-in-operations-over-funding-shortfalls/
63•geox•4h ago•30 comments

GLP-1s Are Breaking Life Insurance

https://www.glp1digest.com/p/how-glp-1s-are-breaking-life-insurance
296•alexslobodnik•12h ago•348 comments

The upcoming GPT-3 moment for RL

https://www.mechanize.work/blog/the-upcoming-gpt-3-moment-for-rl/
194•jxmorris12•4d ago•79 comments

Show HN: A Raycast-compatible launcher for Linux

https://github.com/ByteAtATime/raycast-linux
158•ByteAtATime•14h ago•43 comments

Five companies now control over 90% of the restaurant food delivery market

https://marketsaintefficient.substack.com/p/five-companies-now-control-over-90
205•goinggetthem•10h ago•208 comments

C3 solved memory lifetimes with scopes

https://c3-lang.org/blog/forget-borrow-checkers-c3-solved-memory-lifetimes-with-scopes/
105•lerno•2d ago•75 comments

How to scale RL to 10^26 FLOPs

https://blog.jxmo.io/p/how-to-scale-rl-to-1026-flops
69•jxmorris12•3d ago•4 comments

Show HN: Learn LLMs LeetCode Style

https://github.com/Exorust/TorchLeet
145•Exorust•17h ago•18 comments

Fine dining restaurants researching guests to make their dinner unforgettable

https://www.sfgate.com/food/article/data-deep-dives-bay-area-fine-dining-restaurants-20404434.php
82•borski•15h ago•152 comments

Show HN: ArchGW – An intelligent edge and service proxy for agents

https://github.com/katanemo/archgw/
38•honorable_coder•1d ago•7 comments

Monitoring My Homelab, Simply

https://b.tuxes.uk/simple-homelab-monitoring.html
130•Bogdanp•3d ago•45 comments

Does showing seconds in the system tray actually use more power?

https://www.lttlabs.com/blog/2025/07/11/does-showing-seconds-in-the-system-tray-actually-use-more-power
172•LorenDB•13h ago•146 comments
Open in hackernews

Let's Learn x86-64 Assembly (2020)

https://gpfault.net/posts/asm-tut-0.txt.html
208•90s_dev•8h ago

Comments

90s_dev•8h ago
I came to the party way to late. A month ago, I found out asmjit was a thing, and now it's happily embedded in my app. But I don't know assembly! I tried to learn a few times since the early 2000s but the timing was never right. But hand written asm as a feature fits perfectly into my upcoming app, so now I am on a roll learning assembly! Here are some more resources I found so far:

https://news.ycombinator.com/item?id=22279051

https://sonictk.github.io/asm_tutorial/#introduction/setting...

https://cs.brown.edu/courses/cs033/docs/guides/x64_cheatshee...

https://people.freebsd.org/~lstewart/articles/cpumemory.pdf

https://learn.microsoft.com/en-us/cpp/build/x64-calling-conv...

enjoytheview•5h ago
Here's a really good free one:

OpenSecurityTraining2 Architecture 1001: x86-64 Assembly

https://p.ost2.fyi/courses/course-v1:OpenSecurityTraining2+A...

They also have RISC-V and many other for debuggers and reverse engineering tools (ida/ghidra for example)

Razengan•8h ago
I wish there were more articles and resources about modern ARM assembly. Not that I ever will or have programmed in Asm, but I like learning about it and imagining I will, and Intelisms feel so archaic and crusty in comparison.
90s_dev•8h ago
The first HN link in my comment addresses that. The short version: learn the earliest asms first, then progressively learn the newer ones until you get to today, and none of the knowledge will be wasted. Kind of like fast-forwarding.
mjevans•7h ago
I wouldn't say you are wrong, but I would also postulate.

The smallest, simplest, 'useful' (in terms of useful enough that lots of devs did good work with it and thus it might also be 'popular') ASM sets are probably also sufficient to start with. Provided you've got a good guide to using them, and also ideally a good sheet for why given instructions are packed the way they are in binary.

I do agree you're more likely to find pointers to such resources in more classic architectures. They're also more likely to be easy to find free copies of useful literature.

throwaway31131•6h ago
I'm not sure how "useful" or "good" the work is. But some one instruction computers have a considerable amount of tooling already in place.

i.e. https://esolangs.org/wiki/FlipJump

Flip Jump is amazing. I understand the theory and how it works but it still amazes me that it does. Things like this is why I love the science in computer science.

And subleq even has a c-compiler and operating system, just wow. https://en.wikipedia.org/wiki/One-instruction_set_computer#S...

spauldo•7h ago
Any reason for ARM specifically? There are a lot of microcontrollers out there that fairly simple but without Intel's crustiness. Atmel, for instance. And if you decide to actually try experimenting with them you can get yourself set up for it for less than $100.
throwaway31131•6h ago
https://shop.elsevier.com/books/computer-organization-and-de...

It's currently 50% off and not only will you learn ARM, and some history about ISAs in general, but you'll learn more about how the computer itself works.

And if ARM isn't a hard requirement, an older edition that uses RISCV as the core ISA is a free download.

https://www.cs.sfu.ca/~ashriram/Courses/CS295/assets/books/H...

Highly recommended.

pmxi•3h ago
The first link was the textbook I used for my computer architecture course last semester and I concur. This was the first time our professor taught ARM instead of x86_64 because he believes ARM is the future.
slashtom•2h ago
I learned on the MIPS processor, computer organization / architecture one of the most challenging CS courses for me. I don't remember much but I definitely remember the mips pipeline...
lauriewired•5h ago
This is my own channel, but I made a 10+ part series on modern ARM assembly you may find interesting. I used CPUlator for the demonstrations, which is a nice way to inspect the memory as well as the individual registers as you are running a program.

All runs in the browser:

https://youtube.com/playlist?list=PLn_It163He32Ujm-l_czgEBhb...

WalterBright•3h ago
I'm learning AArch64 assembly in the process of writing a code generator for it. godbolt.org is a great resource for "how do I do this?" Write a short function, run it through godbolt.org, see the instructions generated, lookup the instructions in the spec:

https://www.scs.stanford.edu/~zyedidia/arm64/encodingindex.h...

It'll be my keynote presentation at the D conference next month.

Asm2D•8h ago
I think AsmGrid has a great overview of X86 and AArch64 instructions:

  - https://asmjit.com/asmgrid/
electroglyph•7h ago
wow, that's great. thanks for sharing!
__alexander•7h ago
I haven’t seen this site before. Thanks for sharing it.
rfl890•7h ago
Felix Cloutier's page has always been my go-to
mananaysiempre•6h ago
For x86 encodings, there’s also http://ref.x86asm.net/index.html and of course the venerable https://sandpile.org/.
gnabgib•7h ago
(2020) Discussion at the time (180 points, 38 comments) https://news.ycombinator.com/item?id=24195627
nice_byte•5h ago
Author here. The final part of this series is still sitting in my drafts.

It was nominally supposed to be about flow control instructions, but as it goes with those things, it spiralled and ended up touching on relocations, position-independent code, aslr... One on these days I'll clean it up and post it

90s_dev•4h ago
Please do!
pm2222•4h ago
>> Additionally, the higher 8 bits of rax, rbx, rcx and rdx can be referred to as ah, bh, ch and dh.

Did you mean “ax, bx, cx, dx”?

anamexis•4h ago
Those would be the lower 8 bits, no?
pm2222•3h ago
ax=ah:al eax=?:ax rax=?:eax
grg0•3h ago
It's neither. al is the lower 8 bits of ax (ah the higher 8 bits). ax is the lower 16 bits of eax. eax the lower 32 bits of rax.

Here's the AMD manual: https://docs.amd.com/v/u/en-US/40332-PUB_4.08

wunused•3h ago
In a 64 bit register, e.g., RAX, AL refers to the lowest 8 bits [0-7] and AH refers to the next 8 bits [8-15].

Together, AX refers to bits [0-15]. EAX refers to [0-31].

It's counterintuitive (or at least, inconsistent) that we have a name for bits [8-15] but not for [16-31] or [32-63]. My fuzzy understanding is that this came about from legacy decisions.

This page has a helpful visualization at the top: https://www.cs.uaf.edu/2017/fall/cs301/lecture/09_11_registe...

ordu•3h ago
ax, bx, cx, dx are 16 bit registers referring to the lower 16 bits of rax, rbx, rcx, and rdx respectively. Bits 0..8 can be referred as al/bl/cl/dl, bits 8..16 as ah/bh/ch/dh.
wunused•3h ago
It's ambiguous, but I believe the comment you are replying to suggests that the sentence should read:

>> Additionally, the higher 8 bits of ax, bx, cx and dx can be referred to as ah, bh, ch and dh.

mixmastamyk•3h ago
Let's learn RISC-V assembly!

- https://en.wikipedia.org/wiki/RISC-V_assembly_language

- https://asm-docs.microagi.org/risc-v/riscv-asm.html

- https://riscv-programming.org/

- https://github.com/riscv-non-isa/riscv-asm-manual

dapperdrake•3h ago
AArch64/Arm64 assembly:

https://mariokartwii.com/armv8/ch11.html

urda•3h ago
It's always a great way to get a better understanding of things but at least just poking around assembly a bit once. You do not have to make a project or anything big, but do not be afraid to check it out.
pjmlp•2h ago
Thankfully Intel syntax.
Cockbrand•1h ago
Now I'm curious - what other syntaxes are there?
jabr•1h ago
AT&T

* https://imada.sdu.dk/u/kslarsen/dm546/Material/IntelnATT.htm

* https://en.wikipedia.org/wiki/X86_assembly_language

pjmlp•1h ago
The other one, is a clunky one from UNIX world point of view on x86 CPUs, follow the links on the sibling comment.

Rather clunky and most UNIX Assemblers were never as powerfull as other systems macro assemblers, since after UNIX System V, it was there only as an additional external tool pass for the C compilation steps, and even before that, the assembler was quite minimalist.

Then there is the whole brain twist of being used to op dest, src, and having to switch into op src, dest.

I prefer the Intel approach as it is more similar to dest = src, rather than src -> dest.

Intel's approach is also more common across various assembly languages.

vivzkestrel•2h ago
Spectacular post, are you planning to add sections on reverse engineering executables because this definitely looks pretty close
nice_byte•2h ago
(i am the author) not to this series, but the very first post on the blog is an example of a simple reverse-engineering exercise: https://gpfault.net/posts/ripping-sprites-from-super-cyborg....
nayuki•1h ago
I wrote one: https://www.nayuki.io/page/a-fundamental-introduction-to-x86...
shikaan•55m ago
Something similar, but you can play with the examples in the browser without any local setup https://shikaan.github.io/assembly/x86/guide/2024/09/08/x86-...

For full disclosure, I am the author - apologies for the shameless plug

LtdJorge•8m ago
It's cool. Do you sanitize the untrusted input? As far as I can see, it directly assembles with NASM and runs the binary.
fracus•21m ago
I'd love to fool around in assembly but I can't think of anything interesting to do with it.
timonoko•6m ago
I had quite entertaining session with ChatGPT and recursive fibonacci in nasm. We found out that C-version was twice as fast. So no returning back to year 1975.

"Higher language version is easier to optimize, because machine gets better idea what you are aiming at." said Lex Fridman et al.