Comment by MutedEstate45

> IANAL, but AFAICS this leaves 2 options, switching the license or removing that dependency.

There is a third option: asking the project for an exception.

Though that is unlikely to be granted¹ leaving you back with just the other two options.

And of course a forth choice: just ignore the license. This is the option taken by companies like Onyx, whose products I might otherwise be interested in…

----

[1] Those of us who pick GPL3 or AGPL generally do so to keep things definite and an exception would muddy the waters, also it might not even be possible if the project has many maintainers as relicensing would require agreement from all who have provided code that is in the current release. Furthermore, if it has inherited the license from one of its dependencies, an exception is even less practical.

Once the license issues are resolved it would nice if you could install it on a distro with the normal package manager.

The FSF thinks it counts as a derivative work and you have to use the LGPL to allow linking.

However, this has never actually been proven in court, and there's many good arguments that linking doesn't count as a derivative work.

Old post by a lawyer someone else found (version 3 wouldn't affect this) [1]

For me personally I don't really understand how, if dynamic linking was viral, using linux to run code isn't viral. Surely at some level what linux does to run your code calls GPLed code.

It doesn't really matter though, since the FSF stance is enough to scare companies from not using it, and any individual is highly unlikely to be sued.

[1] https://www.linuxjournal.com/article/6366

> This would only apply if they were distributing the GPL licensed code alongside their own code.

As far as I understand the FSF's interpretation of their license, that's not true. Even if you only dynamically link to GPL-licensed code, you create a combined work which has to be licensed, as a whole, under the GPL.

I don't believe that this extends to calling an external program via its CLI, but that's not what the code in question seems to be doing.

(This is not an endorsement, but merely my understanding on how the GPL is supposed to work.)

This is a false analogy. It's quite straightforward.

Running bash (via exec()/fork()/spawn()/etc) isn't the same as (statically or dynamically) linking with its codebase. If your MIT-licensed one-liner links to code that's GPL licensed, then it gets infected by the GPL license.

GPL is for boomers at this point. Floppy disks? Distribution? You can use a tool but you cant change it? A DLL call means you need to redistribute your code but forking doesn't?

Sillyness

Compatible means they can be linked together, BUT the result is GPL-3.

That would be a derivative work, and still be subject to the license terms and conditions, at best.

There are standard ways to approach this called clean room engineering.

https://en.m.wikipedia.org/wiki/Clean-room_design

One person reads the code and produces a detailed technical specification. Someone reviews it to ensure that there is nothing in there that could be classified as copyrighted material, then a third person (who has never seen the original code) implements the spec.

You could use an LLM at both stages, but you'd have to be able to prove that the LLM that does the implementation had no prior knowledge of the code in question... Which given how LLMs have been trained seems to me to be very dubious territory for now until that legal situation gets resolved.

AI is useful in Chinese walling code, but it’s not as easy as you make it sound. To stay out of legal trouble, you probably should refactor the code into a different language, then back into the target language. In the end, it turns into a process of being forced to understand the codebase and supervising its rewriting. I’ve translated libraries into another language using LLMs, I’d say that process was 1/2 the labor of writing it myself. So in the end, going 2 ways, you may as well rewrite the code yourself… but working with the LLM will make you familiar with the subject matter so you -could- rewrite the code, so I guess you could think of it as a sort of buggy tutorial process?

Tell me you haven't used LLMs on large, non-trivial codebases without telling me... :)

I'm not blind but spoken English it's far more difficult to grasp than written one (I'm a non-native speaker), and Flite runs on n270 netbooks at crazy speeds with really good enough voices.