Updated Linux Patches For Managing Out-Of-Memory Behavior Via BPF
Being worked on since last year by Google engineer Roman Gushchin was the latest attempt for the Linux kernel to support managing the out-of-memory “OOM” behavior using BPF programs. It’s been a while since there has been anything new to report on that front but published overnight is the latest iteration of those patches… ⌘ Read more

What a beautiful, beautiful 0°C Sunday arvo and evening! The weather forecast delayed the snow by the minute. An hour or so after it finally started very, very lightly, I headed off for the woods to check out the lake again. Unfortunately, with the fresh snow layer, the crazy wild surface texture of the ice sheet wasn’t visible anymore. But it brought some other nice views and photo opportunities.

I initially thought that I just go for a quick turn. However, with the snowfall a wee bit increasing I was hooked and kept going. Visibility was poor, but the snow blankets just looked too stunning. The road surfaces were quite slippery, so I often just walked alongside the pathways. On downhill slopes I had some good fun sliding down the road on my feet. With varying success. Luckily, I managed not to fall.

On the summit of the mountain the twigs had those absolutely magnificently looking windblown crystal coverings. Awwwwwww! They never get old. It was already getting dark, so the camera was tired and wanted to sleep. The snow program then made use of the flash and I’m quite pleased with how these shots turned out.

Two deer crossed the road in front of me and ran into the woods, that was sight for sore eyes. Although I felt bad that they had to flee from me in this white terrain. By the time I got home, the snow had accumulated around eight centimeters in height, even in town down in the valley. Walking on this fresh snow is just amazing. And I love the sound it makes. Today, the snow consistency must have been just right, because the crushing sound was really loud.

I cannot recall that I had frozen hair and beard before, but today, there was a thick ice buildup. In case I had, it was definitely never this much. Felt really cool.

Enough of this preliminary skirmishing, there ya go: https://lyse.isobeef.org/waldspaziergang-2026-01-25/

Another project where I’m going to use my terminal widget toolkit is a hex editor. This is still very young, obviously, and there’s a lot of work to do (both in the toolkit and this particular application), but I’m making some progress:

https://movq.de/v/2bae14ed16/vid-1769283187.mp4

Since this program is UTF-8 clean (I hope), you can do things like enter multi-byte UTF-8 sequences or paste them from the system clipboard (another hex editor I just tried failed to do this correctly):

https://movq.de/v/e9241034c1/vid-1769283755.mp4

Under the hood, I’m using mmap() with MAP_PRIVATE, which is really cool: I get the entire file as a byte array, no matter how large it is, no need to actually read it upfront; and MAP_PRIVATE means that I can write to this area however I like without changing the underlying file. The kernel does copy-on-write for me. Only when you hit Save, it will write to the filesystem. And it’s just a couple lines of code. The kernel does all the magic. 🥳

Zlib-rs 0.6 Released With Improved AVX-512 Support
Zlib-rs is the effort out of the Trifecta Tech Foundation to provide a Zlib compression implementation written in the Rust programming language that can serve as a C dynamic library and Rust crate. The intent here being that zlib-rs is potentially safer than the classic C-based implementation of Zlib… ⌘ Read more

Rust 1.93 Brings Improvement For Inline Assembly Handling
Rust 1.93 is out today as the first feature release for this programming lanugage of 2026… ⌘ Read more

Germany’s EV Subsidies Will Include Chinese Brands
Germany is reinstating EV subsidies after a sharp sales drop, rolling out a 3 billion-euro program offering 1,500-6,000 euros per buyer starting in May and running through 2029. Unlike some neighboring countries, the incentives are open to all manufacturers with a focus on low- and middle-income households. From a report: “I cannot see any evidence of this postulated major i … ⌘ Read more

Myrlyn 1.0 Released For Package Manager GUI Spawned By SUSE’s Hack Week
Myrlyn 1.0 was released today as the package manager GUI developed by SUSE engineers and started out just over one year ago during a SUSE Hack Week event as a SUSE/Qt package manager program not dependent upon YaST or Ruby… ⌘ Read more

