JPEG-XL Image Support Returns To Latest Chrome/Chromium Code
After widespread backlash over its 2022 decision to remove JPEG-XL support, Google has quietly restored the image format in the latest Chrome/Chromium codebase. Phoronix reports: Back in December they merged jxl-rs as a pure Rust-based JPEG-XL image decoder from the official libjxl organization. At the end of December they did more JPEG-XL plumbing with the en … ⌘ Read more

JPEG-XL Image Support Returns To Latest Chrome / Chromium Code
To the frustration of many developers and end-users, back in 2022 Google deprecated JPEG-XL support in Chrome/Chromium and proceeded to remove the support. That decision was widely slammed and ultimately Google said they may end up reconsidering it. In November there was renewed activity and interest in restoring JPEG-XL within Google’s image web browser and as of yesterday the code was merged… ⌘ Read more

Bcachefs Ships Latest User-Space Utilities With bcachefs-tools 1.35
Kent Overstreet has shipped the latest version of bcachefs-tools, the user-space code complementing the Bcachefs file-system kernel driver. There are a number of improvements present in this latest version with Overstreet remaining committed to advancing Bcachefs even with its current out-of-tree kernel status… ⌘ Read more

LLVM/Clang 22 Feature Development Ends With Intel Nova Lake, Arm C1 & Ampere1C Support
LLVM/Clang 22 feature development ended overnight with the code now being branched and working toward a stable release likely by the end of February… ⌘ 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.

Linux 6.19-rc5 Brings Fix For Newer NVIDIA GPUs, Logitech HID++ For Anywhere 3S & Fixes
In addition to Linus Torvalds doing some vibe coding and more with his new “AudioNoise” project this week, Linux 6.19 kernel development ticked back up with the holidays having passed. A variety of fixes made it into today’s Linux 6.19-rc5 release in working toward v6.19 stable in early February… ⌘ Read more

Latest Linux 6.19 Code Fixes Rust Binder Driver, Adds Intel Nova Lake Point S To MEI
Ahead of the imminent Linux 6.19-rc5 release, the char/misc pull request was merged earlier today with a notable fix to the Rust Binder driver as well as adding the Intel Nova Lake Point S device ID to the MEI driver… ⌘ Read more

Since I used so much Rust during the holidays, I got totally used to rustfmt. I now use similar tools for Python (black and isort).

What have I been doing all these years?! I never want to format code manually again. 🤣😅

Linus Torvalds’ Latest Open-Source Project Is AudioNoise - Made With The Help Of Vibe Coding
In addition to Linus Torvalds’ recent comments around AI tooling documentation, it turns out in fact that Linus Torvalds has been using vibe coding himself. Over the holidays Linus Torvalds has been working on a new open-source project called AudioNoise that was started with the help of AI vibe coding… ⌘ Read more

Elon Musk: X’s New Algorithm Will Be Made Open Source in Seven Days
“We will make the new ð algorithm…open source in 7 days,” Elon Musk posted Saturday on X.com. Musk says this is “including all code used to determine what organic and advertising posts are recommended to users,” and “This will be repeated every 4 weeks, with comprehensive developer notes, to help you understand what changed.”

Some context f … ⌘ Read more

AI Fails at Most Remote Work, Researchers Find
A new study “compared how well top AI systems and human workers did at hundreds of real work assignments,” reports the Washington Post.

They add that at least one example “illustrates a disconnect three years after the release of ChatGPT that has implications for the whole economy.”

AI can accomplish many impressive tasks involving computer code, documents or images. That has prompt … ⌘ Read more

Linux 7.0 Readying Improvement For Rust + LTO Kernel Builds
Alice Ryhl of Google has been working on an improvement to the Linux kernel code for inlining C helpers into Rust when making use of a Link-Time Optimized (LTO) kernel build. At least some of the patches are queued up for merging in the upcoming Linux 6.20~7.0 cycle for helping those enabling the Rust kernel support and also making use of the LLVM/Clang compiler’s LTO capabilities for greater performance… ⌘ Read more

Torvalds Tells Kernel Devs To Stop Debating AI Slop - Bad Actors Won’t Follow the Rules Anyway
Linus Torvalds has weighed in on an ongoing debate within the Linux kernel development community about whether documentation should explicitly address AI-generated code contributions, and his position is characteristically blunt: stop making it an issue. The Linux creator was responding … ⌘ Read more

NVIDIA Optimizes Printing Of Linux Memory Stats For 11% System Time Savings
A NVIDIA engineer restructuring some of the printf-related code within the memory resource controller “memcg” statistics printing code to reduce the system time by 11% for dumping those stats… ⌘ Read more

Linux Kernel Considers Linking The Relocatable x86 Kernel As PIE In 2026
To allow for additional security hardening of the Linux kernel, a patch series has been updated more than one year later to link the relocatable x86_64 kernel as Position Independent Executable (PIE) code… ⌘ Read more

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? 😮‍💨

Compiler-Based Context & Locking Analysis On Deck For Linux 7.0 Paired With Clang 22+
A new feature in the queue for likely introduction with the next version of the Linux kernel (Linux 6.20~7.0) is compiler-based context and locking analysis. This kernel code depends on the yet-to-be-released LLVM Clang 22 compiler but can provide some powerful insights to kernel developers… ⌘ Read more

