- Add opt-in Apple Time Machine support

     Implement the AAPL negotiation and related Finder, stream,
     COPYCHUNK, sparse-file, CHANGE_NOTIFY, and RPC compatibility
     required for Time Machine shares, allowing macOS backupd to use
     ksmbd for backups

Still sucks that it has to be reverse-engineered

My father is mostly on Apple and tries to use his iPad as a PC, ie with files and "the filesystem", he tries to get out of using extra iCloud for pictures (using Proton, or he asks me about Immich, or he wants to use an external HDD, or use Synology Photos and backup). He's mostly on the iPad + keyboard because it's a nicely managed device update-wise and "what I can install"-wise, virus-wise.

But I recent told him: Just give up. Buy (rent!) the storage, you are too depended on me, there is always something with the non-Apple solutions. Yes, your iTunes library is a mess on the filesystem, just don't look at it through anything else than "Music". Yes, Proton Drive eats 400 GB of your iPad storage now, I don't know how to trim that regularly. I'm sorry, it's either Linux and I can help set some things up, or full Apple. Choose. His current mixed, "trying to get best-of-both-worlds", approach is just pure unexpected pain, every time again.

Edit: I also have an iPad, it does work for me, but where my father is trying to use his iPad as a central, primary device (the hub), for me it is a client (spoke) of my own infra. Apps get access to information and I never use Apple services for anything. So indeed, Immich, Proton, Home Assistant, government and banking apps, etc. My iPad is throw-away: If it dies, it dies... I buy a new one, log into all (self-hosed) services and I'm 100% back up and running. Doing the same for my father is also pain, because his Home Assistant will have issues, or his Immich instance, and it's real work to fix, and he won't tell me for months if it does not work and work piles up. So, I tell him to surrender to Apple... It die a little inside.

Since he apparently wants a PC, isn't the logical conclusion the opposite? "Just give up. Buy a Windows/Linux laptop, you are too dependent on Apple, there is always something with the Apple solutions."

The current plan is to put Ubuntu on the Macbook, not sure what to do with the iPad but make it less "primary computer" will be one of the policies to implement indeed. Maybe he will be happy with an external disk and f-spot, and his music nicely sorted into files. Then some generic backup solution to a Synology NAS or something...

macOS also has (well, had) extreme UI stability. You could transport someone from 2003 used to Mac OS X 10.0 two decades into the future and they would be able to use macOS Ventura (and all previous versions) purely by muscle memory. Good luck doing that with Windows and Linux with their constant UI churn.

Interestingly enough, by iOS-ifying macOS, they've made it much easier to shift someone using an iPhone from Windows to macOS, because they already recognize many of the UI and UX paradigms.

Once it's configured for these kind of people, it's really fire and forget, and it was already that in 2016.

She did go back to fix things because the grandma managed to delete the printer, and she said that the downloads folder was full of exe files with sketchy names.

I'm with you on the macOS stability in the past. The thing that gets me is that Windows somehow gets a pass in this regard, but there have been some pretty big changes over the years.

When I say it's been fire-and-forget, I mean that for at least two decades.

If papercuts turn up, you are running the wrong distro or secretly a power user that naturally causes problems for themselves every now and then. This won't happen with normal users on a long term stable distro.

They never managed to get it working for their liking, it wasn't able to run the stuff their friends used to talk about or share via CD/DVD/USB sticks, and they did not wanted to bother me with "dumb" questions.

So I rather that they have Windows, go down to the local PC store when something isn't working as it should.

It's been a while since I experienced people sharing software one discs by the way, it's been a while since I saw discs at all ;)

Only if the device is truly 'forgotten'. As in, it is an appliance that's going to do that task forever and ever. Be it web browsing or what have you.

If requirements change, it becomes a problem. If they have to do work on them and interact with companies, you may need either Windows or Linux. Thankfully online Office365 removed a big use-case. But there are others. It is very likely that whatever package you need will be available on Windows or OSX.

My mother wanted a device to just access internet banking. Gave her a netbook (remember those?). Only successful Linux use-case for non techies I've succeeded at.

Same philosophy as doctors who don't provide medical care for their family.

I can't fathom using Windows voluntarily these days. Even for gaming, Bazzite is janky but it's serviceable, and anything is better than Windows. It's almost shocking how much worse things are than Windows 10, which itself was a major victory in Microsoft's war against its own users.

