Gregory Kurtzer is no stranger to the Linux world. He created CentOS, and when Red Hat messed it up, he started Rocky Linux as the community replacement. He also co-founded CIQ, the company offering enterprise support around Rocky.

His latest project has nothing to do with rebuilding another Linux distro, though. He has built an entirely new operating system kernel, and he didn't write most of the code himself. An AI agent did.

Meet Ginux, Linux userspace without Linux underneath

The project is called Ginux. It's an independent, Rust-first x86-64 kernel. Which simply means it is NOT a fork of the Linux kernel.

It has its own memory management, scheduler, process model, filesystems, networking, and device support, all written from scratch.

The most interesting part is that even though it is not Linux, it is Linux-compatible. Ginux implements the Linux ABI (the binary interface compiled programs use to talk to the kernel), so existing Linux binaries can run on it unmodified.

In the project's own terms, Linux is a "personality" that Ginux exposes, not the kernel running underneath.

Now, the name Ginux may sound like a mix of GNU and Linux. I hate to disappoint you, it is not the case here.

The G in Ginux stands for GPT. Greg. Kurtzer jokes in the README that, to keep his ego within limits, the G officially stands for GPT. Why GPT? Because it was coded entirely by (Chat) GPT 5.6 Sol.

Here's how Kurtzer announced it on X (formerly known as Twitter):

In 11 days, I built a new Linux-compatible operating system kernel that boots Rocky Linux 10 with systemd, all using Human-Directed Agentic Engineering (HDAE).

What Ginux can do today

Ginux builds as a single GINUX.EFI image that boots straight through UEFI, with no Linux host kernel involved.

It runs isolated "domains", each with its own processes, address space, filesystem, and lifecycle. The project describes these as stronger boundaries than OCI containers or Linux namespaces.

It can also pull and verify OCI container images and use them to assemble a domain's root filesystem. That's how it gets Rocky Linux 10 booted all the way to systemd's multi-user.target. Selected Alpine Linux programs (like the musl and BusyBox) run too.

Don't get too excited, though. Right now, Ginux runs only in a QEMU virtual machine, with no physical hardware profile, no GPU or NVMe support, and no independent security audit.

What is Human-Directed Agentic Engineering?

HDAE is the name Kurtzer gives to the development method, and to be honest, that's the real story here. He has documented it in a technical report on Zenodo.

The idea is a clear division of labour. The human decides the architecture, the constraints, the milestones, the acceptance criteria, and when to stop. The AI agent runs the implementation loop: write code, boot it, test it, diagnose failures, revise, and repeat against those executable checks.

For Ginux, that meant one persistent OpenAI Codex task running GPT-5.6 Sol for eleven days. It produced approximately 139,000 retained lines of implementation and test code, across more than 1,000 commits. Architecture documents kept the agent aligned, and real userspaces like Rocky Linux caught bugs that synthetic tests missed.

The "human-directed" part matters. This isn't as simple as typing "write me a kernel, don't make mistakes" into a chatbot. It's a person with decades of systems experience steering an agent that does the heavy lifting of coding.

One expert plus AI can go a long way

Kurtzer is careful not to oversell this AI achievement:

The larger lesson is that AI can generate complex systems software, but compatibility, security, hardware support, standards, community, and long-term maintenance remain the real moat.

I think that's only fair. Linux isn't going anywhere because a prototype boots systemd in a VM. Decades of hardware enablement, code review, and community are not something an AI agent produces in eleven days.

But let's take a step back to realize what happened here. A new kernel created from scratch, that runs an enterprise distro. And it took just 11 days with GPT 5.6 (not even 6.1, the latest model).

AI won't replace expertise. An expert who already knows how kernels work uses AI to squeeze years of grunt work into days.

When people with deep domain knowledge pair it with frontier AI agents, projects that once needed a large team and several years start to look like weekend side projects.

Ginux won't replace Linux, but it does show how far (and how fast) an skilled person can now go.

Tesco, the supermarket group with stores in the UK and certain regions of Europe, is hiring a Head of Software Engineering for its Edge Platform. The new hire would be responsible for carrying out the move away from VMware, the Broadcom-owned virtualization software, to Proxmox for the systems that run inside its stores.

The Register were the ones who spotted the listing first, and so far it's the only public sign of the Proxmox plan. Tesco has not said how many stores the move covers or how fast the rollout will occur.

What edge means for a supermarket

Edge computing puts servers and software near the place where the business operates instead of in a faraway central datacenter, and for a supermarket chain, that place is the brick-and-mortar store.

Tesco's listing describes its Edge Platform as the computing environment and software that lets applications run across its stores. Checkout, payments, stock management, and staff-facing apps all depend on it.

The platform covers Linux, server hardware, virtualization, and storage. Stores also need to keep working through connectivity disruptions or when local resources run short, as a badly handled change can interfere with store operations, staff, and customers.

The ask

The hire would handle two jobs. The first is the migration, and it involves defining repeatable setups for different kinds of stores, testing each version before a gradual rollout, and automating installs, upgrades, rollbacks, and recovery.

Along the way, they would also manage any migration dependencies and risks so that critical store operations are not affected.

The second job is a management platform for every store, built as an API-first system for provisioning, monitoring, patching, and remote diagnostics. It has to cope with stores going offline and with systems drifting from their intended setup.

That platform should also evolve independently of any one infrastructure technology where practical. The hire leads engineering managers and principal engineers, and the listed skills include Java, Python, and Terraform.

Where the exit stands

Tesco bought perpetual VMware licenses in 2021, but Broadcom stopped supporting them in January 2026. They have had to pay third-party providers for support since then.

In its lawsuit, Tesco accuses Broadcom of refusing to honor the 2021 agreement and of abusing its market power. They say the end of 2027 is the earliest it can be off VMware and calls that timeline a significant risk to its business.

Tesco also alleges that one Broadcom offer this year came in around 175 percent above what its 2021 contract entitled it to.

Suggested Read 📖: Proxmox Virtual Environment now runs on ARM64.

Jordan Hubbard started FreeBSD in 1993 with two others, and he has now built Daemonarchy with help from OpenAI’s GPT AI model. The name plays on Omarchy, with the BSD daemon taking the place of Arch as the base.

As for Omarchy, it has grown considerably since we initially covered it as a one-command script for Arch. It now installs from an ISO and has managed to pull in massive amounts of funding.

Anyhow, Daemonarchy is only a few weeks old and already has several releases, with v1.3.1 being released a few hours ago.

Why does this exist?

A few people on LinkedIn were pestering Jordan, saying FreeBSD should be as easy to set up and as pretty as Omarchy. That got him wondering, “Why doesn’t that already exist?”

He was testing GPT Astra 6 at the time and used it to put the project together. The first pass took under two hours. That figure leaves out the Poudriere builds used to validate it. GPT also picked the name for the project.

The ports this distro needed went upstream to FreeBSD’s ports tree for review. The same ports also let you install Daemonarchy on top of an existing FreeBSD system.

Jordan also credits the Wayland, Hyprland, and Arch Linux projects for the layers the desktop sits on.

What does it offer?

The installer follows Omarchy’s own, and it asks for the usual basics like keyboard layout, account details, hostname, and timezone.

Daemonarchy can take over a whole disk or settle into a partition or free space you pick, with a minimum of 40 GB of storage required. A whole-disk install wipes the drive, while partition mode overwrites only the partition you select.

Because the installer won’t shrink existing filesystems, anyone dual-booting has to make room from the other OS first. Everything lands on ZFS with rollback support, and encryption is optional.

The desktop is Omarchy itself, ported over with only the changes FreeBSD requires, and it runs on FreeBSD 16.0-CURRENT. Since CURRENT moves daily, each image is pinned to one snapshot.

