Hacker News Reader

Comment by diath | Hacker News Reader

The primary reason why it worked is because Claude could rip off the Linux driver. Without any prior work to rely on, how will the AI figure out proprietary hardware?

View on HN

He also mentioned it took 2 months. I’m actually wondering how long it would take to do the Linux to BSD port by eyeball, or at least ai assisted. Probably not that much longer? I guess it depends on wall time vs real time.

I estimate two weeks from having never seen kernel source to something reasonably stable based on experience with block devices/raid controllers. But I knew a bit of C (had patches merged into SVN, Exim4, etc).

And the BSDs code are fairly simple as things go. Lots of specific domain knowledge sure, but you can find books and article fairly easily. The code itself is straightforward.

Most hardware drivers are simpler than people expect. The hardware is usually designed to do the sensible thing in a straightforward way, and you're just translating what the OS wants into a bunch of bits you need to write to the right hardware register.

On the flip side, the perceived barrier is high. Most folks don't have an intuitive sense of how the kernel or "bare metal" environment differs from userland. How do you allocate memory? Can you just printf() a debug message? How to debug if it freezes or crashes? All of these questions have pretty straightforward answers, but it means you need to set aside time to learn.

So, I wouldn't downplay the value of AI for the same reason I wouldn't downplay it with normal coding. It doesn't need to do anything clever to be useful.

That said, for the same reasonss, it's harder to set up a good agent loop here, and the quality standard you're aiming for must be much higher than with a web app, because the failure mode isn't a JavaScript error, but possibly a hard hang.

Harder, but not impossible. You 3d print a jig for a solenoid and a relay so you can warm/cold reboot the laptop, get a pizerow setup and configured to be a keyboard you can control over SSH, a webcam watching the screen, a hardwired Ethernet port, a second computer to manipulate the Device Under Test (aka the MacBook/laptop with a missing whatever driver). Even though waiting on Claude Code doesn't hit flow state if you've only got one project going, setting things up so it can run with it is still fun, for specific and rather nerdy definitions of fun.

Or, for many things, a VM with hardware passthrough could work.

Very good point! Different busses are capable of different things. USB is great for that. Windows drivers, especially. Unfortunately laptop hardware is pretty hardwired in, so there's no escaping that there.

I would expect WiFi to be either usb or pci attached, so VM passthrough would work.

It also doesn't matter if AI is involved - you save yourself trouble either way.

I was thinking of the laptop that isn't waking up from sleep that I'm trying to get working when I wrote that. Although, hmm...

- have AI write a windows filter driver to capture all hardware communications

- have AI reverse engineer Windows WiFi driver and make a crude prototype

- have AI compare registers captured by filter driver with linux driver version and iterate until they match (or at least functional tests pass)

not exactly rocket surgery, and windows device drivers generally don't have DRM/obfuscation, so reverse engineering them isn't hard for LLMs.

So we send an AI agent to the French cafe instead of us?

https://download.samba.org/pub/tridge/misc/french_cafe.txt

Shouldn't AI be able to take this one step further and just analyze the binary (of the samba server in this case) and create all kinds of interface specs from it?

Make the LLM operate the hypervisor VM so it can observe a binary as it executes to write specs for it?

I'm working on this. It's wild.

Trial and error?

Just like it does when given an existing GPL’d source and dealing with its hallucinations, the agent could be operated on a black box (or a binary Windows driver and a disassembly)?

The GPL code helped here but as long as the agent can run in a loop and test its work against a piece of hardware, I don’t see why it couldn’t do the same without any code given enough time?

Presumably one would like to use the laptop before the million years it would take the million monkeys typing on a million typewriters to produce the Shakespearean WiFi driver.

Consider that even with the Linux driver available to study, this project took two months to produce a viable BSD driver.

This process took two months, including re-appraisals of the process itself, and it isn't clear that the calendar on the wall was a motivator.

The next implementation doesn't have to happen in a vacuum. Now that it has been done once, a person can learn from it.

They can discard the parts that didn't work well straight away, and stick to only the parts of the process that have good merit.

We'll collectively improve our methods, as we tend to do, and the time required will get shorter with each iteration.

Seems very promising but then you realize the LLM behind said agent was trained on public but otherwise copyright encumbered proprietary code available as improperly redistributed SDKs and DDKs, as well as source code leaks and friends.

In fact most Windows binaries have public debug symbols available which makes SRE not exactly a hurdle and an agent-driven SRE not exactly a tabula rasa reimplementation.