So the Minecraft crew would regularly release updates and obfuscate the code again - most updates were to fix issues/add features, but some were purely for obfuscation. So if you wanted your mod to work it meant not playing any other version.

I'm guessing we'll start seeing more regular updates from software makers; will the updates be fixing bugs or adding features - sure - but I'm guessing that quite a few updates will be simply to obfuscate the code and change addresses around so that any mods that worked before, won't in the new version. Sure an LLM could just decomp it again, but I figure most people won't want to spend the tokens/time it takes for the LLM to actually do the work on that new decomp effort. And with the fact that most people have "auto-update" defaulted to on, I'm foreseeing that apps will get auto-updated likely daily in the near future to combat this.

Years ago, someone once told me "I hope you live in interesting times" ... I don't think this is what they had in mind.

Edit: But good point of course, but I believe it will remain cat and mouse, no idea how Apple internally sees it, whether they really don't care, or actively break stuff (break your ** face tonight).

That was the same issue with jailbreaking, it gave a lot of freedom, while also being a PITA to deal with at every security fix and system change. Many jailbreakers came to parent's conclusion and just "give up".

I love Proton services and have been a subscriber for years. I do not understand what is going on with this. I have proton drive on my iPhone, I manually open it monthly to let my photos sync. I pay for the storage on proton drive to _save_ space locally, but whenever I sync to proton drive the storage space used locally by the app is almost equal to a local photo library! Yes I can delete the app, re-install it monthly to sync my library once, but it quickly balloons to dozens of gigabytes when I start to sync my local photos.

Can anyone at proton explain what is going on here?