DRM Splash Screen Updated To Simply Drawing A Colored Background, Displaying A BMP Image
Back in October was an initial proposal for a DRM splash screen client for the Linux kernel that would be primarily useful for embedded systems for rendering a simple “splash screen” when updating the system firmware/software, early display activation at boot, during system recovery, or similar processes. Sent out today was a second revision to the DRM splash screen code… ⌘ Read more

Creator of Claude Code Reveals His Workflow
Boris Cherny, the creator of Claude Code at Anthropic, revealed a deceptively simple workflow that uses parallel AI agents, verification loops, and shared memory to let one developer operate with the output of an entire engineering team. “I run 5 Claudes in parallel in my terminal,” Cherny wrote. “I number my tabs 1-5, and use system notifications to know when a Claude needs input. … ⌘ Read more

Linux’s Old Mount API Code On The Chopping Block For The 7.0 Kernel
The Linux kernel’s “new mount API” that has been in the kernel since 2019 and recently made rounds for taking 6+ years to land the man page documentation on it will soon be the the only mount API internally within the kernel. Removing the “old” Linux kernel mount API internals is a candidate for the upcoming Linux 7.0 kernel cycle… ⌘ Read more

Google Will Now Only Release Android Source Code Twice a Year
Google will begin releasing Android Open Source Project (AOSP) source code only twice a year starting in 2026. “In the past, Google would release the source code for every quarterly Android release, of which there are four each year,” notes Android Authority. From the report: Google told Android Authority that, effective 2026, Google will publish new s … ⌘ Read more

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?

GStreamer 1.28-RC1 Brings A Rust-Based GIF Decoder, Other New Rust Components
On Monday the first release candidate of the GStreamer 1.28 multimedia framework was released. As is a recurring focus in recent releases, more GStreamer code is written in Rust for memory safety especially around decoding content… ⌘ Read more

Valve & AMD Developers Delivered The Most Code Contributions To Mesa In 2025
A developer from Valve working on the RADV Vulkan driver was once again the most prolific contributor to Mesa in 2025 followed by AMD’s Marek Olšák with continued improvements around RadeonSI and Gallium3D… ⌘ Read more

Intel Xe Driver Preps THP Support For “Significant” SVM Performance Gains
Intel engineer Francois Dugast today sent out the new patch series for enabling Transparent Hugepages (THP) support within the drm_pagemap code with a focus on the Intel Xe kernel driver usage. This enabling of THP support and in turn 2MB pages by the Xe driver is yielding “significant” performance improvements when using Shared Virtual Memory (SVM) such as for GPU compute workloads… ⌘ Read more

Linux Kernel AES Library Seeing Improvements For Better Performance & More
A set of 36 patches sent out overnight is making big improvements to the Linux kernel’s AES library. The patches allow for making use of the kernel’s existing architecture-optimized AES code for better performance, that code is also constant-time, lower memory use, and all-around a nice improvement over the status quo… ⌘ Read more

Spent most of the long weekend working on a few coding projects… specifically, I pushed some updates for TwtKpr to my test instance before spending some time working on the build process and demo page for my new twtxt-parsing library… which lead to me make some changes to my existing fluent-dom-esm library.

So, nothing actually got finished, but the incremental updates continue…

Spent most of the long weekend working on a few coding projects… specifically, I pushed some updates for TwtKpr to my test instance before spending some time working on the build process and demo page for my new twtxt-parsing library… which lead me to make some changes to my existing fluent-dom-esm library.

So, nothing actually got finished, but the incremental updates continue…

#Beyond40 have a #PublicDomainDay online event today!

“Discuss public domain and Creative Commons resources. Help plan #DocumentFreedomDay. Find out about public domain source code.”

From 2:00 pm to 3:30 pm (EST)
From 7:00 pm to 8:30 pm (GMT)

https://gath.io/XDKJ66FYl2ABCs2B1FktE

Linux’s Hung Task Detector Will Be Able To Be Reset For Easing System Administration
Worked on back in 2024 for the Linux kernel was a built-in counter to keep track of the number of hung tasks since boot. That feature for keeping track of the number of hung tasks since boot was merged in Linux 6.13 and exposed via /proc/sys/kernel/hung_task_detect_count. For helping ease use around it, new code working its way to the kernel will allow resetting that “hung_task_detect_count” counter… ⌘ Read more

RadeonSI Starts 2026 With NIR Compilation Refactoring For Better Performance, Lower GLSL Compile Times
Merged on New Year’s Day was a set of 36 patches authored by well known AMD Mesa developer Marek Olšák for refactoring the NIR compilation code for the RadeonSI Gallium3D driver… ⌘ Read more

European Space Agency Acknowledges Another Breach as Criminals Claim 200 GB Data Haul
The European Space Agency has acknowledged yet another security incident after a cybercriminal posted an offer on BreachForums the day after Christmas claiming to have stolen over 20GB of data including source code, confidential documents, API tokens and credentials.

The attacker claims they gained access … ⌘ Read more