The Linux driver in this case is ISC licensed. There’s no legal or ethical problem in porting it. This is open source working as intended.

I feel like the jury is still out on whether this is acceptable for GPL code. Suppose you get agent 1 to make a clear and detailed specification from reading copyrighted code (or from reverse engineering). Then get agent 2 to implement a new driver using the specification. Is there anything wrong with that?

>anything wrong with that?

Wonder if the courts will move fast enough to generally matter.

As I understand it, reverse engineering for the purpose of interoperability is allowed under the law. The only thing subject to copyright is your code. So long as a separate implementation (made by an AI model or made by hand) doesn't use any of your actual code, you have no claim over it. Only the code is yours.

AI models make the process of reversing and reimplementing drivers much cheaper. I don't understand the problem with that - it sounds like a glorious future to me. Making drivers cheaper and easier to write should mean more operating systems, with more higher quality drivers. I can't wait for asahi linux to support Apple's newer hardware. I'm also looking forward to better linux and freebsd drivers. And more hobbyist operating systems able to fully take advantage of modern computing hardware.

I don't see any downside.

Drivers are usually easy to implement. What’s usually lacking is the specifications of the hardware. A lot of devices are similar enough that you can reuse a lot of existing code, but you do want to know which registers to read or fill.

True. But also -- how do humans do it? There are docs and there's other similar driver code. I wouldn't be surprised if Claude could build new driver code sight-unseen, given the appropriate resources

> But also -- how do humans do it?

Intelligence.

> But also -- how do humans do it?

Probably a mix of critical thinking, thinking from first principles, etc. You know, all things that LLM's are not capable of.

Except it often is the case that when you break down what humans are doing, there are actual concrete tasks. If you can convert the tacit knowledge to decision trees and background references, you likely can get the AI to perform most non-creative tasks.

If you have to hold the LLM's hand to accomplish a task, using human intelligence to do so, you can't consider the task performed by AI.

I half agree. But two points: 1) if you can formalize your instructions ... then future instances can be fully automated. 2) You are still probably having the AI perform many sub-tasks. AI-skeptics regularly fall into this god-of-the-gaps trap. You aren't wrong that human-augmented AI isn't 100% AI ... but it still is AI-augmentation, and again, that sets the stage for point 1 - to enable later future full automation on long enough timecycles.

> if you can formalize your instructions

Isn't that...code?

No. Think of all engineering disciplines that aren't software. Those all depend on human-language formal instructions.

Formal instructions paired by tables are almost as rigid as code. Btw normal engineering disciplines have a lot of strict math and formulas. Neither electrical nor mechanical engineering runs on purely instructions.

The non-software engineering disciplines I'm thinking of rely on blueprints, schematics, diagrams, HDLs, and tables much more than human language formal instructions. More so than software engineering.

Disagree, they rely on both equally, not much more on one of them. Consider the process of actually building a large structure with only a set of such diagrams. The diagrams primarily cover nouns (what, where, using what), whereas the human language formal instructions cover the verbs (how, why, when). You can't build anything with only one of the two.

And sure, the human language formal instructions often appear inside tables or diagrams, that doesn't make them anything less so.

This is based on having worked with companies that do projects in the 10 figure range.

Humans do it with access to the register-level data sheets, which are only available under NDA, and usually with access to a logic analyzer for debugging.

Usually, the problem with developing a driver isn't "writing the code," it's "finding documentation for what the code should do."

... and then figuring out where the hardware company cheapened out and created a whole unfixable mess (extra fun when you first ship your first 10k batch and things start failing after the vendor made a "simple revision"). Then finding a workaround.

Scientific method. There are many small discoveries humans make that involve forming a hypothesis, trying something out, observing the results, and coming to a conclusion that leads to more experimentation until you get to what you actually want. LLMs can’t really do that very well as the novel observations would not be in their training data.

Combine AI + genetic algo?

https://www.reddit.com/r/learnmachinelearning/comments/1665d...

GPL is not a patent. It covers the work and _derivatives_; it does not cover ideas or general knowledge. The chip in question has docs.

I fully expect that Claude wrote code that does not resemble that of the driver in the Linux tree. TFA is taking on some liability if it turns out that the code Claude wrote does largely resemble GPL'ed code, but if TFA is not comfortable with the code written by Claude not resembling existing GPL'ed code then they can just post their prompts and everyone who needs this driver can go through the process of getting Claude to code it.

In court TFA would be a defendant, so TFA needs to be sure enough that the code in question does not resemble GPL'ed code. Here in the court of public opinion I'd say that claims of GPL violation need to be backed up by a serious similarity analysis.