1. Local storage is cheap, I have lots of it. I want multiple copies of my data so that they will serve as backups. I want everything in the cloud to be copied locally. (I'm in this category.)

2. Local storage is cheap if you look at the price of external hard disks, but my phone or tablet only has a limited amount of it, and no way to upgrade without buying a whole new device, so it is scarce for me. I want nothing in the cloud to be copied locally, unless I am specifically using it on this device. (Sounds like you're in this category.)

Half the people think the first use case is the obvious one. Half the people think the second is the obvious one. And that includes developers, who will design the product accordingly without giving it much thought. So either half the users get a nasty surprise in the form of running out of disk space, or the other half risk an even nastier surprise in the form of data loss.

Obviously, computers pester us with too many questions these days, but I think this is one case where the software really does need to ask the user which behavior they want. Perhaps with a hint based on how much local disk space seems to be available.

* https://support.apple.com/en-ca/104984

The "3-2-1" strategy is even possible if you rotate drives between locations:

> For extra security and convenience, you can back up to multiple disks. If you work in two locations, you may want to keep backup disks in both places.

* https://support.apple.com/en-ca/guide/mac-help/mh40739/mac

edit: to be clear you can still use a network drive, but how well that works is the big question. It will probably depend on the user and the setup. The Macs in my house backup to a share on a Pi 4. They can still restore files from it just fine.

To be absolutely complete, I could mention that at least one SAS HBA PCIe card exists on the market with support for macOS 27, even. Sometimes bundled with other products...

Really? I guess now that the Mac Pro is discontinued, products like that are on borrowed time.

People also connect LTO tape drives using this interface.

Besides that, whether a throughput limit defeats the point depends on what the "point" was to begin with, as well as what the alternatives are.

https://www.reddit.com/r/MacOS/comments/18sjnwb/state_of_mac...

If Samba is built with mDNS support, that’s all you need, but it typically isn’t, so you also need to advertise the share using avahi-daemon or systemd-resolved on their respective configurations.

[1]: https://www.samba.org/samba/docs/4.9/man-html/vfs_fruit.8.ht...

With AI and stuff like rea.tools does that really matter anymore?

Let's just accept that this is the new norm: Giant companies who had over 20 years to open their shit up, chose to be ass about it and refused, and now we can just take it. Screw them.

Not 200Gbps of 16kB block writes, that's for sure.

Agree with you on the rest about kernel vs userspace, just taking issue with the bit about a single CPU core.

The link will be whatever the fastest network port you can get on an apple machine is. Its not 200Gbps - the apple end will be the limiting factor. A single core can probably fill that just fine.

And being pedantic - 200Gbps links are not a significant percentage of installed network ports in the computers in the world... so "almost any" is pretty accurate.

Certainly not a guarantee at today's link speeds. We're increasingly leaning into RDMA and other forms of offloading for a reason.

I tried setting up SAMBA by itself (on Debian) for Time Machine, but for it to work it seems to want Avahi running for mDNS; the problem is there is some weird bug or maybe user-related blooper where it collides with itself from time to time, leading to local DNS weirdness

https://github.com/apple-oss-distributions/SMBClient

I’m not sure where Phoronix/the author got the information that this was reverse-engineered, because the patch doesn’t say that either.

hopefully without kernel-slops :P good job everyone btw!

During peer review a race condition was found in his code. Would he have spotted it himself when writing the code manually? Maybe, maybe not. He's only human, and the AI is only AI.

I'm in the "AI is great!" optimist camp myself, which is how I felt in the very early days of "this little crappy hobbyist Linux kernel thing that'll never go anywhere important" minix-list flamewars.

Once again, Linus demonstrating that those who understand the code, own the code.

I think this says way more about the industry being completely out of touch and less about Linus leading the pack.

There are intelligent arguments against using AI, your comment is not referring to any of them.

In short: Linus feels responsible for the quality of the Kernel, he expects the same of other devs. He does not care about the tools used to generate the code. He (or some other human) will call out submitted slop, whether LLM generated or human generated.

The kernel developers are probably a bit further in their thinking then some developers. They've been dealing with many thousands of contributors for decades. Git was invented by Linus Torvalds specifically to deal with ensuring only the best patches make it into the kernel.

Somebody posted a video with Greg Kroah-Hartman last week or so commenting on how he's been dealing with all the AI generated security bug reports. His key point is that AI generated reports are meaningless unless they come with a suggested fix as well. If you are going to generate the report, you might as well generate the fix. And it's a lot easier for him to review if the fix fixes anything worth fixing then to piece together a fix from a lengthy report. The larger the report, the less likely it is to get any attention. If the person contributing can't articulate why the fix is needed or how it works, they just reject the change and toss it back. That strikes me as very pragmatic. Judge a change on its merits. Not on how it was created. A report without a suggested fix is relatively meaningless.

The answer to this issue is not to equate any code generated by LLMs to slop. It is just not true. As you say, the latest models often flag things that I would definitely miss, or they simplify my code significantly with a just-released feature. I see benefits to code quality all day from using LLMs.

I'm just saying (not to you but to comments below): Lets keep it constructive, which means: lets keep it real, as in close to truth. Yes vibe coding exists, and it has it's place (ie in prototyping?). But not in the kernel, and also not in my own line of works. LLMs do have a place there though.

And it can read all of the logs in the backend and browser simultaneously and understand what is causing issues. I’ve used that a few times and it is such a game changer for weird bugs.

slop is slop.

Human slop is equally as bad, but this is not what Linus chose in this case, he chose to accept the higher risk of almost 2x as much more bugs using LLMs which lead to the introduction of LLM slop.

I don't care if it is Linus or anyone else, slop is slop human or not, with LLMs it is far worse.

I force all work to be split up into chunks, properly investigated, spiked, and planned out, and then implemented via TDD (with only system-boundary mocking permitted). It's not perfect, but I've seen regression bugs very much cut so far.

Beyond that, if it's a GUI app, I also require the TDD cycle to require GUI tests with screenshot evidence, and proper assert statements.

He didn't even review the code. [0] Someone else did.

[0] https://lwn.net/ml/all/as6vBoWQGglxXxb0@thinkstation/

This is what happens when you use LLMs and this is far more irresponsible of Linus because he is vibe coding C code in the kernel.

You know it won't be properly reviewed and understood.

Using LLMs to review code is much more useful imo but it can also cause problems due to the natural lazyness of a person.

You wouldn't want the OS you are using to be developed by a dilligent but a low IQ and mediocre skill level programmer.

I'm not saying other people can't possibly use LLMs to generate code effectively but it seems super suspicious from my experience as it triggers laziness and reluctance to put effort into understanding every piece of code.

Do you now?

> You wouldn't want the OS you are using to be developed by a dilligent but a low IQ and mediocre skill level programmer.

So you also know that people using LLMs to produce code are diligent but low IQ and mediocre skill?

> it triggers laziness and reluctance to put effort into understanding every piece of code.

Linus has been mostly reviewing code for what... decades? The rest of the contributors have been his LLM in some way. Would you say that he has gotten "reluctant to put effort into understanding every piece of code" he reviews?

And then somehow consider that because LLMs can make bad programmers worse, it has to mean that it will make all programmers worse. And therefore Linus Torvalds using LLMs will necessarily make Linux worse.

Something like this?

This reads a bit weird in hindsight but what I meant was it just feels like that to me.

> I'm not saying other people can't possibly use LLMs to generate code effectively but it seems super suspicious from my experience as it triggers laziness and reluctance to put effort into understanding every piece of code.

This part is my personal experience with trying to use LLMs for code review and sometimes to write a bit of code via opencode.

> diligent but low IQ and mediocre skill

This is how I see LLMs.

In my personal experience, it is not worth to make it write code because then reviewing the code becomes more work than actually writing myself and get LLM review + fix and review again myself.

It can be very good at writing code but the instances where it messes up just cost too much for me to disentangle and making it write things I don't understand doesn't work because I can't review.

I can't judge Linus Torvald's ability but this is my perspective so if I had to guess, I would guess that it isn't necessarily efficient for him to generate code with an LLM because he is spending more time reviewing it compared to him writing the code.

> In my personal experience, it is not worth to make it write code

Sure, totally fine with that! I am completely okay with people not using LLMs, just like I am completely okay with people using an IDE instead of vim. Do what works for you.

> I would guess that it isn't necessarily efficient for [Linus Torvalds] to generate code with an LLM

It seems like he disagrees: sometimes it makes him more efficient. But in any case, I think it is his choice. I won't judge him for using an LLM, or an IDE, or even if he wanted to develop on Windows. Why should I care? I care about his contributions.

My problem is that many people say "I don't like working with LLMs, so I don't want other to use them". If you don't like working with LLMs, just don't. And let others use the tools they want.

Except if it is philosophical: something like "I believe LLMs are bad for society because X and Y, and I don't want to be related to them". Similar to "I don't want to work with weapons" or "I refuse to open source my code because it could be used to build weapons". Sure, I respect such ideas. I don't respect the "I don't like this tool so I think people who use that tool are unprofessional".

Features? Bugfixes? What? Look how many commits we've got!

2. This type of stat was always being shared with each new release, giving a general indication of the size of changes. They did not started posting it all of a sudden due to AI.

Is this satire? :D

A process which is chrooted into failfs cannot open new files. It is limited to the set of filesystem file descriptors it already has open (presumably set up before the chroot or inherited into the process from some container runtime).

I'd love if chrooting would become easier. In particular a requirement to have bash or a specific shell is annoying; imo a simple REPL should suffice already there. I wrote one that works years ago, need to look into what is all needed for a chroot (I always used bash for this but I'd also want to change to my own shell eventually).

[1] https://en.wikipedia.org/wiki/Capability-based_security

https://docs.kernel.org/next/filesystems/failfs.html

Unfortunately, yu can't use dynamically-linked apps anyway since failfs would break absolute path resolution loading system libraries.

EDIT:: But I guess yu could put a statically linked app on the socket, wrap it in failfs and gave it proxy requests to a dynamically-linked app process if your app must use something like python.

Almost always youre better off producing a bundle which has everything (excluding the runtime) included... Or just use better languages which categorically don't even have this scenario, eg golang, Java, rust, etc pp

I am the person addressed when someone says "you", not "yu". Why is that person changing how I'm addressed?

It's also confusing because it feels initially like it's some new Linux command or user, like "su".

> Device Tree Updates

> Apple platform gains support for M3 Pro, Max and Ultra SoC

Incredible how fast support for Apple silicon is progressing.

https://x.com/JoshuaSWarren/status/2111923039378211100?s=20

They are truly and utterly a definition of a slop. And, expectedly, their work is unstable and not efficient, just look into Reddit discussion complaining about power draining.

I am afraid no one, or very few, has any deep understanding of low level architecture of these platforms or even Linux kernel and hardware in general, looking at their contributors’ previous front end NodeJS projects.

The only good thing is you can take their otherwise time-consuming work, have an agent infer and write a spec and use that to implement proper improvements.

It makes no sense to put them down on HN. I love using Omarchy, and like many others, I coudln't care less about what's going on under the hood. It works great for me, is OSS and I can tweak it anytime I want. Critical Bugs get caught quick too.

> why don't you submit some PRs to help them improve?

Is often a non-starter. If you believe a codebase is poor quality, any changes to improve it have a strong risk of making it worse and/or wasting your own time. In the case that you aren't a key player in said codebase already, it is even more likely your attempts to make changes will fail. Its not impossible to improve these repositories however doing so is quite a different skill-set to identifying their failings.

This is why there will likely be fragmented efforts for bringing up the hardware. Asahi already struggled merging all of their patches into the kernel, there's a 99%+ chance that Omarchy's patches will never be fully upstreamed if the reverse engineered devicetree is uninterpretable vibeslop.

So, even though Asahi's the slow-and-steady side, it makes a lot more sense to channel your effort there.

The device tree is the least of a problem, it's a very limited, highly structured language, you don't need super deep understanding of things to get it right.

Problem is the drivers they write. The hacks, the workarounds, the utter mess. There's hundreds of commits that I am certain no one keeps track of and understands their true purpose.

You think it's the same amount of time for both?

> It makes no sense to put them down on HN

Put them down? How, by sharing what I saw in their codebase, which anyone else can also do?

That's some apologist nonsense here and you sound super biased with those suggestions. I made and effort to assess the technicality of what I saw and I would absolutely stay away from what they do.

> Critical Bugs get caught quick too.

This is not just about kernel oops kind of bugs with a nice trace that LLM will fix in 5 minuyes. It's the race conditions, the lockups, all type of architectural, high-level things that their code does that create non-deterministic bugs, i.e. untraceable and virtually unfixable by LLMs nor a human being.

The fact this needs explaining even...

Furthermore we are lucky that Apple at least tolerates Asahi and does not throw at them more technical hurdles, legal issues (DMCA?) or whatever. Based on past history (in the 90s, so a lot of management changes) Apple would shut them down if they were a threat to their bottom line. I remember the shortly allowed Mac clones so, a possible scenario: a significant fraction of sold Macs is immediately reinstalled with Linux and provide zero dollars to cloud services and followup sales of other hardware. Apple is not going to like that.

Would be cool if Apple decided to support Linux, of course. But why would they? If it was profitable for them, they would do it. Instead they think it's more profitable to enshittify their products. That's life.

Now people who reverse engineer that to help us run Linux on Apple hardware... I would guess they don't make a fortune doing that, and I find it impressive work.

Sure, Apple (like all other BigTech) suck. But the Asahi project is quite amazing. I don't see a reason to complain about the Asahi project.

This analogy is really tortured. Apple doesn't make bikes.

But they do make software, and hardware. People want to use them however they choose.

This is more like a bike company choosing a proprietary air valve that only lets you inflate your bike tires with their own company-branded air pump, even though there's been other air pumps for many decades before them, and their design isn't particularly better than the others. And you say "well they don't have to design an air valve adapter to use other air pumps" and -- yeah, that's true. But people are gonna bitch.

So we agree :-). Of course I would like it if Apple was making my life better. I just find it naive to consider that companies are anything other than profit-maximizing machines. If they happen to do something you like, it's because it is profitable for them. They couldn't care less about you.

