Toyota Developing A Console-Grade, Open-Source Game Engine - Using Flutter & Dart
Well, here’s an unexpected combination… Toyota’s Toyota Connected North America unit is developing a console-grade open-source game engine. Making it even more unusual is their engineering choices of building around the Flutter toolkit and in turn the Dart programming language. This new game engine creation is called Fluorite… ⌘ Read more

Krita 6.0 Beta Released - Using Qt6 & Wayland Color Management Support
The first beta release of Krita 6.0 is now available for this featureful digital painting program. Krita 6.0 is re-based against the Qt6 toolkit while Krita 5.3 Beta is also being released at the same time for those sticking to Qt5… ⌘ Read more

NetBSD’s Kernel Supports Lua Scripting But Don’t Look For Rust In There Anytime Soon
For those not fond of the increasing use of the Rust programming language within the Linux kernel or FreeBSD’s considerations for Rust in its kernel, you can perhaps find refuge within NetBSD. One of the NetBSD developers has explained why you likely won’t be finding Rust code within the NetBSD kernel anytime soon… ⌘ Read more

Intel ISPC 1.30 Released With AMX Support Added To The Standard Library
Intel ISPC 1.30 is now available as the latest feature update to their Implicit SPMD Program Compiler as a variant of the C programming language to easily target their array of CPUs and GPUs… ⌘ Read more

Microsoft’s New Open-Source Project: LiteBox As A Rust-Based Sandboxing Library OS
Microsoft engineers and other stakeholders have been developing LiteBox as a security-focused library OS written in the Rust programming language and leveraging Linux Virtualization Based Security “LVBS”. The design is for LiteBox to operate as a secure kernel protecting the normal guest kernel via virtualization hardware… ⌘ Read more

Adobe Is Killing A Popular Animation And Game Development Program
Adobe has emailed users of Adobe Animate to let them know the popular animation and game development program will be discontinued on March 1, an abrupt decision that has angered animators and game developers who say the tool remains an industry standard in television and game production.

Animate, the successor to the once-popular Flash, is wid … ⌘ Read more

Rust Coreutils 0.6 Brings Increased Compatibility, Removing Some Unsafe Code & More Perf
Following the Rust Coreutils presentation from FOSDEM this weekend, Rust Coreutils 0.6 is now available as the latest feature release for this Rust programming language re-implementation of GNU Coreutils… ⌘ Read more

EU Deploys New Government Satcom Program in Sovereignty Push
The EU “has switched on parts of its homegrown secure satellite communications network for the first time,” reports Bloomberg, calling it part of a €10.6 billion push to “wean itself off US support amid growing tensions.”

SpaceNews notes the new government program GOVSATCOM pools capacity from eight already on-oribit satellites from France, Spain, It … ⌘ Read more

Blue Origin Announces Two-Year Pause in Space Tourism - to Focus on the Moon
TechCrunch reports:

Jeff Bezos’ space company Blue Origin is pausing its space tourism flights for “no less than two years” in order to focus all of its resources on upcoming missions to the moon, the company announced Friday. The decision puts a temporary halt on a program that Blue Origin has been using to fly humans … ⌘ Read more

GNU gettext Reaches Version 1.0 After 30 Years
After more than 30 years of development, GNU gettext finally “crossed the symbolic ‘v1.0’ milestone,” according to Phoronix’s Michael Larabel. “GNU gettext 1.0 brings PO file handling improvements, a new ‘po-fetch’ program to fetch translated PO files from a translation project’s site on the Internet, new ‘msgpre’ and ‘spit’ pre-translation programs, and Ocaml and Rust programming l … ⌘ Read more

GNU gettext Reaches Version 1.0 After 30+ Years In Development - Adds LLM Features
Sun Microsystems began developing gettext in the early 1990s and the GNU Project began GNU gettext development in 1995 for this widely-used internationalization and localization system commonly for multi-lingual integration. While GNU gettext is commonly used by countless open-source projects and adapted for many different programming languages, only an hour ago was GNU gettext 1.0 finally released… ⌘ Read more

RFC Patches Posted For Klint Integration With The Linux Kernel: Rust-Based Linting Tool
A request for comments (RFC) patch series was sent out today for providing Klint integration with the Linux kernel. Klint is a new linting tool written in the Rust programming language that helps with static code analysis for errors/bugs as well as code styling inconsistencies… ⌘ Read more

OpenAI Releases Prism, a Claude Code-Like App For Scientific Research
OpenAI has launched Prism, a free scientific research app that aims to do for scientific writing what coding agents did for programming. Engadget reports: Prism builds on Crixet, a cloud-based LaTeX platform the company is announcing it acquired today. For the uninitiated, LaTeX is a typesetting system for formatting scientific docume … ⌘ Read more

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:

https://movq.de/v/1d155106e2/s.png

(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