Prompts cannot possibly be considered derivatives of the GPL'ed code that Claude might mimic.

From the file headers:

SPDX-License-Identifier: ISC

Based on the Linux brcmfmac driver.

I'm going to ahead and say there are copyright law nightmares, right here.

That headers looks pretty reasonable to me. I don't see anything misleading or ambiguous about it. Whenever I am heavily modifying some licensed code, I always make sure to include a similar header.

    > I'm going to ahead and say there are copyright law nightmares, right here.

I am confused. My first thought was maybe the original Linux driver was GPL'd, but it is not. It is ISC'd. Look here: https://github.com/torvalds/linux/blob/master/drivers/net/wi...

    // SPDX-License-Identifier: ISC
    /*
     * Copyright (c) 2010 Broadcom Corporation
     */

It adds a contributor.

To add a contributor, you need "significant" _human_ input. The output of models has so far not been deemed copyrightable.

As it acknowledges the original source, it needs to show the human effort that allows it to be bound to the new contributors.

Eh. Copyright only matters if it goes to court. And you only go to court over copyright if somebody is getting sued. That only happens when a plaintiff has standing, they can show damages and the person they want to sue has enough money to make it worth their while. (And if they'll make more money than it costs them in lawyers and negative PR. Suing users and developers for interacting with the product you sold them is generally considered a bad look.)

Anyway, nobody is going to sue you because you added your name (or "project contributors") to an ISC licensed source file in your own repository. Nobody cares. And there's no damages anyway.

Especially when the line added is:

> Copyright (c) brcmfmac-freebsd contributors

If you're right, that's an empty category. Thus the inclusion has no effect.

Except...

In this case, they didn't really work from the chip's published documentation. They instead ultimately used a sorta-kinda open-book clean-room method, wherein they generated documentation using the source code of the GPL'd Linux driver and worked from that.

That said: I don't have a dog in this race. I don't really have an opinion of whether this is quite fine or very-much not OK. I don't know if this is something worthy of intense scrutiny, or if it should instead be accepted as progress.

(It is interesting to think about, though.)

As I mentioned in another comment, the original referenced source code from the Linux kernel is ISC'd, not GPL'd. See here: https://github.com/torvalds/linux/blob/master/drivers/net/wi...

I don't work on the Linux kernel, but I do poke around the sources from time to time. I was genuinely surprised to see that some hardware drivers are not GPL'd. That is news to me, but makes commercial sense to when I think deeper about it. When these manufacturers donate a driver to Linux, I don't think GPL is a priority to them. In the case of Broadcom, they probably want their WiFi hardware to more compatible with SBCs to drive sales (of future SBCs that use their WiFi hardware and run Linux). If anything, choosing a more liberal license (ISC) increases the likelihood that their Linux driver will be ported to other operating systems. From Broadcom's commercial view, that is a win to sell more SBCs (free labour from BSDers!).

Also, if the original driver was GPL'd, I am pretty sure it is fair game (from US copyright and software license perspective) to use one LLM to first reverse engineer the GPL'd driver to write a spec. Then use a different LLM to implement a new driver for FreeBSD that is ISC'd. You can certainly do that with human engineers, and I see no reason to believe that US courts would object to separate LLMs being used in the two necessary steps above. Of course, this assumes good faith on the part of the org doing the re-write. (Any commercial org doing this would very carefully document the process, expecting a legal challenge.)

I do think this blog post introduces a genuinely (to me!) novel way to use LLMs. My favourite part of that blog post was talking about all of the attempts that did not work, and new approaches that were required. That sounds pretty similar to my experience as a software engineer. You start with preconceived notions that frequently shattered after you walk down a long and arduous path to discovering your mistakes. Then you stop, re-think things, and move in a new intellectual (design) direction. His final solution of asking LLMs to write a spec, then asking other LLMs to proof-read it is highly ingenious. I am really impressed. Please don't view that "really impressed" as my thinking that the whole world will move to vibe coding; rather I think this is a real achievement that deserves some study by us human engineers.

Why is this “ripping off”? It’s an ISC Licensed piece of code.

It could be given reference material like documentation/datasheets and/or just be prompted as to how it should work.

Repurposing NDIS drivers is a time honored tradition. No source, but oh well.

I haven't read the article but my first question was, install wifibox?

It's a bhyve VM running alpine Linux and you pass through your WiFi adaptor and get a bridge out on the freebsd host.

Literally explained in the post, that’s why you read first.

Reply on news.ycombinator.com