> But people are gonna bitch.

Whatever you do, people are gonna bitch. Again it would be a bit naive to think that if you do "your best", or if you do "what's right", or if you "genuinely try", then everybody will appreciate. There will always be enough people bitching, of that I am certain.

So we agree :-)

Well, to be fair, they occasionally make rather nice hardware.

For my usage, the reason the Linux-on-Mac efforts are useful is that Apple hardware becomes easily and cheaply available once it is no longer supported. My home server is an old Mac Mini (GigE, HDD + SDD, double core Haswell, 7 W power envelope, doesn't take up space, silent) running stock Debian. When it dies, I'll probably be able to replace it with an M2 model, thanks to Asahi and friends.

This created a large enough market for Linux distros installed on Apple hardware to make it a sustainable business model the makers of Yellow Dog Linux to buy the hardware through a reseller channel, ship it to the building, install Linux on it, then ship the device to customers. I worked there and it was fun.

Lots has changed since then of course, one of which being that Apple controls the chip from top to bottom, and their near-indifference in 2004 now seems to have transformed into something more adversarial.

I mean that if Asahi starts to gain on Apple with respect to generation of M chip they support. If Asahi supported M4 chips...

But clearly, my dream hasn't come true yet :-)

> What is it that you think is in the hardware that you'd be able to unlock with linux but isn't exposed by MacOS?

I believe that Linux would give me more control over exactly what is running on the machine (and using up precioius memory). Maybe it would also have better support for the toolchain/ecosystem needed to run local inference?

Pretty disappointed in Qualcomm's promise of upstream support for Snapdragon X Elite turning out to be: lol, not actually so you can run Linux on devices, only so you can maybe boot without most devices working...

Hope things will keep improving despite lack of help from vendors.

It's the firmware that locks up - with Bluetooth and wifi devices not working at all anymore (does not show up in Linux or Windows device manager). And even a complete power drain and reboot can't resurrect them.

So, I would be super interested how you inferred it was Linux’ fault but I sssume b/s at this point.

"Fried" was a poor choice of words - the device is dead - but it's due to firmware and probably something to do with sleep states.

I didn't mean to imply the radio was actually fried.

It'll be interesting to see what the technicians end up doing to get it working. It might be enough to disconnect the card and force some even deeper reset than a power cycle with drained laptop battery does - but as I still have valid guarantee on the machine, I stopped short of opening it up. Especially since I might need a new wifi card anyway.

Chance is you could probably have Claude or Codex had look into it and have them fix it for you.

Ed: user AI on the Linux side, to help with getting firmware blobs etc - might be random combination of flaky firmware, flaky Linux support and reboots that did it - not AI or any particular driver/firmware version.

It's the first time I've seen drivers knock out a hw component completely on a consumer product - but I gather the platform is fickle.

The arm64 Snapdragon elite support is very poor unfortunately (due to there being zero upstream support).

Which wouldn't be so bad if they weren't marketed with a promise of Linux support.

https://github.com/hakuna-m/wubiuefi

I'm not saying it's a great idea, but I'm explaining why people may expect to have a smoother path here.

I'm reading that as many new AI assisted code patches. Not everyone does an obviously bad job at submitting AI assisted code.

Not a criticism, just an observation.

https://docs.kernel.org/process/coding-assistants.html

Broadly it says: you can use AI as much as you like. You have to disclose use of AI. You, as a person, not the AI, are responsible for the quality of Linux kernel submissions.

If you spent 20 seconds to generate a patch and just hurled over the fence to be reviewed is no worse than spending 3 hours to manually write a fix that fixes 1 thing and break 2 others.

As someone who doesn't know much about linux kernel work: what does being responsible for the submission look like in practice? Are you expected to find fixes if your change causes unanticipated issues?

At least that's how I do it. When someone offers a patch to an open source project, I don't really care if that person has a PhD, or if that person does this in their free time, or if that patch is actually the result of a whole team working together. I judge the patch based on the value it brings to me as a maintainer.

Obviously the code has to be good, but also the interaction with whoever offers the patch has to be smooth: if I have a question, if I need them to confirm/change/test/elaborate on something, I need that to work.

If I feel like I would be faster doing the work myself AND this author is not putting effort into it (e.g. they just copy-paste an AI), I will not review that work. Possibly I will distrust that author. If too many contributions end up wasting my time, I will start limiting the contributions to people I know/trust, etc.

In terms of maintenance, I don't see a difference between getting a contribution from a stranger or from a stranger using an AI.

In terms of philosophy, that's obviously different: One may not want to accept contributions from people using AI because they think that AI is bad for society, for instance. And I would totally understand that. But if the stance (and it seems to be Linus' stance) is that a patch is only judged based on its technical merit, then I don't see why AI-in-the-loop would be an issue.

