R
rxi
rxi.github.io · Personal blog · on HN since 2020
rxi is a programmer who writes implementation notes on small C libraries and tools like microui and the Lite text editor.
What HN saysHN commenters cite it for the cached software rendering technique and microui's split between UI logic and draw commands, which they found useful and reused.
22HN people shared it
12linked it in comments
13stories submitted
22story points
5 months agolast shared
2020people per year2026
Most-shared posts
- 1Cached Software Rendering5 people · 1 points · first shared 2020 · discussion on HN
- 2Lite: An Implementation Overview4 people · 5 points · first shared 2020 · 1 comments on HN
- 3Microui v2: An Implementation Overview (2020)4 people · 2 points · first shared 2023 · discussion on HN
- 4Textbox Behaviour2 people · 6 points · first shared 2024 · discussion on HN
- 5Microui v2: An Implementation Overview2 people · 2 points · first shared 2020 · discussion on HN
- 6Cached Software Rendering2 people · 2 points · first shared 2020 · discussion on HN
- 7Homepage2 people · first shared 2020
- 8Level Generation Using Markov Chains1 people · 2 points · first shared 2021 · discussion on HN
- 9A Simple Serialization System1 people · 1 points · first shared 2024 · discussion on HN
- 10A Simple Undo System1 people · 1 points · first shared 2024 · discussion on HN
What HN people wrote when they linked it
bjconlan · 2023-03-10
Beyond the rendering which as noted is nothing that hasn't been done before (in general) the inherent OT/multi user + tree sitter functionality is something that entices me.
I'm surprised nobody pointed out lite/litexl here either it's rendering of ui is very similar (although fonts are via a texture; like a game would) and doesn't focus overly on the GPU but optimises those paths like games circa directx9/opengl 1.3
There are great details of the approach taken with lite at https://rxi.github.io
Lite-xl might have evolved the renderer but the code here is very consumable for me.
bvisness · 2024-12-20
This is a delightful take on a style of UI I really love. Separating the UI logic from drawing with a set of draw commands is an excellent and very versatile idea - I first saw it in microui, and the separation allowed me to easily use the library in the browser using WASM and Canvas2D. (https://rxi.github.io/microui_v2_an_implementation_overview.html)
Also, doing layout in WASM and rendering to HTML is a great idea that I can't believe I never thought of before.
aethy · 2022-10-12
The UI is done using an immediate rendering model.
It is entirely composed of two rendering operations, drawing solid color rects, or rendering text from a true type font.
You can read a bit about the underlying technology here: https://rxi.github.io/cached_software_rendering.html
It's quite brilliant.
jmiskovic · 2026-06-17
dsp_person · 2024-08-24
> IMGUI does not mean it needs to refresh all-or-nothing.
The author of microui described an interesting approach to this here https://rxi.github.io/cached_software_rendering.html
JonChesterfield · 2022-12-28
Interesting discussion of rendering from one of related projects at https://rxi.github.io/cached_software_rendering.html
auraham · 2022-10-12
I would like to know more details about how the UI is build. So far I have found this [1]. A tutorial-like post will be welcome, though.
[1] https://rxi.github.io/lite_an_implementation_overview.html
x13pixels · 2022-10-12
If you are interested, the write up on the cached software renderer used in Lite is written up here: https://rxi.github.io/cached_software_rendering.html
panic · 2021-02-14
It's easy to skip drawing frames when no state changes, and for frames where state does change, you can use techniques like rxi's cached software rendering to avoid redrawing the entire screen: https://rxi.github.io/cached_software_rendering.html
mometsi · 2021-01-10
A related project is Lite, a graphical text editor that's a bit further along the frontier of useful features vs code simplicity.
It includes lua 5.2 and SDL.
On top of that, it's a few c files to handle input and rendering, and a set of neatly written lua modules for the logic.
Repo and author write-up:
https://github.com/rxi/lite
https://rxi.github.io/lite_an_implementation_overview.html
slmjkdbtl · 2020-09-21
rxi · 2020-05-09
Not even that: SDL just provides a pixel buffer, the application draws everything itself per-pixel. Lite uses a technique I refer to as "cached software rendering" which allows the application code to be written as if it's doing a fullscreen-redrawn when it wants to update, the renderer cache (rencache.c) then works out which regions actually need to be redrawn at the end of the frame and redraws only those. You can call `renderer.show_debug(true)` to show these redraw regions: https://youtu.be/KtL9f6bksDQ?t=50
I wrote a short article detailing the technique here: https://rxi.github.io/200402.html