making some good progress on dwarf debug info for in my compiler backend rat, the example below has been compiled and linked with ratcc (my c99 frontend) and linked with ratl (my simple linker) . https://github.com/hexratcc/rat

I've been doing some 6502 assembly programming lately, which is fun! But, I had an idea for a modern systems programming language inspired by Odin for the 6502: https://danb91.github.io/posts/6502-language-proposal/

My C compiler, Lance, can now compile dwm (a window manager for Linux) with no modifications to source code.
Lance's in-house ELF linker was also used to link dwm successfully into a final executable!
The video (taken on my phone camera obviously) shows a Lance-compiled dwm starting and some mouse interaction

We're getting somewhere! basic PBR rendering from GLTF models in DX12 with textures, an infinite grid for reference and camera logic
I anticipated a pitfall I had in the previous engine, where the renderer received data in absolute world space and in F32,
here coordinate space is in doubles F64, and the shader receives positions in relative render space to the camera position.

My C compiler, Lance, always had a very annoying thing about it.
That is, it couldn't process system headers because the frontend didn't support many features that are required to do so.
Now, after some added features and a lot of bug fixes, system headers (located in /usr/include, /usr/include/bits, etc), like stdio.h, can be fully processed by my compiler (at least on this machine)
This eliminates the need for making my own compatibility bindings on libc, as Lance can now use the system's C headers. Very satisfying
To showcase this, I made the compiler self-host using only system C headers, completely removing the includes to my custom compatibility bindings. SHA-256 sums between generations match as well.

Made a new release of Pixel Art App. Can drag/drop canvases on the animation timeline & undo/redo them.
https://makinggamesinc.itch.io/spixl-pixel-art-editor/devlog/1738352/new-release

My C compiler, Lance got decent preprocessor and linker updates recently
Lance's custom ELF linker now supports linking .a archive files and automatically chooses whether to use .so (dynamically-linked) or .a (static) versions of a library whenever -l is present in the command.
The example shown has libraylib.a statically linked in (including GLFW), with X11 dynamically linked in.
The preprocessor now allows #if, allowing expressions like defined(SOME_MACRO) && val > 10 to be evaluated in the preprocessing stage.
The new preprocessor allows much better compatibility with ordinary C code (for example, rlgl.h as shown in the video) without having to modify them greatly.

Game Design is hard! Trying to work out the how everything connects to make it a playable game. Originally had the idea for a big overworld/town where you did jobs for people but seemed to 'busy'. So trying more a simple approach to go to the 'runner' world, then maybe you get a square added as you progress in the game.

Drew the tree and wind swirl animations recently.

Getting back to it, reviving my 3D project after a year, this time in Odin, and I'm using the opportunity to also learn a few new things;
This is a loaded GLTF model rendered with DirectX 12 in Odin.
-# of course, all handmade

My compiler backend rat can now compile sqlite.c and does so ~17x faster than clang (both -O1), with -O0 its about 4x faster (looking into some areas to improve here).

In my benchmark suite (CoreMark, PolyBench, wren, c-ray), ratcc -O1 is only about 26% slower than clang -O1 and within 5% of gcc -O1

I'm also working on an slp pass for rat as part of my bachelor's thesis, the current results are promising: I'm getting about 4x speedup on focused kernel benchmarks over base rat (this is comparable to clang/gcc with slp on/off, adjusting for rat's missing optimizations). I'm also capable of packing some kernels clang/gcc don't attempt to, and my pass is about 15x faster than LLVM's 🐀

https://github.com/hexratcc/rat

My C compiler Lance has much prettier error messages now (GCC/Clang style), with notes added as well

Release video for :silvernode: SilverNode 0.9 is out!

↩️ Undo for everything
🎨 Skin tones on the vectorscope
🖼️ Alternative edits
🎯 A white balance picker
✨ …and a lot more

https://www.youtube.com/watch?v=N-nQhwdpmZo

&silvernode

I drew and added a teleporter to my game, the first step to try and link the 'overworld' to the 'underworld' type world.

Blick version 0.4 is released!

The biggest additions:

New Features:

• Scripting (beta):
  • a script server lets a program on the same computer control Blick: read the project, add and edit clips, set effects and keyframes, and render. Turn it on in Settings > Scripting > Enable script server. It needs a Blick license.
  • Blick listens on 127.0.0.1 only, on a random port, with a new token for each start. The documentation has the message format, the commands and a full Python client.
• Image sequences:
  • import numbered images, for example frame_0001.png and frame_0002.png, as one clip. Use File > Import Image Sequence, or drop the files or a folder onto Blick.
  • When you drop numbered files, an import window lists each run of frames. For each run, choose One clip, Separate images or Skip, and set the frame rate.
  • Each sequence has its own frame rate. It starts at the project frame rate, and you can change it in the Media table.
  • Proxies and Gather media work with image sequences. The proxy of a sequence has no alpha channel.
• Markers:
  • comments pinned to a time in the timeline ruler. Hold M and click to add a marker, or press Shift+M to insert one at the playhead. Hold M and drag a marker to move it.
  • Click a marker to write its text. The text shows in full when you zoom in and shrinks to a flag when you zoom out. The right click menu changes the color of a marker or deletes it.
  • Markers snap to clip edges and to the playhead, and clips snap to markers. A project holds up to 256 markers, and they are saved with it.
• Clip sync:
  • select clips and choose Set as synced in the right click menu. Blick remembers how these clips line up, and they show a sync icon.
  • When a synced clip is out of line with its group, its icon changes. Move into sync moves the clip back, and Slip into sync slips its content back. Clear sync removes the clip from its group.
• Flip and mirror: Flip horizontal and Flip vertical in the right click menu of the Monitor, and as actions. Drag an edge of a clip past the opposite edge in the Monitor to mirror it, or set a negative Scale. This also works for text clips.
• Render failure reports: when a render fails, a window shows the reason, what to try, and the details. Blick also tells you when it had to change a setting, for example when it rendered 8-bit because the encoder has no 10-bit output.
• Selectable effects: select effects in the Effect panel, Ctrl+A selects all of them. Copy the selected effects, and paste them with or without their keyframes.

Plus many keyframe, timeline and Monitor improvements, a Window menu on macOS, and bug fixes.

Full changelog: https://blickeditor.com/changelog#v0-4-0
Scripting docs: https://blickeditor.com/documentation#scripting
Download: https://blickeditor.com/download
https://youtu.be/1A17acZLmB8
&blick