Perhaps not in terms of maintenance. In terms of provenance there is a significant difference between "I wrote this." and "I found this."

Which means that "as a maintainer", I don't write anything. I merge code that falls from the sky. Whether it was an AI cloud or a manual-coding cloud, I don't know: from where I stand, it falls from the sky.

> there is a significant difference between "I wrote this." and "I found this."

Of course. When I write code ("I wrote this"), then it does not fall from the sky: I wrote it. I know, it's me :-). But in the open source world, being a maintainer means that you deal with code that falls from the sky. Unless you decide to close your project to contributions and only accept people you trust.

That's very well put. I'm stealing your wording.

The thing which I think is going to be a very sore lesson for everyone at some point is that if anyone uses AI it becomes a burden for everyone. Even in projects that reject all AI usage.

What I can do is create 50 personas that all contribute patches. 40 of them get called out and are distrusted, but 10 make it through. I can give more focus on those 10 to ensure their trust level increases. Then slowly have them all come together to shepard some subsystem where I'm going to be the only real person involved and can sign off on my own work in a that looks like I have oversight from the outside.

In the past this was possible but took a very high cost. You need a bunch of competent software engineers who you can trust not to blab their secret mission. Today anyone can give it a try.

However, I remember that a couple of university researchers (PhD candidates maybe?) thought it would be a good idea to introduce security issues in Linux, and managed to do it. Without AI and without a lot of resources.

