Cheat Engine contains GPL-licensed code but disallows commercial use
github.com
github.com
I could just be bad at following what is going on too, since this is the first time I have seen this.
> modify it under the terms of the GNU Lesser General Public
> * License as published by the Free Software Foundation;
LGPL, not GPL.
No shady stuff going on either, https://github.com/mirror/tinycc/blob/mob/tcctools.c sais the same thing.
Edit: texi2pod.pl however does seem to be GPL, and not LGPL: https://github.com/mirror/tinycc/blob/mob/texi2pod.pl however, perl isn't linked, so there's probably a way out there.
il-opcodes does seem to be GPL2+, and the header arguably would end up in the binary thus forcing everything to be GPL? https://github.com/mirror/tinycc/blob/mob/il-opcodes.h
Edit 2:
I think I've resolved this: Fabrice Bellard already agreed to relicense under a permissive license, see: https://github.com/mirror/tinycc/blob/mob/RELICENSING
Thus, I think it would be really hard to argue that there's any problem left, since the only file here that could be in violation (il-opcodes) is authored by fabrice bellard and arguably already permissively licensed.
Case closed.
Says:
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
The COPYING file contains this:
* GNU LESSER GENERAL PUBLIC LICENSE
* Version 2.1, February 1999
* [This is the first released version of the Lesser GPL. It also counts
* as the successor of the GNU Library Public License, version 2, hence
* the version number 2.1.]
Edit: Fabrice Bellard is also the author of libtcc, who has chosen to release that project under LGPL, so this is irrelevant to begin with. The file is LGPL.
Also, "any later version" is any later version of the same license. LGPL and GPL are two separate licenses- you can't switch GPL to LGPL using this clause.
I assume that it used to stand for "library", and this was changed to discourage people from thinking of this library as the default license for libraries, and consider using the GPL instead. For example, the GNU Readline library is GPL, and this is reportedly the reason why CLISP is also GPL'd.
> [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.]
There's a bit of a myth that if you release a program containing GPLed code then you irrevocably get the obligation to release your source code whether you want to or not. Certainly you're in violation of the terms if you don't, but releasing your source code is not the only way to correct the violation. Even if you were successfully taken to court over the matter (which can only be done by the copyright owner of the GPLed software, since it's a contract with them that you're breaching), the court might require another resolution e.g. that you remove the GPLed code from your software or pay the copyright owner a fee/fine.
https://github.com/cheat-engine/cheat-engine/blob/master/Che...
Either way, it is hard to blame the author of Cheat Engine for this. If there is any violation it comes from a vendored dependency. Again, IANAL, but if someone presents you code and claims it is licensed under X, but then you find out they don't have the rights to license that code under X, it is hard to find you at fault.
Edit: The GPL file in question is authored by the same author of libtcc (Fabrice Bellard) who has released libtcc in its entirety under LGPL. No violation has occurred anywhere in the stack, the header is simply incorrect.
No. Both the GPL and the LGPL encourage you to add the “or any later version” clause that allows the FSF to retroactively add other licensing options to your code, but they do not include that clause themselves. The standard example is that the SMB protocol implementations in the Linux kernel (GPL 2.0 only) and the Samba project (GPL 3.0 or later) cannot share code in either direction.
> LGPL states that it counts as GPL 2.1
Also no. The GNU Lesser General Public License (LGPL) 2.1 (says that it) counts as the successor of the GNU Library General Public License (LGPL) 2.0, not of the ordinary GNU General Public License (GPL) 2.0. GPL 2+ code cannot be treated as LGPL 2.1, and from the FSF’s perspective allowing that would not make sense, as GPL 2 enforces strictly more copyleft than LGPL 2.1.
Why the confusing renaming? As far as I can see, Stallman wanted library authors to switch from LGPL to GPL, so that library users are forced into the GPL as well. The chosen solution was to play language games to redefine the “L” in “LGPL” to mean “lesser” instead of “library”. There is an official article that explicitly points out this piece of manipulation[1], but I still cannot suppress the vague feeling of revulsion at being manipulated.
No. GPL encourages people to say "GPLv2 or later" or "GPLv3 or later", but being under one version of the GPL does not automatically afford "or later" unless the copyright holder says so.
Anyway, all it does is convert from texinfo to pod formats, so that should be easily doable by some other tool or by the author themselves, if that is the only remaining violation, might as well address that.
First of all: IANAL.
Yes, and the perl script will remain GPL, but that doesn't make the rest of the program a derived work. That even seems to be the position of the FSF:
> The Free Software Foundation [...] asserts that an executable that uses a dynamically linked library is indeed a derived work. This does not, however, apply to separate programs communicating with one another.
Perl (and the script) is a separate program, the entirety of CheatEngine is not automatically a derived work of the perl script. Thus the script can remain GPL and CE could be licensed any way it wants without a problem.
Wikipedia has a section dedicated to this: https://en.wikipedia.org/wiki/GNU_General_Public_License#Lin...
Which if you think about it is really a very problematic assertion, for a couple of reasons.
First, it doesn't seem to be related at all the the definition of "derived work" in the Copyright Act (in the US) or the examples given for other kinds of derived works, which all involve incorporating creative elements from the original work into the derived work. These elements might be translated or rearranged or otherwise transformed, but they're still necessary for the work to count as derivative. Linking against a dynamic library has more in common with referencing another work in your bibliography—which so far as I am aware has never been considered enough on its own to consider the referencing document a derivative work.
But more importantly: The FSF also maintains that a clean-room, from-scratch open-source reimplementation of a proprietary library with a compatible ABI is not a derived work of the proprietary library. (For example Lesstif vs. Motif, or Wine vs. Windows.) A program which is dynamically linked against some library is only dependent on the library's ABI, not the specific implementation of the library, and can be used at runtime with either version. So is it a "derivative work" of the original proprietary library, or the open-source reimplementation? And of course the same logic could be applied the other way around for a program which can be (but need not be) dynamically linked against a GPL library—it could just as easily be linked against a proprietary reimplementation of the same library with a compatible ABI. And why should it make any difference for the purpose of declaring something a "derivative work" whether the reimplementation under a compatible license already exists, or merely could exist? The part which is asserted to be "derivative" hasn't changed at all.
I am not (a / your) lawyer, yada yada, but the "dynamic linking implies derivative work" argument has always struck me as being at odds with both the plain meaning of "derivative work" and actual practice when the situation is reversed.
The only actually GPL-licensed file in that list, obsolete_ntifs.h, doesn't exist in the repo. If you can find a version of CheatEngine that includes that file, presumably that would be a GPL violation, but that would have to rely on an analysis of how integrated the DBKKernel component is with the rest of the CheatEngine system.
I'm team free software and GPL code makes it more likely that people will GPL their code, but this sort of mobbing/bullying shouldn't be the way to do it. Let people make the decision because it is technically superior to do so, and sure ask people but bullying like this seems counter-productive.
As an aside for the tcc bits, they're right, tcc is lgpl, but it is odd that parts of it are stamped GPL proper, so I'm not sure what the protocol is there...is that an improper inclusion of GPL'ed code into a LGPL project? That would be tcc's fault then...
@Maniues: Please explicitly list all files in this project that violate GPL, or I will close this issue by (Some reasonable date.)
Then, by that date, I'd double-check that none of the code violates the GPL.
Why: I suspect that Maniues has a poor understanding of the semantics needed to determine if the project actually violated the GPL. It's quite common for people to raise a ruckus on something that they don't understand.
Upon closing the issue, I'd state, "I checked all of our dependencies, including XXX. Nothing violates the GPL." If there's LGPL or similar, I'd say something like, "We use XXX, which is LGPL, not GPL, and we are in compliance with the license."
Then I would close the issue. Issues like this shouldn't be left unresolved.
https://github.com/cheat-engine/cheat-engine/issues/60#issue...
Importantly, the new code in the infringing product is still copyrighted, and that copyright is owned by the person who wrote that code even though they also violated the GPL license of other code.
Edit: Good point about the SFC/Vizio case. I would be surprised if the SFC wins, but it's a clever argument. It would be a major earthquake for the free software world, but maybe not an earthquake in their favor. No one is going to touch GPL code with a ten foot pole if it gives the entire public standing to sue you.
[a]: According to a comment on issue #60[0], this would be any of: the FSF, Fabrice Bellard, Timppa, Martin Waldenburg, Jean-Franois Goulet, or Bo Brantén
[0]: https://github.com/cheat-engine/cheat-engine/issues/60#issue...
I thought the "one GPL file touched these other files and made them all GPL too!" vibe coming off the thread felt a bit weird! But I'd read something about the GPL being a viral license somewhere so wasn't quite twigging that no that's not what that means. Thanks.
I've incidentally been looking for a good dense steak to chew through on software licensing that's maybe dense but leaves me with a properly calibrated mental model that lets me answer simple non-normative questions without pining for counsel :). Something with good signal-to-noise ratio that eschews circumstantial drama to focus on theory and how things (have) play(ed) out in practice in nuanced and unintuitive situations. I wonder if something like this even exists...?
Microsoft FUD morphed that into "if you use GPL code, all other code you write automatically becomes GPL (and you lose copyright)", which is wrong.
To really get the issues discussed in this sub-thread and at issue in the SFC/Vizio case, you would want to know about contract remedies, privity of contract, third party beneficiaries, license agreements as a special species of contract, standing, and maybe some other areas too. But I think software engineers are actually well suited to understanding law, especially if they also have an innate interest in political/moral philosophical questions.
Then just... actually follow the license? The only way for it to be a problem is if you're using GPL code and not releasing it under the GPL; the only change is who can try and force you to actually follow the license, not the actual exposure.
(IANAL, but to the best of my amateur knowledge this isn't particularly complex or controversial)
That's not clear.
> All it does is give the copyright holder of the GPL'd code a legal claim against the developer of the derivative product.
That's a hotly debated topic, because of the “intended third-party beneficiary” doctrine in contract law, which clearly gives people other than parties a right to sue (why it is debated is because it is debated how the doctrine applies to the GPL specifically, and it may differ among different particular cases where the license is used, since it isn't just a question of the bare contract language.)
Even if it's true, it just seems to be mislabelled headers and code in tcc and that have been cleaned up in next versions of tcc so just updating the dependency resolve the problem.
If the GPL requires you to release source code, but the reason for your success is that you've found a clever way to do something that no one has thought of yet, doesn't that really put a damper on what people will try doing - because the invention is no longer yours and must be shared?
Although Stallman argues otherwise, the nature of the GPL is really incompatible with how business is done in the real world.
And how about The Qt Company or MySQL / MariaDB?
Red Hat, Qt, and the rest give the core stuff they build away but make people pay for more complicated services and support. For them, that's reasonable and it works.
Now, if you're Goldman Sachs and somebody gets a hold of the code that runs your trading platform (which surely includes some open-source components) and tries to use it as the basis of their work at another company, that's a problem.
They're not in the business of selling software and paid people to develop something that supports the parts of the business that people can actually see. Allowing anyone to use that code simply based on policy gets problematic real fast.[1]
[1]: https://en.wikipedia.org/wiki/Sergey_Aleynikov
Just because some parts are open shouldn't mean everything must be and you can use it without repercussions. IANAL, but this is the basic reason why copyright exists, to make sure people can get paid for their work.
These companies can't use GPL code if they don't want to share those. If the reason they don't want to share is because they feel it would get in their way of making money, they can find someone to take some of that money in exchange for producing code that they can use that does the same as the GPL library.
For single copyright owner software, this might be the same code from the same owner, just under a commercial license. For free software you might have to implement your own clone. That's the prospective user and the software author being unable to agree on a price (the author wanting the release of the derivative source code), not any fatal flaw with free software.
The answer seems to be "no". You can't build a software development company around a GPL code base. You can build a support services company around that (like RedHat or MySQL did), but that's it. You can build a service company that uses software internally, like Google and Facebook and AWS etc.
But the idea that you can build and sell a piece of GPL software is a fantasy of Stallman's and no more than that. Free software has even helped encourage the software-as-a-service world, where no one owns even a copy of a propietary piece of software...
In a world without copyleft, I don't think many of the ecosystems we have today would exist. The alternatives are that this software doesn't exist (because there's no economic incentive to build a business to sell it), or it's permissively licensed and some random other builds a business off it and with the extra resources outcompetes the original.
I'd take a world with some free software over none, and I don't see any way to loosen the restrictions to make it more easily broadly commercially viable without causing its own extinction.
Parent mentions Goldman Sachs; their trading platform is not something they want to sell, nor want to give away. Their build system, their UI component library, their numeric libraries, etc, could all be things they don't feel give them a material advantage over their competitors, and so it makes sense to open source ('many eyes make any bug shallow' style of thing).
These libraries don't need to be copyleft. If someone else wants to extend them and turn them into their secret sauce, who cares? They lose the benefit of it being open source (those many eyes), but if keeping their modifications closed enables a business model that people want to pay them for, they're generating value. And that's something that copyleft -wouldn't- allow, but a permissive open source license (such as MIT) would.
Red Hat is a rare outlier.
The vast majority of business related software is not GPL, and cannot be.
The thing notable about every company I've seen relying on GPL code is that what they sell are services/support. People pay Red Hat to be able to email someone when they have a problem. That's it. That's the business mode. Same with MariaDB (MySQL is a little unique in that it was purchased by Oracle, and I can't speak to Qt having no familiarity with it).
That works for B2B positioning, since the cost of support staff scales well when each new customer is worth thousands of dollars in revenue...and doesn't work well for B2C where the cost of support staff won't scale well when each new customer is worth a few bucks.
Release the source code in the most user-hostile, obfuscated, undocumented format possible while technically in legal compliance!
A business can't just grab a bunch of free GPL software, modify it, and then sell it with a whole bunch of restrictions about what the user may or may not do with their product. The GPL ensures the user has the right to examine, alter, fork, or manipulate the product.
If that hurts a business because they need to restrict how their customers are allowed to utilize their product, they shouldn't be using GPL code to make their product.
Only if you distribute a binary. You can freely build GPL code into a proprietary network service. Plugging this loophole is the whole reason why AGPL exists. You can also freely incorporate GPL code into private internal tooling since a corporation is a single legal entity and no distribution happens among employees.
using GPL code REQUIRES COMPLIANCE, that is the only way to ensure the four freedoms. if you are not okay with that, like famously google is, they simply ban AGPL/GPL software from their organization and everyone is fine with that also.
GPL actually restricts certain freedoms to preserve others. The "actually free" (public domain) licenses allow you to do things Stallman considers harmful, which he defines as a violation of user freedoms. In other words, his licenses remove the freedom to remove freedoms.
i know what the "freedom" that GPL restricts. it is about using GPL code in proprietary software. thats all.
look at it from GPL POV. i am contributing to a GPL software which is free software (beer and speech), a person comes along and uses the freedom i gave in my license and uses that code in a proprietary software. now, the intermediate dev is free to use the code but their end users now suddenly find that they are using my code and yet the intermediate dev put proprietary license, thereby restricting their freedom.
i have a small question to ask for all gpl naysayers, why do you care about this intermediate dev's freedom and not about the freedom of the end users?
look at it this way. Apple took bsd kernel whatnot and made it into proprietary code. the license gives them the right to do that but what about end users. now they are forced to use proprietary code. Had apple used GPL code, they would have been forced to give source code to their customers and we would not be reverse engineering asahi linux like we are doing it now. it would have been as easy as linux is right now.
Sure I'd prefer that people release their changes, but am I their dad? Am I their priest?
People are free to do things I consider unethical; it is not my place to stop them. If I seriously consider the alternative, then I would be forced to commit to the idea of software-licensing as ethics activism: for example I might add a veganism clause to my license to prevent my software from being used by people who contribute to the horrors of factory farming.
To be clear, I'm not at all opposed to the spirit of the GPL! As mentioned above, I very much like it when people behave in the ways the FSF recommends. I'm just opposed to legally mandating such behavior, so I wouldn't personally do that.
If you are in this situation, you do not have free software.
The difference between free software and open source is the perspective. Open source comes from the perspective of the vendor. Free software comes from the perspective of the user.
Free software is about freedom for the user, everything else builds upon this first principle. It is possible that the licenses have defects. The license is an artifact. The four essential freedoms are the business requirements on which the licenses are built in top of:
The freedom to run the program as you wish, for any purpose (freedom 0).
The freedom to study how the program works, and change it so it does your computing as you wish (freedom 1). Access to the source code is a precondition for this.
The freedom to redistribute copies so you can help others (freedom 2).
The freedom to distribute copies of your modified versions to others (freedom 3). By doing this you can give the whole community a chance to benefit from your changes. Access to the source code is a precondition for this.
For some things, people eventually realize their advantage over keeping the rights is outweighed by making whatever you've done widely available.
The PDF format is another great example and we've seen a number of apps come up to supplement the core tech or implement features that Adobe doesn't care about but someone finds useful.
This is good old fashioned Orwellian language control. Many things are genuinely free software that do not fit the FSF's "definition."
They are not an authority on the language or all software.
Much of my software costs $0. That makes it free. I do not follow the FSF's demands. It is still free software, even though you found a link with a bullet list that says things.
None of these "essential freedoms" actually are essential to anyone but FSF people.
Using a most descriptive language sidesteps the English conflation of free and free.
North Korea is a very free country. Everything is gratuit, but it's not a free country at all, no libre
If the FSF changed their definition to something that made absolutely no sense, then sure, the software community would rightly reject it. Until then, it's useful to have a clear definition for a term-of-art.
> Much of my software costs $0. That makes it free.
A car is heavy. A car is a machine. A car is not heavy machinery.
If you wish to refer to software that is made available at no charge but is not Free Software, you can use the term freeware.
Yes, the terminology is quite annoying on account of the two meanings of free, but we're stuck with it. This happens in many different fields.
> I do not follow the FSF's demands. It is still free software, even though you found a link with a bullet list that says things.
It is unhelpful to deliberately make non-standard (i.e. incorrect) use of accepted terms. It isn't about demands and agendas, it's about clear communication. To copy from an old comment of mine: [0]
In aviation, flap is a precise term-of-art, and is never used interchangeably with aileron, despite that an aileron is plainly a kind of flap (in the colloquial sense). If you adopt your own definition of flap, to refer to both flaps and ailerons, no-one is going to sue you, but no-one is going to know what you're talking about. Your use of the term will be considered not merely different, but wrong.
On the other hand, you could try telling a physicist that you consider the words power and force to be interchangeable. They're not going to sue you, but they're also not likely to entertain your deliberate misuse of standard terms.
On the third hand, you could try insisting to a soldier that machine gun refers to all automatic weapons, rather than to a specific subcategory. They will inform you that they are aware of this colloquial use of the term, and that their more precise use of the term remains a standard, and reasonably clear, term-of-art.
In no instance is there any question of Orwellian control.
See also similar discussion of the term Open Source [1].
No.
The FSF does not have "their definition" of common words and phrases that predate them by decades.
This just doesn't belong to them. Period, full stop.
.
> A car is heavy. A car is a machine. A car is not heavy machinery.
That's nice.
This phrase meant what it said on its face for 30 years before Stallman showed up with an editor he stole and an operating system he stole.
He's not stealing the phrase, even though you can show compound terms that break down to unrelated simple sentences.
.
> It is unhelpful to deliberately make non-standard (i.e. incorrect) use of accepted terms.
Yep. And that's what the FSF did.
The term predates them by almost 40 years, and is mostly used by other people in ways that are incompatible with them.
As an issue of fact, GPL/LGPL/AGPL use by project count is now below 10% of free software licenses, and as an issue of fact, the other free software licenses that the FSF has decried "not truly free" continue to ignore them and chuckle.
And I see you, from the radical minority, insisting that your viewpoint is the standard, and accepted.
Not really, is the thing. There's evidence, and it does not support you.
.
> In aviation,
These constant attempts to point to other things and insist their structure informs this discussion, while placing a mistake in someone else's mouth and and then correcting it, are pointless and tedious.
.
> On the other hand, you could try telling a physicist
These constant attempts to point to other things and insist their structure informs this discussion, while placing a mistake in someone else's mouth and and then correcting it, are pointless and tedious.
.
> On the third hand,
That's pronounced "gripping."
.
> you could try insisting to a soldier
These constant attempts to point to other things and insist their structure informs this discussion, while placing a mistake in someone else's mouth and and then correcting it, are pointless and tedious.
.
> In no instance is there any question of Orwellian control.
I'm sorry that you failed to understand my meaning.
.
> See also similar discussion of the term Open Source
I am not interested in an HN attempt to redefine terms either.
It's really weird that you say "It's not Orwell, now watch me define the term against you"
I'm not sure I think you've actually read the book
Have a day
At that point, you're back to traditional copyright and other less restrictive schemes.
> He claims that it protects users, but this leaves out the people who spend the time and effort to develop that software product.
Some things really aren't all positives for everyone. The free software movement prioritises users first. Sometimes this is a negative for the developer's goals. But clearly by the existence of a large amount of free software, there are enough developer's sympathetic to this goal to make it work, and by eliminating those restrictions, I don't see how that's preferable (or even different) to the all rights reserved world.
It doesn't put a damper on societal progress because you benefit from the existence of GPL software so it is only fair to let others benefit.
Dont use GPL licensing if you want to turn a trade secret into profit.
What you're saying is simply a part of the big question of "intellectual property," though I think perhaps one thing we forget is that the protection is the ARTIFICIAL part; IP is the thing we made up out of nowhere.
Probably one of the reasons I find the GPL to be so brilliant and clever -- one could whinge about the problems with overbearing copyright, or one can use some clever judo and just roll with it.
It was the only way to make the business work, as work for hire would be owned by the customer, and we didn't have the money to waste arguing with massive corporations.
It's like anything else tools + labor = work product.
Isnt that the point? Your contribution is freely accessible to the community. If your work gets used, then you contributed
If you want to get paid for your work, set up a contract beforehand. Get paid to work on GPL code upfront - dont try to get paid for how it is used after. How it is used is heavily effected by not needing to pay for it in the first place.
Otherwise you are like the guy at the gas station who randomly cleans your windshield and then asks for a tip. Like yes, my windshield was dirty and you deserve to be paid for your work, but no one asked
"get paid" for open source work typically means become a contractor, paid per hour. that doesn't scale, I'm interested in getting paid repeatedly without any additional effort on my part, rather than getting paid per hour.
it would be interesting if there was a model where a contribution would cost $0.001 to use in a product. if I am a small business selling a product with that contribution in it, and I sell 1,000 products, I pay $1. if I am a FAANG and sell 20 million products, I pay 20K. that sounds like a much more fair situation. perhaps blockchain can enable this. now let's say I am a regular contributor and FAANGs use my software. I can now make let's say ~100K per year from my few contributors from FAANGs without any additional work. that would be pretty awesome.
Compete with you on what? using the public goods you created? I still think that is the point. If they can utilize the public good more efficiently and offer its service to users at a more competitive price point than your small shop - that benefits the user.
>I'm interested in getting paid repeatedly without any additional effort on my part, rather than getting paid per hour.
A plumber doesn't get paid every time water runs through the pipe. Coming up with clever solutions to the operational problem is part of the $/hr of doing work.
I guess what it comes down it is are we talking about literal code, or are we talking about something higher level that you want some level of ownership of?
When it comes to code, the logic of the code itself is not where the value is. the reason multiple payments are made for the same set of logic / code is because the value is in the time and place of execution. Owning the overall system the code lives in is all that matters for value. Code itself has literally no value on its own. The value is in the execution.
The thing people pay for is to have others execute code for them. development is part of that.
you still bring up an interesting payment model idea though. I'm not sure how it could work, but there might be a feasible way to have multiple developers work under the same umbrella, with all code being proprietary and owned by that umbrella, and instead of paying them a flat wage they each work as contractors who get paid whenever code they developed gets executed. The umbrella could service FAANG as customers through typical SaaS API model so FAANG never sees the code and the developers themselves get paid on execution instead of FAANG management
Basically what you describe, but as a closed ecosystem - not sure how feasible it would be to insulate it from the general ecosystem though.
It's a nice software, but the people behind it are shady
> Legal action is a last resort. Compliance actions are primarily education and assistance processes to aid those who are not following the license. Most GPL violations occur by mistake, without ill will. Copyleft enforcement should assist these distributors to become helpful participants in the free software projects on which they rely. Occasionally, violations are intentional or the result of severe negligence, and there is no duty to be empathetic in those cases. Even then, a lawsuit is a last resort; mutually agreed terms that fix (or at least cease) further distribution and address damage already done are much better than a battle in court.
TLDR: Legal action is a last resort. Most GPL violations occur by mistake, without ill will.
Here is a list of the supposed violations, as per this comment [1]:
./Cheat Engine/tcclib/texi2pod.pl copyright Free Software Foundation via GNU GPL v2+
./Cheat Engine/tcclib/il-opcodes.h copyright Fabrice Bellard via GNU GPL v2+
./Cheat Engine/tcclib/tcctools.c copyright Timppa via GNU GPL v2+
./Cheat Engine/tcclib/lib/libtcc1.c copyright Free Software Foundation via GNU GPL v2+
./Cheat Engine/bin/tcclib/libtcc1.c copyright Free Software Foundation and Fabrice Bellard via GNU GPL v2+
./Cheat Engine/SynHighlighterAA.pas copyright Martin Waldenburg via GNU GPL v2+ (and MPL)
./Cheat Engine/LuaSyntax.pas copyright Jean-Franois Goulet via GNU GPL v2+ (and MPL)
./DBKKernel/obsolete_ntifs.h copyright Bo Brant via GNU GPL v2+
* il-opcodes.h [3] is included in libtcc, but has a GPL license in the header. As the GPL license author is the author of libtcc (Fabrice Bellard), this seems like a mistake in that single header and the general license of the project should take priority. An author of source code is allowed to relicense their own code to whichever license they wish, after all, even if the original license used to be the GPL.
* texi2pod.pl [4] is licensed under GPL, but as it is a single perl script it does not link to the main cheat-engine program, which means the GPL does not extend to the rest of the cheat-engine project.
* LuaSyntax.pas and SynHighlighterAA.pas [5] are dual licensed under MPL, so are not violations to begin with.
* The other linked file (obsolete_ntifs.h [6]) has since been deleted and was not in use to begin with (and hence never linked to the actual project).
Unless I am missing something, none of these allegations seem to hold any water. It mainly seems to boil down to the author of libtcc making a sloppy license mistake in a header (likely copy-pasting licenses around incorrectly).
[1] https://github.com/cheat-engine/cheat-engine/issues/60#issue...
[3] https://github.com/cheat-engine/cheat-engine/blob/master/Che...
[4] https://github.com/cheat-engine/cheat-engine/blob/8bdb7f28a9...
[5] https://github.com/cheat-engine/cheat-engine/blob/5d595d7fce...
[6] https://github.com/cheat-engine/cheat-engine/blob/e38c7997c9...
You can easily generate the il-opcodes.h based on the constant names that were used.
CONV_OVF_I1_UN -> lower case -> conv_ovf_i1_un -> . -> convv.ovf.i1.un
Those opcode numbers are just an auto incremented number.
The author of Cheat Engine should just reverse engineer the file himself and push an update to libtcc to make it LGPL compliant.
I do find this side of things very interesting so I took at look at the thread.
But 2 things stick out to me in particular:
1. The person who opened this ticket... their tone is. Strong. Especially for someone that claims to not have a stake but is threatening to contact those that do? What is the point?
2. I took a look at the history for this person and they open a lot of these tickets. So again... I am curious what their point is? What is the end goal of just spending all this time looking at repos and getting into arguments over licensing.
Is it GPL? GPLv2? GPLv2+? LGPL? AGPL? The majority will enjoy their absolute freedom... to stay far, far away from all that noise...