Spent basically the entire day (except for the mandatory walk) fighting with Python’s type hints. But, the result is that my widget toolkit now passes mypy --strict.

I really, really don’t want to write larger pieces of software without static typing anymore. With dynamic typing, you must test every code path in your program to catch even the most basic errors. pylint helps a bit (doesn’t need type hints), but that’s really not enough.

Also, somewhere along the way, I picked up a very bad (Python) programming style. (Actually, I know exactly where I picked that up, but I don’t want to point the finger now.) This style makes heavy use of dicts and tuples instead of proper classes. That works for small scripts, but it very quickly turns into an absolute mess once the program grows. Prime example: jenny. 😩

I have a love-hate relationship with Python’s type hints, because they are meaningless at runtime, so they can be utterly misleading. I’m beginning to like them as an additional safety-net, though.

(But really, if correctness is the goal, you either need to invest a ton of time to get 100% test coverage – or don’t use Python.)

Whohoo! 🥳 You have no idea how great a feeling this is! This includes the Mu stdlib and runtime as well, not just some simple stupid program, this means a significant portion of the runtime and stdlib “just works”™ 🤣

Btw @movq@www.uninformativ.de you’ve inspired me to try and have a good ‘ol crack at writing a bootloader, stage1 and customer microkernel (µKernel) that will eventually load up a Mu (µ) program and run it! 🤣 I will teach Mu (µ) to have a ./bin/mu -B -o ... -p muos/amd64 ... target.

Wild 0.8 Linker Adds SFrame Support, LoongArch64 & More Performance
Wild 0.8 is now available as this speedy linker focused on iterative development, a goal of incremental linking, and written in the Rust programming language… ⌘ Read more

Students Increasingly Choosing Community College or Certificates Over Four-Year Degrees
DesScorp writes: CNBC reports that new data from the National Student Clearinghouse indicates that enrollment growth in four year degree programs is slowing down, while growth in two year and certification programs is accelerating: Enrollments in undergraduate certificate and associate degree programs … ⌘ Read more

Burn 0.20 Released: Rust-Based Deep Learning With Speedy Perf Across CPUs & GPUs
A significant update to Burn was released today, the MIT and Apache 2.0 licensed tensor library and deep learning framework written in the Rust programming language. Burn 0.20 brings some low-level changes as it continues to strive to deliver high performance AI across the diverse hardware ecosystem… ⌘ Read more

Even Linus Torvalds Is Vibe Coding Now
Linus Torvalds has started experimenting with vibe coding, using Google’s Antigravity AI to generate parts of a small hobby project called AudioNoise. “In doing so, he has become the highest-profile programmer yet to adopt this rapidly spreading, and often mocked, AI-driven programming,” writes ZDNet’s Steven Vaughan-Nichols. Fro the report: [I]t’s a trivial program called AudioNoise – a recen … ⌘ Read more

I’m trying to implement configurable key bindings in tt. Boy, is parsing the key names into tcell.EventKeys a horrible thing. This type consists of three information:

1. maybe a predefined compound key sequence, like Ctrl+A
   
2. maybe some modifiers, such as Shift, Ctrl, etc.
   
3. maybe a rune if neither modifiers are present nor a predefined compound key exists
   

It’s hardcoded usage results in code like this:

func (t *TreeView[T]) InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
    return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
        switch event.Key() {
        case tcell.KeyUp:
            t.moveUp()
        case tcell.KeyDown:
            t.moveDown()
        case tcell.KeyHome:
            t.moveTop()
        case tcell.KeyEnd:
            t.moveBottom()
        case tcell.KeyCtrlE:
            t.moveScrollOffsetDown()
        case tcell.KeyCtrlY:
            t.moveScrollOffsetUp()
        case tcell.KeyTab, tcell.KeyBacktab:
            if t.finished != nil {
                t.finished(event.Key())
            }
        case tcell.KeyRune:
            if event.Modifiers() == tcell.ModNone {
                switch event.Rune() {
                case 'k':
                    t.moveUp()
                case 'j':
                    t.moveDown()
                case 'g':
                    t.moveTop()
                case 'G':
                    t.moveBottom()
                }
            }
        }
    })
}