A consequence of that was that Linux immediately reverted all the patches coming from that university, saying "we don't know if we can trust you guys" (but really I guess as a way to tell universities "if you fuck with us we ban you, now keep your people in line").

And that's what I was thinking about when I said that if too many contributors misbehave, as a maintainer I will just stop accepting contributions from people I don't know. And maybe that will happen. Maybe it will be harder and harder to just be accepted into the club of the people who can send a contribution and have it reviewed at all.

It's just another way of saying, you can't have AI submit things on its own and you can't "blame" AI for anything you submit, you're expected to understand and be able to explain anything you're putting forward, if there is an issue with your submission, doesn't matter at all if you go back to AI to address it, so long as all issues are properly addressed.

The code is either of sufficient quality, or it's not, doesn't matter whether you or AI wrote it, it's your name on it, you're responsible for it and its your reputation on the line.

Should be applied to anything someone is releasing without big disclosures.

At least until a few months from now when it will be clear that human code is the weak point.

(And in reality EVERYONE's AI policy is a variation of this no matter how strict they get, because very few people will suddenly rip all of tridge's code out of Samba if he admits he used AI once, and nobody can withstand slopspam for long.)

That last part is worth highlighting: you always have the option to not follow-up and abandon your proposed change, in which case it won't make it into the kernel. (Unless someone else picks it up and volunteers to get it into shape for that is acceptable for merging into the kernel, but that is vanishingly rare, unless the change is trivial.)