A compatibility layer maps pacman to pkg, backs the Wi-Fi panel with⁣ wpa_supplicant instead of NetworkManager, and uses PipeWire to handle sound. Bluetooth also works for keyboards and mice via FreeBSD’s Bluetooth stack.

Apps come from FreeBSD’s own packages, installed with OctoPkg under Install > Packages or with pkg, and Chromium is preinstalled. Linux-only apps are being held back until specific versions have been tested under the Linuxulator, FreeBSD’s Linux compatibility layer.

Jails give you isolated FreeBSD environments that carry their own packages, and bhyve, the built-in hypervisor, runs virtual machines for guests like Linux and Windows.

And, if you run an upgrade through Omarchy’s update, it applies pkg upgrade to your applications and leaves the FreeBSD base and kernel alone. Daemonarchy’s own packages come from a signed repository and fixes land between ISO releases.

The wallpaper, wordmark, and login theme are the project's own creations.

📥 Get Daemonarchy

The latest 1.3.1 ISO release is a little under 2 GiB. Put it on a USB drive using dd or a live USB tool like Fedora Media Writer, then boot from that.

An internet connection is required during the installation while the installer downloads many packages as it progresses. The source code lives on GitHub.

Before announcing this Linux-based implementation, Amutable had released two open source tools. tine, a Buck2-based build system that composes OS images; available under MPL-2.0, and Quarry, a TUF-based tool that distributes those images to machines; available under Apache-2.0.

What Amutable Foundations brings to the table is a service where Amutable runs the images, update repositories, control plane and vulnerability fixes for organizations and individuals who operate their own systems.

No license has been stated for those company-run parts, and the preview announcement does not say how much of Foundations beyond tine and Quarry will be open source.

What's in the system?

Foundations is the product of Amutable, the startup Lennart Poettering co-founded earlier this year with Christian Brauner and Chris Kühl.

The system is immutable, with read-only system volumes protected by dm-verity, signed unified kernel images, and measured boot. Software and configuration both ship as signed images, and a machine boots only what is signed.

Because there is no package manager and no SSH or interactive shell, a change means giving every machine in your fleet a new signed image.

Its images are reproducible, come with an SBOM and are built from pinned inputs of whichever distribution you pick, with tine being able to import packages from Fedora or CentOS Stream.

How machines prove their state

Each machine sends a signed report that records what it booted, from the firmware and boot loader up to the kernel and OS, plus the configuration it runs.

Reports go out at regular intervals and at boot, and the signature is backed by a TPM or a CPU with confidential computing support. Machines without that hardware can fall back to a software key.

Amutable's control plane verifies reports from systemd-report, an experimental command in systemd 260 that the company helped build. It compares each one with the declared state and flags machines that deviate.

A rollout only continues while machines can show they are in a good state. Operators work through a structured interface instead of logging in.

Updates come from per-machine repositories that can link to one another, and downloads are checked against signed metadata for tampering, replay, and rollback attempts.

The same proof is meant to decide access, such as cluster joins and secrets. Amutable's provided example is withholding database credentials from a machine that runs outdated configuration.

Get into the preview

Amutable is looking for teams that manage Linux fleets and need to show what state each machine is in. It expects to start bringing the first 'design partners,' as it calls them, on board over the coming weeks.

Those partners will get early access, a direct line to the developers, and a say in what gets built next. The signup form asks for name, work email, company, role, country, industry, and company size.

Amutable is also targeting Kubernetes next, and if you are eager to learn more about that or Foundations, the team will be present at Booth 347 at this year's KubeCon North America in Salt Lake City.

If you have used Linux for a while, chances are you have used something Mirko Brombin built. He created Bottles, the app that takes a lot of the pain out of running Windows software with Wine. He founded Vanilla OS. And these days, he is building Singularity OS, an operating system with its own desktop and its own approach to immutability.

We last spoke with Mirko back in 2022. A lot has happened since then. He now works full time at fabricators, he is working on getting Microsoft Office running through Bottles, and he has some strong views on AI and on the recent wave of apps cloning Adobe and Microsoft interfaces.

I sent him my questions over email. Here are his answers, exactly as he sent them.

You have full time work at fabricators, Bottles, Sinty OS, and a long list of libraries and tools. How do you decide what gets your time?

I think anyone who's known me for a while knows that I'm not particularly good at sitting still, haha.

I've never really had a proper strategy for deciding what to dedicate my time to. Most of my projects are born from a problem I want to solve, an idea I want to experiment with, or simply the curiosity to find out whether something is possible.

Naturally, working full-time at fabricators and maintaining several open source projects, I've had to learn to set priorities. Not everything can receive the same attention, and not everything necessarily has to become a complete product.

You've written about using AI agents for the mechanical work, so how much has that changed what you can realistically take on?

Artificial intelligence has certainly changed a lot about the way I work, but I think it's important to explain how, because it's a topic I've really spent a lot of time thinking about.

When I wrote my articles about using AI agents in software development, I spent quite a lot of time just trying to find the right words. In open source, it's a particularly delicate subject, especially when you're someone with a fairly public presence and free software isn't just a passion, but also part of your work and your life.

It's very easy to be misunderstood, both by those who consider artificial intelligence the solution to every problem and by those who reject it completely, and honestly... I don't see myself in either position, because I've always had a rather complicated relationship with LLMs. At first I was very skeptical and, frankly, the more I tried to understand how they worked, the harder I found it to fully trust them.

The problem isn't the quality of the code they can produce, but understanding why they produced that particular code, because when I design software, I start from the architecture, I decide how the components should interact, what responsibilities they should have, how to handle errors, which compromises to accept and, logically, which ones to avoid. I document all of this very carefully, because I want to be able to understand every decision even years later, and it's a process I particularly care about and have absolutely no intention of delegating.

I want to give an example. A large part of the applications and infrastructure I develop every day, including for work, is written in Go. Over the years I've built my own set of libraries, defined my own patterns, and developed a fairly precise way of writing software. When I use AI, I don't ask it to invent an architecture, I give it mine, along with the documentation, conventions, and constraints it has to respect. I'm the one who decides how a project is born, how it evolves, and, eventually, when it's time to abandon it.

I still write a great deal of code manually, often because I need to work on particularly delicate components, other times simply because it's faster for me to do it myself. In any case, I review every single line of code written by AI. If it does something badly, it's because I accepted it.

What still doesn't convince me, though, is the very nature of how they work, because a language model can produce a correct answer, it can even explain the steps that seem to have led it to that conclusion, but this is... Well, illogical, at least from my point of view. An LLM can produce reasoning, but it doesn't necessarily possess an explicit, persistent, and causally verifiable representation of the knowledge it uses to express that reasoning. And this bothers me quite a lot.

If an agent decides to use a particular data structure, I want to know whether it did so because my documentation specifies that it's the correct solution, or because that solution is statistically plausible given the context.

To me, these are two very different things, and it's precisely for this reason that, for quite some time now, I've been researching and experimenting with an alternative approach to current language models, a project called Amus, with which I'm exploring a different way of representing knowledge and constructing answers, trying to make the relationships that lead to a conclusion more explicit and verifiable.

I don't want to reveal too much because it's still a research project, but the first results have been really encouraging, and I hope to be able to talk about it publicly in more detail soon.

So, going back to the original question, yes, AI agents have allowed me to take on an amount of work that would have been unthinkable for a single person just a few years ago, but by using them, I've started questioning the very technology they're based on and, well, perhaps that's the best way to describe my relationship with artificial intelligence, haha.

Your site now lists Vanilla OS as community-run. When we spoke in 2022, your goal was to make it sustainable enough to work full-time. What happened along the way, and how did it feel to step back from something you founded?