Linux 6.19 Lands Fix For Dead WiFi With MediaTek MT792x Wireless
Merged to Linux Git on New Year’s Eve was a fix in the form of a code revert for broken MediaTek WiFi on the in-development Linux 6.19 kernel… ⌘ Read more

@lyse@lyse.isobeef.org It’s actually not nearly as half bad as I really thought it would be. Just having to eventually deal with the “lowering down” to machine code / ARM64 assembly in the end once you’ve verified the semantics in the VM.

@lyse@lyse.isobeef.org A “Hello World” binary is ~372KB in size. I currently have peephole optimization and deac code optimizations in play, and a few other performance related ones, but nothing too fancy. I have a test case that ensures fib(35) doesn’t regress too badly as I continue to evolve the language.

Opinion / Question time…

Do you think Mu (µ)’s native compiler and therefore emitted machine code “runtime” (which obviously adds a bit of weight to the resulting binary, and runtime overheads) needs to support “runtime stack traces”, or would it be enough to only support that in the bytecode VM interpreter for debuggability / quick feedback loops and instead just rely on flat (no stacktraces) errors in natively built compiled executables?

So in effect:

Stack Traces:

• Bytecode VM Interpreter: ✅
  
• Native Code Executables: ❌

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

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

Asahi Linux Has Experimental Code For DisplayPort, Apple M3/M4/M5 Bring-Up Still Ongoing
Prominent Asahi Linux developer Sven Peter spoke at this week’s 39th Chaos Communication Congress “39C3” in Hamburg, Germany. He provided an update around the still-in-the-works Apple M3 / M4 / M5 SoC and device support as well as other outstanding features like getting DisplayPort working on Apple Macs under Linux… ⌘ Read more

@shinyoukai@neko.laidback.moe We finally abandoned our GitLab. I publicly mirrored my code in the Mills Data Center a few days ago: https://git.mills.io/lyse/tt2

@movq@www.uninformativ.de Well, just a very limited subset thereof:

1. inline and multiline code blocks using single/double/triple backticks (but no code blocks with just indentation)
   
2. markdown links using using [text](url)
   
3. markdown media links using ![alt](url)
   

And that’s it. No bold, italics, lists, quotes, headlines, etc.

Just like mentions, plain URLs, markdown links and markdown media URLs are highlighted and available in the URLs View. They’re also colored differently, similarly to code segments.

I definitely should write some documentation and provide screenshots.

@lyse@lyse.isobeef.org Do you have your client’s code hosted anywhere?

Hurray, I finally fixed another rendering bug in tt that was bugging me for a long time. Previously, when there were empty lines in a markdown multiline code block, the background color of the code block had not been used for the empty lines. So, this then looked as if there were actually several code blocks instead of a single one.

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).

I just fixed another bug in tt where the language hint in multiline markdown code blocks had not been stripped before rendering. It just looked like it was part of the actual code, which was ugly. I now throw it away. Actually, it’s already extracted into the data model for possible future syntax highlighting.

@shinyoukai@neko.laidback.moe Yeah, they don’t truly support XDG. In fact, I looked in the Go stdlib source code to notice all the differences and shortcomings.

Ok, the standard library implementation is wonky at best, at least in regards to XDG, because it really doesn’t implement it properly. https://github.com/golang/go/issues/62382 I stick to my own code then. It doesn’t properly support anything else than Linux or Unixes that use XDG, but personally, I don’t care about them anyway. And the cross-platform situation is a giant mess. Unsurprisingly.

@movq@www.uninformativ.de Thanks! I’ll have a look at SnipMate. Currently, I’m (mis)using the abbreviation mechanism to expand a code snippet inplace, e.g.

autocmd FileType go inoreab <buffer> testfunc func Test(t *testing.T) {<CR>}<ESC>k0wwi

or this monstrosity:

autocmd FileType go inoreab <buffer> tabletest for _, tt := range []struct {<CR>    name string<CR><CR><BS>}{<CR>   {<CR>   name: "",<CR><BS>},<CR><BS>} {<CR>  t.Run(tt.name, func(t *testing.T) {<CR><CR>})<CR><BS>}<ESC>9ki<TAB>

But this of course has the disadvantage that I still have to remove the last space or tab to trigger the expansion by hand again. It’s a bit annoying, but better than typing it out by hand.

NTFSPLUS Linux Driver Renamed To Just “NTFS” With Latest Code Restructuring
One of the unexpected Linux kernel surprises of 2025 was NTFSPLUS being announced as a new driver for Microsoft’s NTFS file-system with better performance and more features compared to the classic read-only NTFS driver or the “NTFS3” kernel driver that Paragon Software submitted upstream. That NTFSPLUS driver has continued expanding its feature set and robustness and sent out today was the third iteration of the patches. Now this driver is s … ⌘ Read more

@lyse@lyse.isobeef.org I can tell you this right now, writing assembly / machine code is fucking hard work™ 😓 I’m sure @movq@www.uninformativ.de can affirm 🤣 And when it all goes to shit™ (which it does often), man is debugging fucking hard as hell! Without debug symbols I can’t use the regular tools like lldb or gdb 😂