I added more optimizations to my C compiler, Lance
Specifically, CSE and while-loop autovectorization.
When CSE is enabled, the compiler generates much more efficient code, reusing previously computed expression results.
The compiler also self-hosts well even with these new optimizations enabled, with SHA-256 hashes matching between each self-build generation's object files.
Here is a demonstration of this new optimization in action. (I don't show while-loop autovec here because it would take too much space in the image!)

the classic "raylib dvd demo" written in my new toy language transpiled to C

Zeiger Beta 0.2.0:

New Features:

• Camera raw support with LibRaw, for 25 raw formats, for example DNG, CR2, CR3, NEF, ARW, RAF, ORF and RW2:
  • Zeiger develops the sensor data, or shows the camera preview in the file. R or the RAW button switches between the two, and Settings > Camera raw sets the default.
  • The camera preview shows first, and the development replaces it when it is ready. When LibRaw cannot develop a file, the preview stays.
  • Lossless, deflate (also floating-point) and lossy DNG files open.
  • The Properties window shows the camera data of raw files.
  • Save writes your edits as a PNG file next to the raw file.
  • The Windows installer can register raw files with Zeiger, with a new file icon. On macOS, Zeiger registers them itself.
• DDS textures: texture arrays, cube maps and cube map arrays, with full control over each layer, face and mip:
  • A small cube net shows the six faces of a cube map. Click a face to show it.
  • Step through cubes, layers and mips in the control row at the bottom: hover a part and turn the mouse wheel, or click and drag over its step lines.
  • Each mip shows exactly as it is in the file, at all zoom levels.
  • Shift+Left and Shift+Right go to the previous and next mip, Shift+Up and Shift+Down to the previous and next layer or face.
  • The pixel grid, the color picker, Save and Copy image use the selected layer and mip.
• Shift+Left and Shift+Right step through the frames of an animation.
• BNG support (bngformat.org): Zeiger opens BNG files, and Save As can write them.
• New settings: scale small images up in Fit mode, keep or remember pan and zoom between images, show hidden files, disable UI animations, and open maximized. Settings also has buttons for the open-source licenses and the log folder.

Improvements:

• New edit panel with a histogram: black point, midtones and white point, as in the Levels tool of image editors, plus contrast and saturation. Brightness and hue are removed.
• Color picker: hold Alt (Option on macOS) over the image, or set it to toggle. It shows the pixel as loaded and as it shows with your edits. Right-click switches between the two, left click copies the value, and the scroll wheel changes the format.
• Copy image includes your rotation, crop and edits, the same as Save.
• Zeiger and its files are now 7 MB instead of 22 MB. Zeiger has its own FFmpeg build with only the image formats.

Bugfixes:

• Fix Zeiger opening too small to fit the UI.
• Fix Copy image not working on macOS.
• 10-bit DDS files (R10G10B10A2) show the correct colors on Windows.
• DDS files with one mip level in formats other than 8-bit and 16-bit RGBA now show correctly on all GPUs. Zeiger no longer makes its own mips for DDS files, so a large DDS file with one level can show aliasing when you zoom out.
• Zeiger now runs on Intel Iris graphics and other GPUs with fewer Vulkan features.
  &zeiger

Download it at https://zeigerviewer.com/

I added AVX2 for-loop auto-vectorization to my C compiler, Lance
Here is GCC -O0 vs Lance -O3 (new optimization flag! enables autovec)
At first it was SSE1-4 autovectorization, but that turned out to not provide gains at all. AVX2 is far less disappointing!
Function calls can also be auto vectorized, through function inlining. Non-inlined function calls will prevent auto-vectorization
And of course with AVX2 comes AVX2 instruction encodings, which have been added to my custom instruction encoder as well

I've written my first blog about the register allocator in my compiler backend rat - you can read it here https://hexrat.cc/pages/blog/2026_10_07, any feedback is appreciated :)

Smaller update, but my C compiler now allows #include of <stdlib.h>, <math.h>, etc, without having to explicitly include Lance's custom libc headers.
This means that I can directly copy-paste raylib example code straight from the website and have it run correctly without any modifications, which I think is pretty cool(tm)
There's also progress on auto-vectorization, coming soon in a -O3 flag near you

Lots of UI progress on my TTRPG note taking tool - implemented a hashless immediate mode UI (see Anton's video) just to see how it would work with my api, and it's going great! Then added panelling and tabs. And I'm now getting around to taking my earlier "looks like" prototype and turning it into something you can actually edit. Rich text editing is coming next. This all serializes and persists to disk already as well.

&Muze First steps towards a "practicing" mode. Also implemented some first editing commands.

making some good progress on dwarf debug info for in my compiler backend rat, the example below has been compiled and linked with ratcc (my c99 frontend) and linked with ratl (my simple linker) . https://github.com/hexratcc/rat

I've been doing some 6502 assembly programming lately, which is fun! But, I had an idea for a modern systems programming language inspired by Odin for the 6502: https://danb91.github.io/posts/6502-language-proposal/

My C compiler, Lance, can now compile dwm (a window manager for Linux) with no modifications to source code.
Lance's in-house ELF linker was also used to link dwm successfully into a final executable!
The video (taken on my phone camera obviously) shows a Lance-compiled dwm starting and some mouse interaction

I made some updates to &painter over the last couple weeks, trying to get it in good shape before beta week. Improvements include:

• Add support for layers
• Eraser tool
• File menu
• Allow creating a new image with a custom canvas size

Alright time to formally announce &rcut, a completely new take on GUI frameworks. It will be part of the beta week this month, if you want to give it a early try.

Top left is the default theme I designed, the other three are generated simply by changing the default colors.

For example:

r_theme_default(ctx, &(r_draw_theme_options){ .background = r_rgba_u8(242, 239, 232, 255), .primary = r_rgba_u8(47, 125, 109, 255) });

This results in the green'ish theme on the bottom right.

Aside from a few vector icons nothing is embedded in the executable, all the UI themes are generated from code when the application is started. This allows changing every little thing about the theme from changing the basic colors to the shape, shadows, borders, etc. of every single element.

The second screenshot showcases making minor adjustments to a theme while keeping the other properties at their default value:

r_theme_default(ctx, &(r_draw_theme_options){ .background = r_rgba_u8(27, 35, 51, 255), .primary = r_rgba_u8(61, 139, 253, 255) });
r_theme_tweak(ctx, R_STYLE_BUTTON | R_VARIANT_BOLD);
r_theme_fill(ctx, r_rgba_u8(61, 209, 115, 255), r_rgba_u8(73, 171, 227, 255));
r_theme_label_color(ctx, 0xFFFFFFFF);
r_theme_build(ctx);
r_theme_build_states(ctx, R_STATE_HOVER | R_STATE_PRESSED);

&Muze getting ready for beta-week :)

Working on the retained-mode UI system for my game.

I've implemented two UI elements: a quick-slot panel and an inventory panel.

I've also improved the UI debugger, which now allows me to inspect the entire UI tree structure.

The inventory panel uses the nine-patch rectangle technique, allowing its texture to scale correctly, even at higher DPI scales.

Quick slots currently use simple colored rectangles as placeholders.

The UI system uses a tree structure to organize parent-child relationships.

The layout system uses two passes:

1. Measure pass: Collects the desired sizes of elements, starting with the children and working up to their parents.
2. Arrange pass: Calculates the actual positions and sizes based on alignment options. This time, we start with the parent and work down to the children, allowing us to distribute the available space correctly.

I use a breadth-first traversal algorithm to render UI elements.
I specifically chose breadth-first traversal over depth-first traversal because it allows me to group elements at the same hierarchy level into a single draw-call batch.

We're getting somewhere! basic PBR rendering from GLTF models in DX12 with textures, an infinite grid for reference and camera logic
I anticipated a pitfall I had in the previous engine, where the renderer received data in absolute world space and in F32,
here coordinate space is in doubles F64, and the shader receives positions in relative render space to the camera position.

My C compiler, Lance, always had a very annoying thing about it.
That is, it couldn't process system headers because the frontend didn't support many features that are required to do so.
Now, after some added features and a lot of bug fixes, system headers (located in /usr/include, /usr/include/bits, etc), like stdio.h, can be fully processed by my compiler (at least on this machine)
This eliminates the need for making my own compatibility bindings on libc, as Lance can now use the system's C headers. Very satisfying
To showcase this, I made the compiler self-host using only system C headers, completely removing the includes to my custom compatibility bindings. SHA-256 sums between generations match as well.

Made a new release of Pixel Art App. Can drag/drop canvases on the animation timeline & undo/redo them.
https://makinggamesinc.itch.io/spixl-pixel-art-editor/devlog/1738352/new-release

My C compiler, Lance got decent preprocessor and linker updates recently
Lance's custom ELF linker now supports linking .a archive files and automatically chooses whether to use .so (dynamically-linked) or .a (static) versions of a library whenever -l is present in the command.
The example shown has libraylib.a statically linked in (including GLFW), with X11 dynamically linked in.
The preprocessor now allows #if, allowing expressions like defined(SOME_MACRO) && val > 10 to be evaluated in the preprocessing stage.
The new preprocessor allows much better compatibility with ordinary C code (for example, rlgl.h as shown in the video) without having to modify them greatly.

Game Design is hard! Trying to work out the how everything connects to make it a playable game. Originally had the idea for a big overworld/town where you did jobs for people but seemed to 'busy'. So trying more a simple approach to go to the 'runner' world, then maybe you get a square added as you progress in the game.

Drew the tree and wind swirl animations recently.

Getting back to it, reviving my 3D project after a year, this time in Odin, and I'm using the opportunity to also learn a few new things;
This is a loaded GLTF model rendered with DirectX 12 in Odin.
-# of course, all handmade

My compiler backend rat can now compile sqlite.c and does so ~17x faster than clang (both -O1), with -O0 its about 4x faster (looking into some areas to improve here).

In my benchmark suite (CoreMark, PolyBench, wren, c-ray), ratcc -O1 is only about 26% slower than clang -O1 and within 5% of gcc -O1

I'm also working on an slp pass for rat as part of my bachelor's thesis, the current results are promising: I'm getting about 4x speedup on focused kernel benchmarks over base rat (this is comparable to clang/gcc with slp on/off, adjusting for rat's missing optimizations). I'm also capable of packing some kernels clang/gcc don't attempt to, and my pass is about 15x faster than LLVM's 🐀