Not much has changed on this front. Vanilla OS continues to be maintained, it receives updates, especially when it comes to security and stability.

We recently released Vanilla OS 3 Reunion, which involved a huge amount of work to bring ARM support, along with writing the Vanilla OS SDK, which we used to rewrite many of the fundamental components of the operating system, so that everything could share a single common foundation.

Today, the project doesn't depend on my hands alone. There are several team members who make all of this possible, plus fabricators, which maintains its server infrastructure, and let's not forget all the contributors who report problems and provide solutions.

Over time, I've taken on a different role. I certainly still develop, in fact I developed Vanilla OS Continuity, the backup system included in Vanilla OS 3 Reunion, but... My role has started to become more political, both from the perspective of someone who finds ways to keep the project financially alive and from the perspective of making decisions about the architecture the project is built upon.

In short, I'm still holding the reins of everything :D

When you started Bottles in 2017, Wine, PlayOnLinux, and Lutris already existed. What gap did you see that made you build another one?

Well, probably because I wasn't satisfied with any of the three, haha.

Jokes aside, when I started Bottles, Wine was already an extraordinary technology, and PlayOnLinux and Lutris offered very useful tools to simplify its use. Actually, a special shout-out to Mathieu: "Hey look, I'm on It's FOSS, again!" D:

But none of them matched exactly my idea of "simplicity". My goal wasn't simply to create another launcher or a tool to install programs, but rather an environment where I could manage my applications without constantly having to touch the command line or place various DLLs here and there...

I've always found it curious how, in the Linux world, people so easily accepted the idea that technically complex tools necessarily had to be complicated to use as well. I think it's a stereotype, but also a fairly widespread one. The internal complexity of an application shouldn't automatically become the user's problem, and I'm saying this knowing that underneath Bottles there's literally a tangled mess making everything work.

And well, it's the same reason why I'm announcing Raven 😄

Many FOSS folks would say the effort is better spent improving LibreOffice or ONLYOFFIC. Why is getting Microsoft's own suite running worth it to you, given that Microsoft could break it with any update?

Frankly, I don't understand why the two things should be mutually exclusive. LibreOffice, ONLYOFFICE, etc. are fantastic pieces of software that I recommend first and foremost to anyone wanting to move from Windows to Linux.

But I can't be blind either. I see it every day at work. In my office I have the privilege of using whatever I want (mainly Singularity OS with its office suite), but almost all of my clients and partners use Microsoft Office for one reason or another, for support, certification, and all those things that a user less immersed in this kind of working environment might not see.

I'm the first to say that users should have a choice, and I create those choices myself... But that's the ideal world. The real world is that sometimes we simply can't afford to make the choices we'd like to make.

Will this stay a Bottles thing, or do you expect the fixes to go upstream into Wine so that other projects benefit too?

My goal is to contribute as much as possible upstream. We'll have to see whether the Wine developers like my patches though, haha.

Jokes aside, I want this work not to remain something specific to Bottles. I'd like it to be adopted upstream.

First of all, I need to reach a point where Microsoft Office 365 works reliably, then I'll find a way to collaborate upstream. It would be pointless to do it now.

There's also a wave of apps that clone Adobe and Microsoft tools almost one-to-one. Is copying familiar interfaces the right way to win people over, or does Linux need its own ideas? And how do you see their effort of bringing MS Office clone to Linux?

Honestly, this is the recent news I like the least, I have to be honest. I've made some tweets about it, I don't like how the identity of other people's products is being violated.

There's talk of clean room... But objectively, what's the point of talking about clean room if you then unleash a swarm of AI agents on the code, forcing them to keep Microsoft Word and Adobe Photoshop open so they can replicate them down to the very last millimeter?

It's not illegal... The practice itself isn't. But stealing, because that's what this is, the visual identity of that project is, it's called copyright infringement, and in some cases even unfair competition.

And what makes me even angrier is that I really don't see the point. Do we really need another Microsoft Office, identical down to the very last pixel?

If they had created a new suite with exactly the same functionality, using exactly the same approach, that would have been great. I would have been the first to promote it. And yet... This scares me a little, and it says a lot about what the future of open source will probably look like, especially if this is allowed and a precedent is set.

You are also working on Sinty OS. Why build your own desktop environment and kernel platform from scratch instead of reusing GNOME or KDE pieces?

Sinty OS is everything that Vanilla OS cannot be, because of its principles.

With Sinty OS, I wanted the desktop environment to be a unique experience, tailored to my needs (and those of many others, apparently), while in Vanilla OS we use pure GNOME, vanilla, exactly as mother GNOME intended it, and it follows all its principles, its style, everything is libadwaita and consistent with that desktop environment.

On the technical side, the "behind the scenes", Sinty OS is a completely different challenge. I'm trying to build an operating system that stands on the shoulders of Atom Loops, a new immutable technology I'm working on, very different from ABRoot and anything else out there.

Atom Loops manages immutability from the very first second of boot. The bootloader, the initramfs, everything is managed by this component, which follows a strict chain of trust and update validation.

Sinty OS doesn't use partitions for the system root, it uses image files (EROFS for the rootfs and UKI for the kernelcache), which are mounted by Atom Loops during boot, which means that, well, all the disk space (formatted as F2FS) belongs to the user.

Unlike Vanilla OS, I don't use LUKS, but encrypt user files using their own unique key. It's, well, completely different. The init system isn't systemd, but an ultra-minimal solution compatible with systemd units.

Let's say the two operating systems are two very different ways of achieving very similar goals.

When can people expect a stable release of SintyOS?

Haha, Sinty is the face of the project, as well as part of its identity.

Sinty is the shortened form I came up with for Singularity, which refers to the family of software related to Singularity Desktop and Singularity OS. Unfortunately, the term was too generic, so I decided to favor the name "Sinty". Little by little, I'm migrating everything to that name, which, in any case, will continue to mean Singularity.

There will be a lot more about Sinty, very soon. Many more applications and platforms are coming, all connected to Sinty OS.

Anything you'd like It's FOSS readers to know?

I just want to reiterate that people need to experiment more, especially today, when we have the technologies to dream big.

It would be predictable to say that limits are made to be overcome. It's much more exciting to think about how to overcome them.

Thank you for having me in this interview, always a pleasure!

Wrapping up

I would like to thank Mirko for taking the time to answer my questions in such detail.

I like how he refuses to pick a side in the AI debate. He uses agents heavily, yet he reviews every line they write and is researching an alternative to LLMs altogether. Amus and Raven are two things I'll be keeping an eye on, and so should you if you follow his work.

I'd also like to hear what you think about his take on the Adobe and Microsoft clones. Is copying a familiar interface fair game, or does it cross a line? Share your views in the comments.

How to use this RAID calculator

It's quite simple, actually.

1. Pick the RAID level or ZFS layout you are considering.
2. Enter how many drives you plan to use.
3. If all drives are the same size, enter that capacity. If they are not, switch to Mixed and enter each drive.
4. Choose the drive class. Check your drive’s spec sheet for its URE rating. Most desktop drives are 10¹⁴, and NAS drives like WD Red Plus or Seagate IronWolf are usually 10¹⁵.
5. Read the results: usable capacity, how many drives can fail, and how much raw space goes to parity or mirroring.
6. Scroll to Compare layouts to see the same drives in every layout side by side.

You can save a configuration or copy a link to share it. Saving and sharing both basically mean the RAID calculator is filled with the values you have selected. Data doesn't leave the browser.

How usable capacity is calculated

N is the number of drives and S is the size of the smallest drive.

RAID 10 can survive more than one failure, but only if each failed drive comes from a different mirror pair. If both drives in the same pair die, the array is gone. That is why the calculator counts it as one guaranteed failure.