This data structure is just awful to handle and especially initialize in my opinion. Some compound tcell.Keys are mapped to human-readable names in tcell.KeyNames. However, these names always use - to join modifiers, e.g. resulting in Ctrl-A, whereas tcell.EventKey.Name() produces +-delimited strings, e.g. Ctrl+A. Gnaarf, why this asymmetry!? O_o

I just checked k9s and they’re extending tcell.KeyNames with their own tcell.Key definitions like crazy: https://github.com/derailed/k9s/blob/master/internal/ui/key.go Then, they convert an original tcell.EventKey to tcell.Key: https://github.com/derailed/k9s/blob/b53f3091ca2d9ab963913b0d5e59376aea3f3e51/internal/ui/app.go#L287 This must be used when actually handling keyboard input: https://github.com/derailed/k9s/blob/e55083ba271eed6fc4014674890f70c5ed6c70e0/internal/ui/tree.go#L101

This seems to be much nicer to use. However, I fear this will break eventually. And it’s more fragile in general, because it’s rather easy to forget the conversion or one can get confused whether a certain key at hand is now an original tcell.Key coming from the library or an “extended” one.

I will see if I can find some other programs that provide configurable tcell key bindings.

C# (and C) Grew in Popularity in 2025, Says TIOBE
For a quarter century, the TIOBE Index has attempted to rank the popularity of programming languages by the number of search engine results they bring up — and this week they had an announcement.

Over the last year the language showing the largest increase in its share of TIOBE’s results was C#.

TIOBE founder/CEO Paul Jansen looks back at how C++ evolved:

From a language … ⌘ Read more

How the Free Software Foundation Kept a Videoconferencing Software Free
The Free Software Foundation’s president Ian Kelling is also their senior systems administrator. This week he shared an example of how “the work we put in to making sure a program is free for us also makes it free for the rest of the world.”

During the COVID-19 pandemic, like everyone everywhere, the FSF increased its videoconferen … ⌘ Read more

@lyse@lyse.isobeef.org It’s not super comfortable, that’s right.

But these mouse events come with a caveat anyway:

ncurses uses the XM terminfo entry to enable mouse events, but it looks like this entry does not enable motion events for most terminal emulators. Reporting motion events is supported by, say, XTerm, xiate, st, or urxvt, it just isn’t activated by XM. This makes all this dragging stuff useless.

For the moment, I edited the terminfo entry for my terminal to include motion events. That can’t be a proper solution. I’m not sure yet if I’m supposed to send the appropriate sequence manually …

And the terminfo entries for tmux or screen don’t include XM at all. tmux itself supports the mouse, but I’m not sure yet how to make it pass on the events to the programs running inside of it (maybe that’s just not supported).

To make things worse, on the Linux VT (outside of X11 or Wayland), the whole thing works differently: You have to use good old gpm to get mouse events (gpm has been around forever, I already used this on SuSE Linux). ncurses does support this, but this is a build flag and Arch Linux doesn’t set this flag. So, at the moment, I’m running a custom build of ncurses as a quick hack. 😅 And this doesn’t report motion events either! Just clicks. (I don’t know if gpm itself can report motion events, I never used the library directly.)

tl;dr: The whole thing will probably be “keyboard first” and then the mouse stuff is a gimmick on top. As much as I’d like to, this isn’t going to be like TUI applications on DOS. I’ll use “Windows” for popups or a multi-window view (with the “WindowManager” being a tiny little tiling WM).

Vacation: Doing crazy things like C on DOS, lots of Rust, bare-metal assembly code, everything is fine.

Back at work: How the fuck do I move an email in this web mail program? Am I stupid? 😮‍💨