https://github.com/hexratcc/rat

hand writing an ASCII 3D renderer to refresh my C skills and also because it's fun.

LLM usage: An LLM (Opus 4.8) was used to clarify direction, syntax, critique, find/understand bugs, learn about algos and generally drill down questions, etc

I wrote a blog post on how we do UI rendering in Blick!
You can check it out on our blog. :blick:

https://fixupx.com/Blick_Editor/status/2112901886408049148

My C compiler Lance has much prettier error messages now (GCC/Clang style), with notes added as well

Release video for :silvernode: SilverNode 0.9 is out!

↩️ Undo for everything
🎨 Skin tones on the vectorscope
🖼️ Alternative edits
🎯 A white balance picker
✨ …and a lot more

https://www.youtube.com/watch?v=N-nQhwdpmZo

&silvernode

This fall, we’re trying something new. Join us November 16-22 for the first-ever Handmade Network Beta Week, a focused week of testing and improving software made by the community.

The idea started as we were trying to make jam plans for the fall like usual. Normally we’d do our annual Wheel Reinvention Jam, but we wanted to change up the theme. As we thought about other topics, we realized there is an enormous number of projects in the community now that are significantly more mature than a mere side project, but not yet “shipped” and ready for others to use. We’re always inspired by community members who do ship, so what if we did something to help community members get their software to that point?