How the rebuild risk is estimated

When a drive fails, the array has to read every surviving drive in full to rebuild it. The calculator multiplies the data read by the drive’s URE rating to estimate the chance of hitting at least one unreadable sector along the way.

Take four 8 TB drives in RAID 5. A rebuild reads the three surviving drives, which is 24 TB or about 1.9 × 10¹⁴ bits. With consumer drives rated at 1 error per 10¹⁴ bits, the spec sheet says the chance of at least one error is around 85%. With NAS drives rated at 10¹⁵, it drops to around 17%.

Real drives usually beat their rating, so treat this as a worst case. It still explains why RAID 6 and RAIDZ2 are the usual advice for big drives. A second parity drive means one bad sector during a rebuild costs you nothing.

Does this work for Synology, QNAP, UGREEN or TrueNAS?

Yes, for the standard RAID levels. QNAP, UGREEN and Synology all use Linux software RAID underneath, so RAID 1, 5, 6 and 10 give the same usable capacity shown here. For TrueNAS, use the ZFS mirror and RAIDZ options.

What this RAID calculator does not cover

It shows capacity and redundancy, not speed. Real performance depends on your controller, drives and workload. The figures are also before filesystem overhead. ZFS reserves a little over 3% of a pool as slop space, and your OS shows sizes in TiB, so expect the free space you actually see to be lower.

RAID terms explained

Here is a brief explanation of the terms used on this online RAID calculator.

Striping

Data is split into chunks and written across several drives at once. It is fast because every drive works in parallel, but nothing is stored twice, so losing one drive loses everything. This is RAID 0.

Mirror

The same data is written to two or more drives. If one dies, another still has a complete copy. Simple and safe, but you only get the space of one drive per mirror. This is RAID 1.

Parity

Extra data calculated from your files, like the answer to a sum. If one number goes missing, you can work it out from the rest. Parity lets the array recreate a failed drive without keeping a full copy, so it costs less space than mirroring.

Single parity

One drive's worth of space holds parity, spread across all drives. The array survives one failed drive. RAID 5 and RAIDZ1 work this way.

Double parity

Two drives' worth of parity, so any two drives can fail. That includes a second drive dying while the first is being replaced, which is when it is most likely. RAID 6 and RAIDZ2 work this way; RAIDZ3 adds a third.

Striped mirrors

Drives are paired into mirrors, then data is striped across the pairs. You get the speed of striping and the quick recovery of mirrors, but only half the raw space. This is RAID 10.

Rebuild (resilver)

After you replace a failed drive, the array recreates its data by reading the other drives. ZFS calls this a resilver. Until it finishes, the array has less protection than usual.

ZFS vs. traditional RAID

Traditional RAID, from a hardware card or Linux's mdadm, only sees blocks of data and cannot tell if a block has gone bad. ZFS is a filesystem and RAID manager in one. It checksums every block, so it spots silent corruption and repairs it from the redundant copy. It only rebuilds the space actually in use, and a read error usually costs one file rather than the whole array. In return, it likes plenty of RAM, and growing a pool is less flexible: adding a single drive to an existing RAIDZ only arrived in OpenZFS 2.3.

URE and drive class

A URE (unrecoverable read error) is a spot on a drive that cannot be read back. Manufacturers rate how often this can happen. Consumer drives are usually rated at 1 error per 10¹⁴ bits read (about 12.5 TB). NAS and enterprise drives are rated at 1 per 10¹⁵ (about 125 TB). A rebuild reads a lot of data, so the calculator uses this rating to estimate the chance of hitting an error mid-rebuild. These are spec-sheet worst cases; real drives often do better.

How is the power draw estimated?

Each drive type uses a typical average draw for a drive that is spinning or active but not under heavy load:

• 3.5" HDD: 6.5 W
• 2.5" HDD: 2.5 W
• 2.5" SATA SSD: 2.0 W
• NVMe SSD: 4.0 W

The array total is that figure multiplied by the number of drives. The yearly figure assumes the drives run 24 hours a day, every day: watts × 8,760 hours ÷ 1,000 = kWh.

It counts the drives only. The CPU, motherboard, fans and power supply losses add more, while spinning drives down when idle lowers it. Treat it as a ballpark for comparing layouts.

Frequently Asked Questions

Here are the answers to common questions you might have:

By now, you must know that mainstream Linux desktop environments, and by extension, distributions, are moving away from X11.

If you don’t know what an X11 session is, it is a desktop session that uses the X Window System, typically through the X.Org Server (Xorg). The server handles graphical output and input communication between applications and the display, while other components manage windows and compositing.

The newer, increasingly favored approach on Linux is a Wayland session.

Wayland is a display protocol, and its compositor acts as the display server, handling graphical output, input, window management, and compositing.

KDE has confirmed that Plasma 6.7 is the last release with a native X11 session, while GNOME has also removed its own X11 session. Of course, X11 applications can still run in Wayland sessions through the Xwayland compatibility layer.

Though not everything is lost for people who prefer X11. Several projects are emerging to keep the experience alive, with some maintaining or forking the existing X.Org Server, while others go as far as rewriting an X11 server from scratch.

This list covers eight of them, spread across desktops, X servers, and a layer that runs X11 apps on a Wayland compositor. Each one is open source and has shown development activity within the past few months.

1. SonicDE

SonicDE is a desktop that branches off KDE Plasma 6 and puts X11 first. It began in 2025 as a patched KWin/X11 called kwin-x11-improved. That grew into sonic-win, a window manager and compositor that keeps KWin/X11 going with code borrowed from KWin/Wayland and its own fixes.

Beyond the window manager, SonicDE is forking the KDE pieces it builds on and stripping out Wayland-only code. A Vulkan backend is in progress, and the developers plan to keep X.Org Server compatibility going while that remains feasible.

There's also conveniences, such as global hotkeys for push-to-talk and OBS recording toggles, and screen recording inside remote desktop apps like TeamViewer. Packages are available for Arch-based distributions, Artix, Manjaro, Gentoo, Void, and Slackware, among others.

Install instructions and links to each distribution’s packages are on the installation page.

2. Trinity Desktop Environment

Trinity Desktop Environment, or TDE, keeps the KDE 3.5 codebase going as a desktop of its own. The project's goal is to preserve the look and feel of a traditional desktop while being lean and requiring modest hardware to run.

Unlike KDE Plasma and GNOME, TDE continues to offer a traditional X11-based desktop environment rather than moving to Wayland. Its features include a built-in X11 compositor, with the project maintaining the components needed for its classic desktop experience.

The R14.1.6 release, the sixth maintenance update in the R14.1.x series, was announced in April. It fixed window tiling for maximized windows, improved branding, and addressed several transparency problems. It also added a 3D border option for the Kicker panel and a "Go to Desktop" action in Konqueror.

TDE can be installed on various Linux distributions and FreeBSD. You will find the latest packages on the official website.

3. Wayback

Wayback does not replace X11 clients or desktops. It replaces the layer underneath them.

The project is a small Wayland compositor built with wlroots. It carries just the required Wayland functionality to run Xwayland in rootful mode, allowing an entire X11 desktop environment to run inside it.

The aim is to make the traditional Xorg server binary unnecessary while retaining support for existing X11 desktops, particularly in Alpine Linux. The project is still experimental, so compatibility isn't guaranteed.

Ariadne Conill of Alpine Linux started the project. It is MIT-licensed and hosted on freedesktop.org's GitLab instance.

The remaining five entries are X servers or X server ports, ordered from the most mature to the least.

4. XLibre