@bender@twtxt.net They’re not completely impossible, but C makes it much easier to run into them. I think the key point is that in those “safe” languages, buffer overflows are caught and immediately crash the program (if not handled otherwise) instead of silently corrupting memory, not being noticed right away and maybe only later crashing at a different location, where it can be very hard to find the actual root cause. This is a big improvement in my book.

Some programmers are indeed horrible. I’m guilty myself. :-)

I like the article.

I came across this on “Why Is SQLite Coded In C”, which I found interesting:

“There has lately been a lot of interest in “safe” programming languages like Rust or Go in which it is impossible, or is at least difficult, to make common programming errors like memory leaks or array overruns.”

If that’s true, then encountering those issues means the programmer is, simply, horrible?

@movq@www.uninformativ.de I quite like this part:

Many people write programs, but few stick with a program long enough to distill it.

I think this is finally a good metaphor to talk about “simple” software:

https://oldbytes.space/@psf/115846939202097661

Distilled software.

I quote in full:

principles of software distillation:

Old software is usually small and new software is usually large. A distilled program can be old or new, but is always small, and is powerful by its choice of ideas, not its implementation size.

A distilled program has the conciseness of an initial version and the refinement of a final version.

A distilled program is a finished work, but remains hackable due to its small size, allowing it to serve as the starting point for new works.

Many people write programs, but few stick with a program long enough to distill it.

I often tried to tell people about “simple” or “minimalistic” software, “KISS”, stuff like that, but they never understand – because everybody has a different idea of “simple”. The term “simple” is too abstract.

This is worth thinking about some more. 🤔

And now the event loop is not a simple loop around curses’ getch() anymore but it can wait for events on any file descriptor. Here’s a simple test program that waits for connections on a TCP socket, accepts it, reads a line, sends back a line:

https://movq.de/v/93fa46a030/vid-1767547942.mp4

And the scrollbar indicators are working now.

I’ll probably implement timer callbacks using timerfd (even though that’s Linux-only). 🤔

More widget system progress:

https://movq.de/v/87e2bce376/vid-1767467193.mp4

I like the oldschool shadow effect. 😅 Not sure if I’ll keep it, but it’s neat.

The menu bar is still fake.

Had to spend quite a bit of time optimizing the rendering today. This can get really slow really quickly.

Unicode is Pain.

I might be able to start porting my first program (currently uses urwid) soon. 🤔

Stoolap 0.2 Released For Modern Embedded SQL Database In Rust
Stooplap v0.2 released today as this SQLite alternative for providing embedded SQL database needs while written in the Rust programming language. Stoolap supports both in-memory and persistent storage models… ⌘ Read more

Nice! 😊 Here are the startup latencies for the simplest Mu (µ) program. println("Hello World"):

• Interpreter: ~5ms
  
• Native Code: ~1.5ms

Ncurses 6.6 Released With Improved Windows Terminal Support, Other Enhancements
Ncurses 6.6 was released today prior to closing out 2025. This programming library update for creating terminal-based text user interfaces (TUIs) features a variety of great improvements for ending out the year… ⌘ Read more

NJ’s Answer To Flooding: It Has Bought Out and Demolished 1,200 Properties
New Jersey has found its answer to the relentless flooding that has plagued the state’s coastal and inland communities for decades: buy the homes, demolish them and turn the land back into open space permanently. The state’s Blue Acres program has acquired some 1,200 properties since 1995, spending more than $234 million in feder … ⌘ Read more

@movq@www.uninformativ.de Yeah, I see. Just crudely checked on my computer, with around 0.013 seconds, Python 2.7 seems a tad faster than Python 3.14’s 0.023 seconds in this little program.

The lazy imports sound not too bad, but I just skimmed over them. There are surprisingly many exceptions, but yeah, no way around them. :-)

mu (µ) now has builtin code formatting and linting tools, making µ far more useful and useable as a general purpose programming language. Mu now includes:

• An interpreter for quick “scriptinog”
  
• A native code compiler for building native executables (Darwin / macOS only for now)
  
• A builtin set of developer tools, currently: fmt (-fmt), check (-check) and test (-test).

Things I’ve learned along the way:

1. Writing self-contained and barely tied up programs didn’t go as well as I’d have thought
   
2. Reverse engineering (to put it that way) an open source library
   
3. Acceptance of non-Make build systems

@lyse@lyse.isobeef.org

I assume you made the thing load quickly, didn’t you?

That’s the problem with Python. If you have a couple of files to import, it will take time.

I want this to be reasonably fast on my old Intel NUC from 2016 (Celeron N3050 @ 1.60GHz) and I already notice that the program startup takes about 95 ms (or 125 ms when there are no .pyc files yet). That’s still fine, but it shows that I’ll have to be careful and keep this thing very small …

Python 3.14 will bring lazy imports, maybe that can help in some cases.

Well, you girls and guys are making cool things, and I have some progress to show as well. 😅

https://movq.de/v/c0408a80b1/movwin.mp4

Scrolling widgets appears to work now. This is (mostly) Unicode-aware: Note how emojis like “😅” are double-width “characters” and the widget system knows this. It doesn’t try to place a “😅” in a location where there’s only one cell available.

Same goes for that weird “ä” thingie, which is actually “a” followed by U+0308 (a combining diacritic). Python itself thinks of this as two “characters”, but they only occupy one cell on the screen. (Assuming your terminal supports this …)

This library does the heavy Unicode lifting: https://github.com/jquast/wcwidth (Take a look at its implementation to learn how horrible Unicode and human languages are.)

The program itself looks like this, it’s a proper widget hierarchy:

(There is no input handling yet, hence some things are hardwired for the moment.)

@lyse@lyse.isobeef.org I’m toying with the idea of making a widget/window system on top of Python’s ncurses. I’ve never really been happy with the existing ones (like urwid, textual, pytermgui, …). I mean, they’re not horrible, it’s mostly the performance that’s bugging me – I don’t want to wait an entire second for a terminal program to start up.

Not sure if I’ll actually see it through, though. Unicode makes this kind of thing extremely hard. 🫤

Global Hotel Groups Bet on Customer Loyalty To Beat Online and AI Agents
The world’s largest hotel chains are aggressively pushing customers toward direct bookings as they brace for a future where AI “agents” could reshape how travelers find and reserve rooms. Marriott, Hilton, Hyatt and Wyndham have all expanded their loyalty programs and perks in recent months, aiming to reduce their reliance on onli … ⌘ Read more

44% Of GNOME Core Apps Are Written In C, 13% In JavaScript & 10% In Rust
GNOME developer Sophie Herold has shared some interesting end-of-year code stats for the GNOME project. The “GNOME” codebase is up to 6,692,516 lines of code at the end of 2025 with 1,611,526 lines of that being from GNOME apps. Where the data gets interesting is on the programming language breakdown in different areas… ⌘ Read more

The compiler technique I’m using here is to not “emit” most of the runtime if it’s actually never used in your program, and also dropping dead code in the SSA pass.

@prologic@twtxt.net That might be a challenge, at least in 16-bit Real Mode: The OS follows the model of COM files on DOS, i.e. the size of the binary cannot exceed 64 KiB and heap+stack of the running program will have to fit into that same 64 KiB. 😅 (The memory layout is very rigid, each process gets such a 64 KiB slice.)

And in 64-bit Long Mode, there is no “kernel” yet. The thing in the video is literally just a small bare-metal program.

But some day, maybe. 😃

Driverless Future Gains Momentum With Global Robotaxi Deployments
The global push to put autonomous taxis on public roads is accelerating as ride-hailing companies and technology firms advance from pilot programs toward limited commercial rollouts in cities across China, the United States, Europe and the Middle East.

WeRide and Uber launched Level 4 fully driverless robotaxi operations in Abu Dhabi in Novemb … ⌘ Read more

