Fabian Giesen
fgiesen.wordpress.com · Personal blog · on HN since 2011
Fabian Giesen, a game and demoscene programmer at RAD, writes on graphics pipelines, low-level optimization, compression and data structures.
What HN saysHN commenters call it a blog where they enjoyed nearly every article, and single out "Metaprogramming for madmen" as a favorite.
200HN people shared it
119linked it in comments
189stories submitted
4.6Kstory points
3 months agolast shared
2011people per year2026
Most-shared posts
- 1A trip through the graphics pipeline (2011)42 people · 218 points · first shared 2012 · 24 comments on HN
- 2Metaprogramming for madmen30 people · 313 points · first shared 2012 · 20 comments on HN
- 3Homepage12 people · first shared 2013
- 4The Magic Ring Buffer (2012)11 people · 89 points · first shared 2015 · 21 comments on HN
- 5Software Occlusion Culling9 people · 3 points · first shared 2014 · discussion on HN
- 6A whirlwind introduction to dataflow graphs8 people · 186 points · first shared 2018 · discussion on HN
- 7How many x86 instructions are there?7 people · 295 points · first shared 2016 · 87 comments on HN
- 8Reading bits in far too many ways7 people · 124 points · first shared 2018 · 15 comments on HN
- 9Oodle 2.9.14 and Intel 13th/14th gen CPUs7 people · 28 points · first shared 2025 · 1 comments on HN
- 10A lot of “being smart” consists of getting comfortable with feeling stupid7 people · 9 points · first shared 2016 · 1 comments on HN
- 11Content Creator7 people · 7 points · first shared 2025 · discussion on HN
- 12Texture tiling and swizzling7 people · 3 points · first shared 2011 · discussion on HN
- 13Why do CPUs have multiple cache levels?6 people · 419 points · first shared 2016 · 121 comments on HN
- 14Networks all the way down6 people · 19 points · first shared 2014 · 1 comments on HN
- 15Thoughts on the Witness (2016)5 people · 93 points · first shared 2016 · 74 comments on HN
What HN people wrote when they linked it
moregrist · 2026-02-13
It clearly didn’t come out of game dev. Many people doing high performance work on either embedded or “big silicon” (amd64) in that era were fully aware of the importance of locality, branch prediction, etc
But game dev, in particular Mike Acton, did an amazing job of making it more broadly known. His CppCon talk from 2014 [0] is IMO one of the most digestible ways to start thinking about performance in high throughput systems.
In terms of heroes, I’d place Mike Acton, Fabian Giesen [1], and Bruce Dawson [2] at the top of the list. All solid performance-oriented people who’ve taken real time to explain how they think and how you can think that way as well.
I miss being able to listen in on gamedev Twitter circa 2013 before all hell broke loose.
[0] https://youtu.be/rX0ItVEVjHc?si=v8QJfAl9dPjeL6BI
[1] https://fgiesen.wordpress.com/
[2] https://randomascii.wordpress.com/
leeoniya · 2021-01-08
for those who don't know, Fabian Giesen (@ryg of demoscene group https://en.wikipedia.org/wiki/Farbrausch) works at RAD.
his blog: https://fgiesen.wordpress.com/
one of my favorites: https://fgiesen.wordpress.com/2012/04/08/metaprogramming-for-madmen/
vog · 2017-05-24
Speaking of Fabian Giesen, his whole blog is worth a read:
https://fgiesen.wordpress.com/
This is one of the very few blogs where I enjoyed reading every single article.
amiga386 · 2025-11-17
Picture the scene: you have a 102KiB executable game that you want to enter into the 96KiB-or-less game competition at a demoparty in 2 weeks time. You and your friends have been working on this for months. This amazing thing you have is currently 6KiB too large to qualify for the competition at all. What do you do?
https://fgiesen.wordpress.com/2012/04/08/metaprogramming-for-madmen/
Now it makes sense.
jesse__ · 2025-10-11
So, you're saying they built a novel storage architecture that competed with state-of-the-art consumer hardware, at a lower price point. Five years later, laptops are just catching up, and that at the same price point, it's faster than what you'd expect from a PC.
The compression codec they licensed was built by some of the best programmers alive [0], and was later acquired by Epic [1]
I dunno how you put those together and come up with "isn't really fast" or "not particularly innovative".
Fast doesn't mean 'faster than anything else in existence'. Fast is relative to other existing solutions with similar resource constraints.
[0] https://fgiesen.wordpress.com/about/ [1] https://www.epicgames.com/site/en-US/news/epic-acquires-rad-game-tools
kevingadd · 2025-02-28
I strongly recommend https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p… if you're curious about GPU architectures. Though in the 14 (!) years since, a lot has changed still.
In the modern era the 'compute shaders' part of that has become more dominant and lots of fixed function parts of the graphics pipeline have moved to software.
I'd love to see a more modern take on this if someone has run across it.
CoastalCoder · 2024-11-15
Here's some reading that I personally have found helpful for optimizing parallel programs:
The best I've found so far:
https://cdn.kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbo…
And some other good reading:
https://www.amazon.com/Systems-Performance-Brendan-Gregg/dp/0136820158
https://fgiesen.wordpress.com/2014/08/18/atomics-and-contention/
https://travisdowns.github.io/blog/2020/07/06/concurrency-costs.html
smokel · 2024-11-01
For those not in the know, things only get faster with this approach when you apply some optimization. The article that we are discussing won't get there until part 12.
For the time being one may consult Ryg's amazing blog series: https://fgiesen.wordpress.com/2013/02/10/optimizing-the-basic-rasteriz…
sitkack · 2024-08-16
Single best post on the LoE that the programmers went through to fit it into 96kb https://fgiesen.wordpress.com/2012/04/08/metaprogramming-for-madmen/
previous discussions https://hn.algolia.com/?dateRange=all&page=0&prefix=true&q…
All the wonderful posts for that blog https://news.ycombinator.com/from?site=fgiesen.wordpress.com
azornathogron · 2024-06-05
GPUs don't rasterise line-by-line like old software renderers, and they basically only know how to rasterise triangles. If you're rendering on GPU then I think the approach in the article is pretty good, despite its apparent complexity.
This is a great series of blog posts about how GPU based rendering is structured (long but excellent if you're interested):
https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p…
Part 6 is about rasterisation.
speps · 2024-01-24
The backstory written by one of the authors is worth a read: https://fgiesen.wordpress.com/2012/04/08/metaprogramming-for-madmen/
wly_cdgr · 2023-11-23
The details are outdated now, I guess, but I don't know if there's any more inspiring reading for an aspiring graphics programmer than Fabian Giesen's "A trip through the graphics pipeline" https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p…
As for a place to actually start, I think Computer Graphics From Scratch is a good place https://www.gabrielgambetta.com/computer-graphics-from-scratch/. A great thing about the book is it gives you many ideas for where to go next once you work your way through to the end.
AntiRush · 2023-09-05
There’s an awesome write up of some of the tools written specifically for this demo.
https://fgiesen.wordpress.com/2012/04/08/metaprogramming-for-madmen/
Probably worth a discussion in its own right: https://news.ycombinator.com/item?id=37386377
pixelpoet · 2023-06-27
Always worth linking to ryg / Fabian Giesen: https://fgiesen.wordpress.com/2012/07/21/the-magic-ring-buffer/
nicopappl · 2022-10-15
You'd definitively be interested by the ryg[1] series on the graphic pipeline. It goes in details about how bits get to the GPU and how the GPU handle them. The author writes that using a 3D graphics API is a prerequisite. To the contrary, the series itself is great to get a grasp on things and not feel completely alienated by 3D graphics APIs if you ever decide to use one in the future. It's fairly old (2011) but I still see it recommended as a relevant resource today.
[1] https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p…
Const-me · 2022-06-05
Not quite a book, but if you already know, at least to some extent, some 3D GPU API, I can recommend this series of blog posts: https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p…
dundarious · 2022-05-15
Fabian Giesen's always excellent blog has a post about various ring buffer implementations: https://fgiesen.wordpress.com/2010/12/14/ring-buffers-and-queues/
He has a companion post about a "magic" ring buffer that uses a virtual memory mapping to make a ring buffer where you can always address the entire sizes as contiguous memory, but I think it has a bit of minor bit rot in the linked implementations. https://fgiesen.wordpress.com/2012/07/21/the-magic-ring-buffer/
JBits · 2022-03-15
Another great series from fyg is https://fgiesen.wordpress.com/2013/02/17/optimizing-sw-occlusion-culli…
I'd not come across the state machine site before, it looks pretty useful.
flohofwoe · 2022-03-07
This should really be titled "Introduction to WebGL". The GL programming model is very different from what's actually going on under the hood. GL it at best a faint reminder of how GPUs worked during the 90's.
This is by now also over a decade old but still gives a much better idea how current GPUs work:
https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p…
wolf550e · 2021-05-26
Of course there is comparison with LZ4: http://www.radgametools.com/oodlemermaidselkie.htm
LZ4HC is LZ4 compressed with the slow compressor to achieve better compression. It is decompressed using regular LZ4 decompressor.
They also compare with zstd and lzma, which are the open source competition.
I don't know what "specs" you think are missing. They do say which architectures are supported, what the memory use is, whether multi-threading is supported, etc.
No public price, true.
You can read the blogs of the people who work on this code to get a feel for the caliber:
https://cbloomrants.blogspot.com/
https://fgiesen.wordpress.com/
These are known people with known reputation. The product itself is well known in the industry.
Jasper_ · 2021-02-22
I believe you're getting confused. There's no bit string reversal in DEFALTE, it just changes your shift slightly. Both MSB and LSB have their advantages and disadvantages.
As always, ryg has great posts on this stuff: https://fgiesen.wordpress.com/2018/02/19/reading-bits-in-far-too-many-…
news_to_me · 2021-02-03
Yeah I find this method way easier to understand than scan conversion. Fabian Giesen has a great series of articles from 2011 that explains it well[0].
Also the original 1988 paper by Pineda is a surprisingly easy read, and it's only 4 pages![1]
[0]: https://fgiesen.wordpress.com/2011/07/06/a-trip-through-the-graphics-p…
[1]: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.157.4621&…
jo032 · 2021-01-07
fabien giesen, also at RAD, has a very informative blog as well. https://fgiesen.wordpress.com/
they have a seriously impressive group of developers
pheelicks · 2020-12-26
I have a few articles on my blog (and will be adding more related to the Procedural GL JS) library: www.pheelicks.com
I would also very much recommend:
- https://webglfundamentals.org
- https://www.iquilezles.org
- https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p…
- Reading the code on shadertoy.com shaders & THREE.js examples
lifthrasiir · 2018-11-26
I like Charles Bloom's blog, but I'm not sure if it's very approachable (after all, it's "rants" :-). If you want more diversity in the readings, ryg blog [1] makes good reading. Start with the most recent series on efficiently reading bits [2].
[1] https://fgiesen.wordpress.com/category/compression/
[2] https://fgiesen.wordpress.com/2018/02/19/reading-bits-in-far-too-many-…
monocasa · 2018-07-25
https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p…
is a great intro to GPU architecture that I think answers your question indirectly.
It's mainly just command FIFOs, semaphores, and cache flushes. Vulkan's API is a pretty good high level approximation of current architecture.
corysama · 2018-05-22
I’m not quite what you are looking for, but I might ping you at some point looking to trade questions for questions :)
In the meantime, I thought you might appreciate this guy’s recent vids: https://www.youtube.com/channel/UCcRaa0AcYX32c0m8wJJHNWg/videos?disabl…
I’m definitely a fan of his blog https://fgiesen.wordpress.com
gp7 · 2017-09-02
https://fgiesen.wordpress.com Most of his posts end up on the first page of hn. In fact there is one right now
http://nullprogram.com/ makes C look fun
eln1 · 2016-09-04
Golomb-Rice with base M is prefix code optimal for approximately geometric probability distribution
Pr(x) ~ sqrt(2)^(-Mx).
Arithmetic coding or FSE/tANS would allow to use the actual probability distribution. The question is how large the gain could be - how far from Shannon is Golomb-Rice for this specific type of data?
If this probability distribution varies, maybe it's worth thinking about adaptive rANS, like in Oodle LZNA and BitKnit: https://fgiesen.wordpress.com/2015/12/21/rans-in-practice/
ps. Is M fixed or adapting?
panic · 2016-04-26
This series of articles doesn't have any costumes, but it's still a good read: https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-p…