XLibre is a community-maintained fork of X.Org Server that aims to keep X11 viable while continuing to develop the existing codebase. It also carries forward improvements that were never released in X.Org Server, including some features previously available only in Xwayland.

The changes are practical. TearFree modesetting is enabled by default, while atomic modesetting is available as an option. XLibre also introduces Xnamespace, an extension designed to separate X clients, and supports seat management through seatd as an alternative to systemd-logind.

The project also maintains CI builds for Linux, the BSDs, macOS, and Windows, although build coverage does not necessarily imply equal support across all these platforms.

Suggested Read 📖: PeppermintOS is moving from Xorg to XLibre to avoid Wayland.

5. Yserver

yserver is Jos Dehaes' ground-up X server rebuild in Rust, and the code is MIT-licensed.

It does not try to reproduce everything Xorg does. Indirect GLX, the DDX driver interface, non-TrueColor visuals, and clients with swapped byte order are among the things it leaves out.

Clients connect over Unix sockets by default, while TCP transport and XDMCP support are available as optional build features.

Despite its narrower scope, yserver can already run complete MATE, Xfce, and Cinnamon desktop sessions. It has also been tested with window managers such as FVWM3, Window Maker, Openbox, i3, and Enlightenment.

The project runs the X.Org X Test Suite to measure protocol compatibility, but development is ongoing and it is not intended to be a drop-in clone of Xorg.

You can find the code for it on GitHub.

6. XQuartz

Unlike the other projects here, XQuartz is not trying to preserve an X11 desktop on Linux or replace the Xorg server with a new implementation. It builds on X.Org's X Window System for macOS, allowing X11 apps to run alongside native Mac apps in the same desktop session.

The latest stable release, 2.8.6, arrived in July 2026. It updated several bundled components to address older security vulnerabilities and fixed rendering issues affecting Apple Silicon Macs.

It supports macOS 10.13 and later, and you can get it from the official website.

7. Phoenix

Phoenix is an X server built from scratch in Zig, not an Xorg fork, and it is licensed GPL-3.0-only. The idea is to build a simpler server than Xorg by supporting only a subset of the X11 protocol, with a focus on modern applications and graphics hardware.

Most of its planned improvements concern security and graphics.

Protocol messages are meant to be parsed automatically, applications are intended to be isolated from each other by default, and clipboard access is planned to be restricted to focused applications, with an option to restore Xorg-like behavior.

Other goals include tear-free rendering, a built-in compositor, better multi-monitor support with different refresh rates, and HDR. In cases where features such as HDR need more than the existing X11 protocol offers, the project says it may extend the protocol.

For now, Phoenix only runs nested inside an existing X server, where it can render GTK 3, GLX, EGL, and Vulkan applications with hardware acceleration. It remains under development and is not ready for everyday desktop use.

The code is available on dec05eba's git server.

8. Frame

Frame is an X server for x86_64 Linux written entirely in NASM assembly. It skips libc, Xlib, and other typical user-space dependencies, speaking to the X11 protocol directly and communicating with the kernel through DRM/KMS and evdev.

Geir Isene created it for the CHasm desktop with the long-term goal of supporting the desktop alongside ordinary X11 clients. Right now, Frame can serve up to 128 clients at once and supports SHAPE, RANDR, XInput2, and MIT-SHM.

It is released under the Unlicense, and its README credits Claude Code.

The code is available on GitHub

💬 Know some other projects that can be added to this list? Share them in the comment section.

If you've followed It's FOSS for a while, you probably have seen our previous coverage of ArmSoM devices. I reviewed the Sige7 a while back and came away impressed (cheeky headline and all). Earlier this year, we also covered the Sige6, the first Sige board to swap Rockchip for Allwinner.

Now the Sige lineup is back on Rockchip with the Sige7s. So, what's changed?

Key Specifications

• SoC: Rockchip RK3588S, 8nm, 4x Cortex-A76 @ 2.4GHz + 4x Cortex-A55 @ 1.8GHz
• AI: 6 TOPS NPU (INT4/INT8/INT16)
• RAM: up to 32GB LPDDR4/4X
• Storage: removable eMMC module (16GB to 128GB) + microSD
• Networking: Wi-Fi 6 + Bluetooth 5.0, Gigabit Ethernet with PoE support (add-on module)
• 2x USB 3.0 + 2x USB 2.0
• 1x MIPI CSI (up to 5MP camera)
• CAN, SPI, PWM, 3x UART, 2x I2C, 6x ADC
• RTC battery connector
• Headphone out
• Power and Maskrom buttons
• 0°C to 80°C operating temperature
• Size: 85 x 56 x 17mm, same footprint as a Raspberry Pi

The Sige7s starts at $153 on ArmSoM's store.

The "s" in the name comes from the chip. The RK3588S is the trimmed-down version of the RK3588 that powers the Sige7. You get the same CPU, the same Mali-G610 MP4 GPU, and the same 6 TOPS NPU. What you lose is peripheral bandwidth. There is no PCIe 3.0, one HDMI output instead of two, no HDMI input, and only one Gigabit Ethernet controller.

In simpler words, the compute is the focus here, the I/O is not. If you want a Rockchip SBC fast NVMe drive or dual networking, this isn't the board for you. If you want RK3588-class power in a smaller package for less money, it is.

There are a few more indirect cost optimizations here for the users. Sige7s accepts a wide 5V to 23V input, so you aren't stuck with a specific USB-C power brick. It also uses a removable eMMC module, which means your precious storage isn't stuck to the board if you want to upgrade or reflash it on another machine.

On the display side, there's HDMI 2.1 up to 8K@60fps, a DisplayPort 1.4 over USB-C, and a 2-lane MIPI DSI connector. The hardware video engine decodes 8K@60fps H.265/VP9 and encodes 8K@30fps, so it can double as a serious media box.

The 40-pin header is Raspberry Pi compatible, and ArmSoM says it works with Pi HATs, the Pi 7-inch display, the IMX219-based Pi camera, and Pi 4 cooling solutions. That's a good thing if you already have Pi accessories in your stock or if you want to expand the board.

Prefer a Compute Module? Meet the CM7s

Alongside the Sige7s, ArmSoM also offers the CM7s, a compute module built around the same RK3588S chip. I checked both spec pages, and the CPU, GPU, NPU, and video engine are identical. It's just a different form factor.

In case you did not know, the compute module contains just the processor, memory, storage, and power management. There are no standard physical input/output ports like USB, HDMI, and Ethernet. Compute modules are more suitable in cases where they need to be embedded.

The CM7s measures 55 x 40mm, pretty much the same size as the Raspberry Pi CM5. Not sure if you can put it into a CM5 carrier board, though.

It's available with up to 32GB LPDDR4/4X RAM and up to 256GB eMMC. Through the 100-pin connectors, it exposes HDMI 2.1, DP 1.4, MIPI CSI/DSI, USB 3.0, PCIe 2.0/SATA, and the usual GPIO buses. ArmSoM has also committed to producing it until at least August 2034, which is reassuring if you're building a product around it.

To get started, there's the CM7s-IO carrier board. It gives you HDMI, USB-C DisplayPort, 4x USB 3.0, Gigabit Ethernet, a 40-pin header, an M.2 M-key slot for NVMe SSDs, microSD, and MIPI camera and display connectors. Unlike the Sige7s, it runs on a 12V DC barrel jack.

Pricing and Availability

Both boards are available now from ArmSoM's official store, with AliExpress and Taobao listings as well.

The Sige7s starts at $153. Wi-Fi antennas are sold separately, so add those to your cart.

The CM7s starts at $179.

If you're in the US, note that ArmSoM collects 25% of the product value as prepaid customs duty at checkout (listed as "sales tax"), so there's no surprise bill on delivery.