My little toy operating system from last year runs in 16-bit Real Mode (like DOS). Since I’ve recently figured out how to switch to 64-bit Long Mode right after BIOS boot, I now have a little program that performs this switch on my toy OS. It will load and run any x86-64 program, assuming it’s freestanding, a flat binary, and small enough (< 128 KiB code, only uses the first 2 MiB of memory).

Here I’m running a little C program (compiled using normal GCC, no Watcom trickery):

https://movq.de/v/b27ced6dcb/los86%2D64.mp4

Next steps could include:

• Use Rust instead of C for that 64-bit program?
  
• Provide interrupt service routines. (At the moment, it just keeps interrupts disabled.)

Apple’s App Course Runs $20,000 a Student. Is It Really Worth It?
Apple’s Developer Academy in Detroit has spent roughly $30 million over four years training hundreds of people to build iPhone apps, but not everyone lands coding jobs right away, according to a WIRED story published this week.

The program launched in 2021 as part of Apple’s $200 million response to the Black Lives Matter protests and costs an esti … ⌘ Read more

Google Looks To Upstream Its Propeller Tool To LLVM For More Performance
Google’s Propeller is a profile-guided, reflinking optimizer for large codebases. Propeller is built atop LLVM and can allow for whole-program optimizations. Google compiler engineers are now hoping to bring the Propeller tool into the upstream LLVM codebase… ⌘ Read more

Ruby 4.0 Released With Ruby Box Experimental Feature, ZJIT Compiler
The past several years we have seen new releases of the Ruby programming language implementation for Christmas (25 December). This year is no different with Ruby 4.0 having been released this morning… ⌘ Read more

What Might Adding Emojis and Pictures To Text Programming Languages Look Like?
theodp writes: We all mix pictures, emojis, and text freely in our communications. So why not in our code? That’s the premise of “Fun With Python and Emoji: What Might Adding Pictures to Text Programming Languages Look Like?” (two-image Bluesky explainer; full slides), which takes a look at what mixing emoji with … ⌘ Read more

Micro QuickJS Engine Compiles & Runs JavaScript With As Little As 10kB Of RAM
Very talented open-source developer Fabrice Bellard who already is well known for his work on QEMU, the Tiny C Compiler, and FFmpeg, has another accomplishment: Micro QuickJS. The Micro QuickJS JavaScript engine can compile and run JavaScript programs with as little as 10 kB of RAM… ⌘ Read more

Rex: Proposed Safe Rust Kernel Extensions For The Linux Kernel, In Place Of eBPF
University researchers presented Rex at this month’s Linux Plumbers Conference 2025 in Tokyo. Rex is designed for “safe and usable” Rust-based kernel extensions that could serve in place of eBPF programs for extending the Linux kernel functionality… ⌘ Read more

@kiwu@twtxt.net Assembly is usually the most low-level programming language that you can get. Typical programming languages like Python or Go are a thick layer of abstraction over what the CPU actually does, but with Assembler you get to see it all and you get full control. (With lots of caveats and footnotes. 😅)

I’m interested in the boot process, i.e. what exactly happens when you turn on your computer. In that area, using Assembler is a must, because you really need that fine-grained control here.

Intel ISPC 1.29 Drops Gen9 GPU Targets, Add New Optimizations & Experimental RISC-V
Intel ISPC 1.29 released on Wednesday as the newest feature update to this Implicit SPMD Program Compiler as a C variant able to target Intel hardware from their CPUs to GPUs for SIMD programming… ⌘ Read more

Meta ‘Pauses’ Third-Party Headset Program
Meta has paused its third-party Horizon OS headset program, effectively canceling planned VR headsets from Asus and Lenovo as it refocuses on “building the world-class first-party hardware and software needed to advance the VR market.” Road to VR reports: A little over a year and a half ago, Meta made an “industry-altering announcement,” as I called the move in my reporting: the company wa … ⌘ Read more