You aren't expected to hang around and maintain your patch once merged, that's what subsystem maintainers are for. But you would be making their lives a lot easier and earn a lot of respect if you did.

How long until we get "all FOSS code is made by AI and so it's not copyrighted" arguments when using code in unlicensed ways?

It also hides what would be a great signal on which ML models to use to get the best quality code. Like, wouldn't the community like to know which models made the code with the least bugs?

(This is why fan made videos using copyrighted characters can be taken down.)

They dont think the juice is worth the squeeze. LLMs are just another tool.

You should read reasoning behind the decision.

https://www.theregister.com/ai-and-ml/2026/10/14/linux-kerne...

[0] https://lwn.net/Articles/1099594/ (user required).

[1] https://lore.kernel.org/lkml/20261009083137.3-1-sashal@kerne...

Nothing says you have to use AI. Just like nothing says you have to use a computer. You could have someone print the code for you, write your patch with a pencil on paper, get a pigeon to send your patch to someone who can then submit it, and it would be judge in the same manner. Granted, it's probably more efficient to use a computer.

Except your employer, usually.

You are right, that many of the more serious, less casual contributors are probably paid.

This is no longer true.

*Linus does it*

Linux maintainers: Goddammit!

Doesn't this just end up with the tech billionaires being the only ones who can make software. Will they decide to allow their models to maintain/create FOSS? Seems unlikely.

It worked out.

The main AI assistance was in determining why my mouse's battery level was easy to see, but not my keyboard's battery level. Having assistance identifying the information pipeline (kernel -> UPower -> xfce4-power-manager) and then identifying which step was broken was vital for me starting the project. The patch itself was trivial, so no coding assistance was needed.

unfortunately no stats displayed :)

though not updated yet, but the script is on GitHub

https://github.com/tb0hdan/rusted-kernel

https://pages.skybrian.com/2026/kernel-cve-fixes/

(Disclosure: I work for Morse)

Surely some code reuse would have been possible? Especially when the same team who write the driver are also making the firmware