If you just want a ready-to-use RK3588S computer, go for the Sige7s. If you're designing your own hardware or want an NVMe slot via the carrier board, the CM7s is the one.

ArmSoM hardware might remind you of Banana Pi boards, that's because the two companies are known to work closely together, and the boards often share the same base.

One more thing worth I have noticed. ArmSoM's documentation has improved considerably since I first tried their boards. That's a positive sign because new SBCs often struggle with the documentation and community.

LF Research is the Linux Foundation's research arm. It was set up in 2021 and publishes studies on how open source is built and used, drawing on surveys and project data.

Its latest report, Navigating Open Source Software Development in the Generative AI Era, surveyed 234 contributors and maintainers on how generative AI is affecting the way open source gets made.

The survey estimates that about 25% of incoming pull requests are low-quality AI slop, with the estimate climbing to 31% on larger projects.

Red Hat sponsored the report, with additional contributions from OpenSSF, LF AI & Data, and Futurewei.

The findings

Large projects, the ones with more than 50 contributors, are affected the most.

Among their maintainers, 69% report more incoming contributions, against 59% across all maintainers, and 64% say reviews now take longer. Burnout is their top concern at 63%, narrowly ahead of contribution quality at 60%.

You will also find that policies have not caught up to the AI-assisted coding and vulnerability reporting trend.

Of the 119 respondents who answered the question, 35% said their project has a formal policy permitting AI use. Another 32% have none and no plans for one, 23% plan to write one, and 10% ban AI contributions outright.

You might remember that some projects, like LLVM, allow AI-generated code with conditions. Separately, 26% of projects have no way of verifying AI-assisted contributions at all.

The report calls on contributors to give effort to written policies, disclosure of AI use, and testing and documentation.

Interestingly, AI does seem to save developers' time. Respondents estimate that code authoring takes 52% less time on average, while on more complex tasks, 21% said the work took longer with AI.

Most maintainers (71%) say AI makes it easier for newcomers to start contributing. Just over half (53%) say it has not improved community trust, while only 13% say it has.

Some caveats do apply. 📝

Respondents were recruited through Linux Foundation newsletters and social channels, plus partner channels that include Red Hat. As for the 25% slop figure, it is an estimate from 111 respondents, not a measured count.

That sounds fair, but disclosure is mostly left to individual choice right now, and a quarter of projects have no way to check anything. It only works if the people sending slop make an effort to do it.

And as we have already seen time and again, the ones sending slop rarely bother. 🤷

Suggested Read 📖: Save up to 40% on Kubernetes security certifications.

The kernel's filesystem mailing list has received an 18-patch proposal this week from Aurelien Desbrieres, the creator of BeamFS. It takes the place of FTRFS, an earlier filesystem he had proposed back in April.

Aurelien says he used Anthropic's Claude to write the code, the tool that checks the patches, and the cover letter.

He also points out that every patch carries an Assisted-by tag. You might remember that is the disclosure the kernel's AI coding assistants policy asks for. The same policy keeps the human submitter responsible for the code.

How does it fix data?

Filesystems that can repair damage, like Btrfs and ZFS, usually do it by falling back on a spare copy of the data. BeamFS skips that and stores Reed-Solomon error-correcting codes inside every block.

Every read gets checked against those codes, and small amounts of damage are corrected before the data reaches the application. If the filesystem can tell the damage is beyond repair, the read fails with an error instead of returning the wrong bytes.

The idea started with satellite computers. They keep data on a single drive and cannot fit a second copy. The same case is made for radiotherapy rooms.

Neutrons from treatment machines can flip bits in the computers there, including the ones handling imaging and records. Aurelien argues a silently wrong byte does more damage in that setting than a failed read.

BeamFS has not been tested in a real radiation environment yet. The tests done so far simulated the damage by flipping single bits in data as it was read on virtual machines and USB flash drives.

In his technical report, ext4 and ext3 returned wrong data without any error, while Btrfs refused to read the file. BeamFS returned the correct file every time except once, when a flip hit a pointer to the file’s data and it refused the read.

Do keep in mind that the comparison is uneven. Each filesystem received a different number of flips, and the report makes it clear that it is not a ranking.

Is it close to landing?

Nope, this is a request for comments (RFC). Aurelien is asking for feedback, not calling for a merge, and he has two questions for the maintainers.

The first is whether it should be a separate filesystem or be proposed for an existing one.

The second is the journal, the log other filesystems use to recover from crashes. BeamFS lacks one and relies on its fsck tool after an unclean shutdown. Aurelien asks whether it has to come before further review or can be submitted afterward.

So far, the only reply in the thread is about where the MAINTAINERS entry sits alphabetically.

The project's README has a warning of its own. It lists bugs that can lose data, open security holes, and crash the kernel, advising against trusting the code with anything important.

Steam’s Linux client is going 64-bit and containerized. Running the client inside Steam Runtime containers, like its games already do, should make it behave more consistently across different distros.

Ubuntu 26.10 is out now. This interim release completes the rustification of core utilities, adds Sequoia PGP to the main archive, and brings Linux 7.3 with Snapdragon X2 Elite support and better GPU memory handling.

Fedora 45 release is delayed, and it should now be released on 30th October.

CutefishOS is making a comeback with a completely rebuilt desktop written using Anthropic’s Fable and Opus AI models. Ships with its own Wayland compositor and graphics library, skips Qt and GTK entirely, and launches apps quickly.

Dux Labs is the new name for Dank Linux and its Wayland suite, now that DMS has grown beyond a single product. The rebrand coincides with DMS 2.0, which adds Material 3 design, a new file manager, and widget support.

🧠 What We’re Thinking About

A €115 billion price tag for Europe’s cloud independence sounds steep until you note who paid for the study. Amazon, Google, and Meta funded the report through their lobby group, warning against rules that would dilute their market power.

🛍️ Get certified for less

The Linux Foundation's Kubernetes Security Certifications bundle is up to 40% off until October 23. That's tomorrow. If you are looking for a career in DevOps, you can purchase the exam for less and schedule it within a year of time. There is also a 3-day money-back guarantee.

🧮 Linux Tips, Tutorials, and Learnings

Our newly-updated podcast roundup covers 15 Linux shows active in 2026, from news digests like This Week in Linux to community shows like mintCast. Which ones are your favorites?

Want to dress up your Linux desktop for Halloween? At least Hyprland users can follow this customization tutorial that covers everything from the Gothic theme to wallpapers. Grab the config files from GitHub and turn your desktop into something out of a nightmare. 🎃👻

Looking beyond Linux, here are nine open source operating systems that cover wildly different purposes. Haiku mimics BeOS for responsive desktops, Redox pursues pure-Rust design, FreeBSD dominates servers, and ReactOS attempts Windows compatibility from scratch.

And if you are in a mood to test your Linux command line knowledge, challenge yourself by attempting this CTF.

👷 Homelab and Hardware Corner

Android TV owners are using AI to strip ads and bloat straight from their hardware. I have to accept that this is the most amusing usage of AI I have seen so far.

There is a new de-googled phone worth a look for privacy enthusiasts. It's 4 inches in size and has both a keyboard and a touchscreen. You may also want to take a look at MAKERphone 2.0 if such devices interest you.

✨ Apps and Projects Highlights

Here's a terminal text editor that you can use with a mouse. It's like VS Code's terminal equivalent.

📽️ Videos for You

If you are a KDE user, you should see this awesome Dock in action in the latest video.

💡 Quick Handy Tip

On KDE Plasma, if you have Filelight installed, then you can quickly analyze disk usage for any directory right from Konsole. Just right-click any folder or empty space in the terminal, select "Open With", and choose "Filelight" to launch a visual breakdown of your files.