The format of the Beta Week is pretty simple: project authors apply to participate, and community members apply to test. Then, for one week, we just go all in on using and testing the software, reporting bugs, fixing bugs, and

We are thrilled to officially welcome six amazing new software projects to the Handmade Network! It's been a long time since we've added anything new to the Projects page, but despite our negligence, the community has been hard at work building some truly amazing software.

So let's get into it!

Blick is a new video editor made by Dihedron, a new startup led by Wassim Alhajomar. Community members already know Wassim as the creator of two other official HMN projects, AV-Racer and Cactus Image Viewer, and for Blick he has assembled a team of Handmade programmers to tackle industry juggernauts like Premiere Pro and DaVinci Resolve.

As is typical of aggressively Handmade software, despit

We in the Handmade community have been, shall we say, slow adopters of AI. In a Discord post early this year, I wrote that the community has generally responded to AI with apathy—we like programming, so why automate the thing we enjoy? Some people use it, some people don’t, many people find value in it without compromising their programming values. But as time goes on, and more new members join the community, we are concerned about the erosion of community values, and long-time members are growing frustrated at the frequent appearance of outright slop in #project-showcase.

We feel it is time to clearly define what we see as acceptable and unacceptable use of AI in this community. We are not opening the floodgates nor banning it outright, but we are clearly defining some practices that we feel are unacceptable. The Handmade Network feels different from other programming communities; our goal with this policy is simply to keep it that way.

You can read the full policy in detail

It is crazy to think that the Handmade Network Expo was over a month ago already. The past few months have been a delightful whirlwind for us, full of new problems and quick decisions. It’s been a lot of work, but it has been very gratifying.

At the time of this writing, we have just finished publishing all the recordings from the Expo, and with that, I feel it’s time for a bit of a retrospective. This was a significant event for us, and it happened at an interesting time in the history of the Handmade community, and of the software industry in general. It would be a shame to let it go by without some reflection.

This post will be a bit long, but I hope you find it interesting and worthwhile. It just doesn’t feel right to move on too quickly.

The context

While far from the first-ever in-person “Handmade” event, the Handmade Network Expo was the first event ful