You can tell that I'm skeptical. Kernel code tends to be pretty tight.

Honestly seems pretty interesting. I had a lot of fun setting up a 4G carrier for my home so I can get decent speeds out on my back porch (5GHz can't cut through my ancient balloon frame walls/door, and 2.4GHz is a congested soup around me, useless), I wonder if I can wrangle some hardware together and start experimenting with this.

Note that the MM8108 (the chip supported by Linux) is a single-stream (no MIMO) 8 MHz implementation. So it's limited to 43.3 Mbit/s at the link layer. Which is still pretty cool, but nowhere near the figure you quote.

- Morse Micro - Newracom - Taixin are mostly not compliant (but cheap) - Amazon have a proprietary not quite compatible HaLow in their Blink cameras

There's varying levels of interest in WFA compliance/interop. Morse and Newracom are the most interoperable, but even then there are gotchas.

The Morse ones, are, of course, the best ;)

Aside from upstreaming, one of the other things we're chasing is a better regulatory environment. In particular, the EU S1G bands are very tightly constrained.

Expect catastrophic problems. There is likely a lot of slop in the code now + testers already found race conditions.

Torvalds' behavior in the past few weeks has been alarming.

This is especially with C code which has hundreds of foot-guns and you can just look at how Linus does not care about code quality in something as critical like an OS kernel and then carelessly introduces a race condition.

If that was anyone else and Linus caught it, they would be completely smoked by his wrath in the mailing list.

Either way, an LTS appears to be released ~every 6th version, 6.18 is the newest LTS, so after that there's 6.19, 7.0, 7.1, 7.2, 7.3, 7.4 maybe LTS?

kernel.org has a nice FAQ about this topic.

https://www.kernel.org/category/releases.html

edit: it is on purpose that gkh doesn't make that an official stance, see reason here: https://lore.kernel.org/lkml/[email protected]/

This is how I learned there's a mainline kernel-mode SMB server!

https://docs.kernel.org/filesystems/smb/ksmbd.html

1) why does it matter “my” patch was submitted? I am simply a bystander but can’t help notice a tone of being admitted to a tribe? Am I wrong ? (It’s ok if it’s a tribe just validating my observation is correct or incorrect)

2) is the Linux kernel on its way to obsolescence? Our field of software engineering and how and what it’s applied to is changing at a drastic rate. The os was built for programs to run which were built by programmers. The programmers thought about what the users of their programs needed to get stuff done and use the programs. This paradigm is changing - fast - an in 10 years it’s going to be very diff place where the users simply build programs or their agents etc. thier expectations of the OS and what “services” and interfaces the os exposes is going to change. And at some point the current os architecture is just not relevant. To build an AI first OS it’s prolly easier to build it from the ground up than keep changing Linux. It’s like we can keep trying to slap on jets to the car to make it go faster but it’s prolly just better to build a plane. We still will need to travel just what we use is going to be diff and as such older mechanisms of traveling will just be irrelevant. Why am I wrong ? What am I missing ?

If you want your code in the kernel, it has to be accepted. If you don't care, then it doesn't matter at all.

> is the Linux kernel on its way to obsolescence?

Only if computers are, which is unlikely.

> Our field of software engineering and how and what it’s applied to is changing at a drastic rate.

Rate of change is not a useful metric here.

> The os was built for programs to run which were built by programmers.

AI code is still programs written by programmers, it's just some of the programmers are AI.

> The programmers thought about what the users of their programs needed to get stuff done and use the programs.

Yes, this is how you build software useful to the users. This won't change. If you make a program without thinking about how it's used, you haven't made a useful program. There are lots of apps throughout history in this pile, programs that were never fit for use.

> This paradigm is changing - fast

It's not, and it never will. Programs always have to be fit for use, and have to be useful tools for the users.

> - an in 10 years it’s going to be very diff place where the users simply build programs or their agents etc.

This doesn't change anything about Linux or applications, though. 100 years ago you bought meat and veggies grown nearby so your home because we didn't have transportation. Refrigerated trains made it possible to ship food long distances quickly and while cold. However, this did not change the way people ate the food, they still used pots and pans to cook, plates and utensil to eat, etc. Same thing here. Rather than artisanal, hand crafted code we'll use robot-generated code, and it won't matter at all to the user, or how applications need to be fit to the job.