🎋 Fun in the FOSSverse

I have redesigned the Quizzes page. You can now see most of the quizzes neatly displayed in categories. Over 140 crosswords, quizzes, and puzzles to enjoy.

Are you willing to make that sacrifice? 🤔

🗓️ Tech Trivia: Ubuntu first arrived on October 20, 2004, with the 4.10 release, nicknamed Warty Warthog. Since then, it has stuck to a standardized rhythm, putting out a new release every six months and an LTS version every two years.

🧑‍🤝‍🧑 From the Community: Pro FOSSer Mikael is looking for a printer that is compatible with Linux. Got any suggestions for him? 🖨️❓

I spend a lot of time in the terminal. Whether it is writing scripts, editing configuration files, or managing remote servers, the terminal remains the place where I get most of my work done. But when a project becomes slightly complex, I often find myself reaching for the comfort of a graphical code editor like Zed.

I'll be honest, while I can appreciate why people love tools like Vim and Neovim, learning a modal editor has always felt like more of a commitment than I was willing to make.

My editing needs are fairly straightforward, and spending hours memorizing keybindings, configuring plugins, and building a workflow from scratch never felt like a worthwhile investment for me.

That's why TTT caught my attention. The project describes itself as a real alternative to VS Code, Zed, and Sublime Text that runs entirely inside the terminal.

Installing TTT

On Linux, to install TTT, you can use the official installer script. That's fashion these days. No package, just an installer script curled right into your system.

curl -sSfL https://raw.githubusercontent.com/eugenioenko/ttt/main/install.sh | sh

This will install the binary in ~/.local/bin. To run it, open your favorite terminal and use the command:

ttt

There are also prebuilt binaries available to download so that you can place it in a folder of your choice and use it in portable mode.

TTT features I liked

Instead of trying to emulate traditional terminal editors, it aims to provide a modern, GUI-like editing experience in the terminal application with virtually no configuration required.

Sure, not all of these features might be unique, but they are good to have in an editor.

Syntax Highlighting

TTT uses textmate-go for syntax highlighting, a Go implementation of Microsoft's TextMate engine that powers syntax highlighting in VS Code. It claims to support more than 120 languages out of the box, giving it a surprisingly mature editing experience for a terminal-based application.

Multi-Cursor Editing

Multi-cursor editing is one of those features I started appreciating after spending some time with Helix. It's something I now instinctively look for in any editor.

Thankfully, TTT ships with multi-cursor support out of the box, so there's no need to install plugins or configure anything before getting started.

The workflow feels familiar if you've used modern editors before, like Sublime Text.

Pressing Ctrl+D selects the next occurrence of the highlighted text, while Alt+Click lets you place additional cursors exactly where you need them.

Mouse Support

Many terminal editors advertise mouse support, but often that simply means you can click around and scroll. TTT goes much further than that.

The mouse interactions felt surprisingly close to what I'd expect from a graphical editor rather than a typical terminal application.

You can click to position the cursor, drag to select text, and right-click to access context menus.

The latter ended up being my favorite part because the menu isn't just a generic list of actions. Depending on where you click, TTT presents relevant options, making the whole experience feel far more polished and GUI-like than most terminal editors I've tried.

LSP and Auto Completion

A code editor doesn't feel complete these days without intelligent auto-completion, and TTT checks that box through Language Server Protocol (LSP) support.

Getting it up and running is fairly straightforward as you only need to install the language server for the programming language you work with.

The project also maintains a dedicated guide covering language server setup for a wide range of languages, which can save some trial and error during the initial configuration.

Once configured, you get the kind of code completion and language-aware features you'd expect from a modern editor, but without leaving the terminal.

Multi-folder Workspaces

Multi-folder workspaces allow you to group related folders into a single workspace and treat them as one project, much like VS Code's multi-root workspaces.

What makes this even more useful is that the workspace can be saved to a workspace.ttt file and reopened later with the exact same setup. So instead of manually opening the same collection of directories every time, you can simply load the workspace and continue where you left off.

For example, I have this customization.ttt file that has the content:

{
  "folders": [
    { "path": "/home/itsfoss/Projects/text-script-files/" },
    { "path": "/home/itsfoss/Projects/public-dot-files/" },
    { "path": "/home/itsfoss/Projects/desktop-customization" }
  ]
}

Now, I can always open this workspace by using the command:

ttt --workspace ~/Projects/customization.ttt

You don't need to manually create this file since you can add location to a workspace and later save it all via File -> Save Workspace As option.

Modern Search with Ripgrep

TTT uses ripgrep under the hood, which is already a favorite among developers thanks to its speed and ability to handle large projects without feeling sluggish.

In practice, this means you get fast, project-wide search capabilities directly inside the editor.

Combined with shortcuts like the Ctrl+K F for workspace search and Ctrl+K R for search and replace, it feels much closer to the experience you'd expect from a modern GUI editor than a typical terminal-based tool.

Git Integration

TTT provides a dedicated Changes panel where you can stage, unstage, discard, commit, pull, push, and sync repositories without dropping back to the command line.

The built-in diff viewer is particularly nice to work with because it combines Git diffs with syntax highlighting, making code changes easier to read.

The Git gutter indicators and inline blame information help provide context while editing.

If you're working with multiple repositories in a workspace, TTT automatically groups changes by repository, which keeps things organized when juggling several projects at once.

Integrated Terminal

You may find it funny that one of my favorite features in a terminal-based editor is... another terminal. But in practice, I found it incredibly useful.

Whenever I needed to run a command, I didn't have to open a split terminal in my terminal emulator or switch to another tab. Everything stayed inside TTT, which helps maintain focus on the task at hand.

TTT's integrated terminal is a full terminal emulator rather than a basic command prompt. It supports multiple terminal tabs, true-color rendering, scrollback, and can be toggled between panel and fullscreen modes with keyboard shortcuts.

For a project that aims to bring a GUI-like experience into the terminal, this feature fits perfectly, eliminating one more reason to leave the editor while working.

Plugins

TTT already comes with many of the features I normally install plugins for in other editors. But the more I explored it, the more I appreciated the approach.

TTT supports Lua-based plugins that can add commands, panels, and keybindings, allowing you to extend the editor without turning it into a configuration project.

Plugins run inside a sandboxed environment and must explicitly request permissions to approve each plugin's capabilities.

To add even more convenience, you can install plugins through a dedicated panel within the TUI.

You may read more about the plugins in their official documentation.

Theming

TTT ships with a decent collection of built-in themes, including popular options like Dracula, Monokai, etc., making it easy to find something comfortable without downloading anything extra.

The built-in theme picker offers live previews as you browse themes, and you can customize virtually every aspect of the interface through JSON files, from syntax highlighting and diff colors to the sidebar, status bar, and even terminal colors.

Wrapping Up

After spending some time with TTT, my biggest takeaway isn't that it's a great terminal editor. It's that this thing often doesn't feel like a terminal editor at all. In many ways, it feels like a full-blown GUI application that just happens to live inside a terminal window.

Now, I don't know how many of you will actually approve of that direction. The Linux and terminal communities have long maintained a clear distinction between TUIs and GUIs, and plenty of users prefer terminal applications precisely because they don't try to mimic desktop software. TTT deliberately blurs that line. Whether that's a good thing or not will ultimately depend on what you want from a terminal editor.

I found TTT's approach refreshing. It takes many of the conveniences people expect from modern GUI editors and brings them into the terminal with surprisingly very few compromises. If that idea sounds appealing, TTT is absolutely worth a look.

By the way, TTT is not the only editor of this kind. We have covered several other terminal editors that are easy to use since they provide terminal user interfaces that can be used with a mouse. If you are not allergic to Microsoft, their open source Edit editor is also worth a look.