Thanks to everyone who participated in the Handmade Essentials Jam last month! It was our biggest jam turnout ever, and there was lots of energy on the Discord as everyone was sharing updates about their projects. We just published the recording of the recap stream, so give that a watch if you’d like to see several of our favorite submissions:

https://youtu.be/kcQN_uYbyjE

The Essentials Jam is yet another case of people really resonating with challenges that make them a better programmer. (I hate to use the term “tradcoding”, but, here we are.) Our Handmade Hero Replay group is going strong too (a Handmade Hero book club, basically). More and more people keep joining the Discord server (we’re over 10k members now!) and whether they are a seasoned programmer or a fresh college dropout, they are all eager to be part of a community that actually cares about the craft of programming.

There’s a moment in the early episodes of Handmade Hero that I particularly enjoy. On da

We’re pleased to announce that ticket sales for the Handmade Network Expo are now open!

The Handmade Network Expo is our first-ever in-person event. We didn’t want to just run another “conference”; after all the years of Abner running Handmade Seattle (and our subsequent split), we weren’t interested in having a typical lineup of tech talks. Our favorite part was always the demos: real Handmade software made by members of the Handmade community. So in that spirit, we decided to make an event that was all demos, all the time.

You can find all the details on the event page, but the short version is that it’s one day in the heart of Vancouver, with a flexible schedule full of small demos, and plenty of opportunities to show off your own work, learn from others, experiment with new ideas, and generally celebrate Handmade software. Tickets are just $100, but space is limited. If

TL;DR:

• The first-ever Handmade Network Expo will take place on June 6, 2026
• Join us in re-watching Handmade Hero! (starting February 7, 2026)
• A few thoughts about Handmade's position in the industry

We are very excited to announce the Handmade Network’s first-ever in-person event: The Handmade Network Expo!

2025 was a quiet year for us where we focused on the fundamentals of the community: jams, projects, a healthy community, and interesting discussions. But we love seeing other people in person, and were sad that we didn’t have the opportunity last year. So we decided it was time to bring people together again, and with our renewed focus on real, tangible Handmade software, a day of demos seems like the perfect fit.

So: Join us in Vancouver, BC on June 6, 2026, for a day packed with demos, discussion, socializing, and celebrating the achievements of the talented programmers of the Handmade community!

(By the way, don't miss more news at t

Hello Handmade Network, and happy new year! 2025 was a relatively quiet year for us where we focused on just running our jams and building relationships across the Handmade community. But we’ve got lots of plans for 2026 and we’ve already been at work kicking them off!

TL;DR:

• We are finally launching the Handmade Software Foundation and using it to support the development of more Handmade software
• We’re planning an in-person gathering for this spring, more details forthcoming
• We’ll be doing two jams as usual, dates TBD based on other events

Launching the Handmade Software Foundation

A few years ago we announced that we were creating a nonprofit to support the development of Handmade software. Well, it took some time, but I am pleased to announce that the Handmade Software Foundation is now officially a 501(c)(6) nonprofit corporation.

What does this mean? It means we are a nonprofit under the category carved out for business leagues, chambers of commer

Happy fall to everyone in Handmade! I hope you had a wonderful summer, and that you spent the perfect amount of your summer writing amazing Handmade software. Ideally you were actually outside enjoying the sun and the air while doing this, and ideally you climbed a mountain or jumped in a lake afterward—but if this is wishful thinking, then I hope you at least have some cool software to show for it.

Fall is a wonderful season for Handmade, because it means that we get to do another Wheel Reinvention Jam. And this is our fifth annual WRJ!

For me, the Wheel Reinvention Jam is one of the most important things we do as a community, because it reminds us that wheels do need to be reinvented, and that even the most ambitious projects need to start somewhere. I wrote this on the jam page, but whe

It's June 9, and that means that the X-Ray Jam has officially begun!

Participants have one week to make a project that exposes the inner workings of software. If this is your first time hearing about it, it's not too late to participate! Head over to the jam page to find more information about the theme, submission instructions, and inspiration to get you started.

After the jam, we plan to do another recap show like usual. The show is tentatively scheduled for Sunday, June 22, one week after the conclusion of the jam, but stay tuned for official confirmation.

We look forward to seeing all the updates this week!

-Ben