I welcome your comments on TTT and other terminal based text editors you prefer.

Brax Technologies, the company behind the BraX3 smartphone and the open_slate tablet, opened pre-orders for the Wink last week with plans to ship it in two batches next year.

Rob Braxman, a co-founder of the company and known on the web as The Internet Privacy Guy, had presented the Wink at a roadmap event last month.

The privacy features

The Wink runs BraxOS, an Android-based operating system that does not include Google services, and the device comes with a physical switch located on top that can be configured to shut off the camera, microphones, location, sensors, or mobile network.

During setup, you can pick between Omni, a full Android experience, and Zero, a stripped-down mode limited to encrypted messaging, calls, messages, and optional navigation.

BraxOS does not support Google account sign-ins or Google Play Services, but Brax says most Android apps still run without issues. The exceptions are apps that check for Google's integrity services before starting, which includes a few banking apps.

The Wink can also wipe itself on triggers you set in advance, namely every restart, a long stretch powered off state, repeated failed unlock attempts, and a duress password.

Brax promises updates until 2032 and says anyone can build BraxOS from source, with files available in its BraX3 repositories.

Key specifications

Coming back to the hardware that powers all that, we have:

• SoC: MediaTek MT8875 with an octa-core CPU (4x Arm C1-Pro and 4x Arm C1-Nano cores, 4 nm) and an Arm Mali-G625 MC2 GPU.
• RAM & Storage: 8 GB, alongside 128 GB of built-in storage.
• Display: 4-inch OLED touchscreen
• Camera: 50 MP rear camera, sensor not disclosed.
• Keyboard: Physical QWERTY keys that are touch-sensitive and support swipe scrolling.
• Networking: Global LTE and 5G bands, plus physical SIM and eSIM support.
• Connectivity: Wi-Fi 6E and Bluetooth 5.4.
• Ports: USB-C 3.2 Gen 1, a 3.5 mm headphone jack, and a microSD slot for cards up to 1 TB.

Getting the device

Pre-orders come in two batches, each capped at the number of units being built:

• Batch 1 is for buyers who pay in full at $449, a price Brax guarantees, and those units go out first in July 2027.
• Batch 2 starts with a $30 deposit toward a $550 total. The remaining $520 would be charged around July 2027, with these units shipping in September 2027.

The deposit amount is refundable until the balance is paid, and orders can be changed or cancelled while they are still reservations. Shipping dates can also change, and reservation holders will be emailed about any change before the remaining amount is due.

Each unit is set to ship with the keyboard, a USB-C cable, and a translucent case.

If such phones interest you, you can also explore the MAKERphone 2.0.

What I realized in the past week or so is that if you can reverse engineer it, any software is open source software.

Not in the license sense, of course. But AI agents are getting good at reading binaries, tracing what an app does and rebuilding it. Last issue, we had the Craft tools cloning Microsoft Office. This week, there are more office clones, a viral repo that reverse engineers "anything", and people taking back control of their smart TVs with the help of AI.

The source code is no longer the wall it used to be. Whether that's a good thing depends a lot on which side you are on.

🧪 On my desk

I have enjoyed using Myna for voice based input on Ubuntu 26.04 (yes, it can be installed on 26.04). The performance is surprising good. Next, I will be trying a few more such voice input tools, starting with SpeakoFlow.

🔍 Discover AI tools

REA (Reverse Engineer Anything) is the repo of the week. It's an MIT-licensed MCP server that lets AI agents inspect native binaries, Electron apps, Android APKs, firmware and more. Deep native analysis needs proper reverse engineering tools like Ghidra. Analysis runs locally, but your agent's model provider still sees what it finds. Also, fake REA repos are already serving malware, so install it only from the official repo or npm package.

Graphify is reverse engineering for your own code. It turns a codebase, docs and PDFs into a knowledge graph your coding agent can query. Code is parsed locally with tree-sitter, and GRAPHIFY_BACKEND=ollama keeps the rest local too.

It's a Plan is a self-hosted Linear/Jira alternative where AI agents get a role and pick up issues like any team member. External agents run on your machine and hand tasks to Claude Code, Codex or opencode. In early stages for now.

🏢 The office clone wars

Mandrake Linux creator Gaël Duval is behind ElixirOffice, a Microsoft Office look-alike built on Euro-Office components. The code was written by LLM agents, with tests and reviews on every change. It's AGPL-3.0 and in beta.

Then there is Ely Office, six offline desktop apps for documents, sheets, slides, PDF, Git and Markdown.

And BetterOffice, which we covered last week, now has its Apache-2.0 source under the openooxml org on GitHub.

Meanwhile, Perplexity added REA to its Computer agent as a /reverse-engineer command, free until 31 October. Its demo clones included Photopea, Audacity and... LibreOffice Calc. Yes, reverse engineering an app that is already open source (LOL).

📺 Your TV, your rules

My favorite story of the week. Android TV owners are using AI to debloat their smart TVs. The agent connects over ADB, lists installed packages and disables ads, telemetry and preinstalled junk. People report faster TVs. A related project does the same for Fire TV.

This is the "reverse engineering" idea at its most useful. You don't need to be an Android developer anymore to fix the device you paid for.

📡 Open Model News

Meta released Muse Spark Open, an 816B model with 42B active parameters and a 1M-token context. The headline says it "runs on Macs". But that actually means two Mac Studios with 512 GB each. Not the kind of hardware normies like me can afford.

Also note the licence. It's the "Muse Model License" with limited commercial terms. Open weights, yes. Open source, no.

👀 Big Tech Watch

NVIDIA RTX Spark laptops went on sale on 16 October, starting at $2,599, from ASUS, Dell, HP, Lenovo, Microsoft and MSI. The chip pairs a Blackwell GPU with a Grace Arm CPU and up to 128GB of unified memory, enough for bigger local models on a laptop. Two catches. The 128GB is only on the top configuration, and the lower tier tops out at 32GB. And these are Windows on Arm machines, with no word on native Linux support (yet).

Google Research open sourced Harness², a framework that improves the harness around a model (prompts, tools, memory, skills) without touching its weights. It's Apache-2.0 and uses OpenCode by default. Model runs are configured for Vertex AI, and I see no documented local model path yet.

Anthropic says Claude Code now gzips the conversation it sends on every turn, and cloud sessions start as soon as you begin typing. It reports up to 3x faster time to first token for local Claude Code sessions, compared with August. The billion-dollar AI speedup came from gzip, a free and open source software tool from 1992.

🗂 AI Jargon: Clean-room design

How do you copy software legally? Clean-room design.

One team studies the original app and writes down only what it does: the behavior, the file formats, the interfaces. A second team, which has never seen the original code, builds a new app from that description. That separation is what protects the clone from copyright claims. It's how the PC BIOS was cloned in the 1980s and that's how Compaq became a popular PC brand.

AI agents blur this neatly. The same agent that reads the binary often writes the new code. Whether that still counts as a clean room is a question lawyers will be busy with for a while.

😂 Meme

⚡ Quick Tip: Back up before an agent touches your TV

Before you get too excited and let an agent debloat your Android TV, save the package list first:

adb shell pm list packages > tv-packages.txt

Ask the agent to use pm disable-user instead of uninstalling. A disabled package comes back with adb shell pm enable <package-name>. And turn off USB or wireless debugging when you are done. An open ADB port on your home network is not something you want to leave lying around.

And if you must use cloud AI for something sensitive, Maple has a sensible guide to using AI privately. Maple sells a private AI service, so keep that in mind. The thing is that privacy settings alone don't stop a provider from reading your chats. Running models locally is still the only option that keeps your words off someone else's server.

Keep on exploring AI (locally).