First, the answer is no (for a translation), you cannot legally relicense it or do anything outside of the original license legalities. You may very well have done 10 times the work of the original author, but it doesn’t matter, it is viral. Not just because it is GPL, but because it isn’t clean design or rewrite.

I struggled briefly with this in 1992 when I had done massive rewrite of an old MUD codebase. We had a successful game, but wanted to do our own thing, and people were willing to pay for it, yet the DikuMUD license strictly forbid us to make money. A competitor, at the time, also had based theirs on the same codebase, and they opted to blatantly ignore the copyright, rip out all traces of it, and basically lie to everyone including themselves. Their logic was “none of the original code exists” and “we have done massive rewrites and improvement” and generally ignoring the fact that they started with 20,000 lines of code. They were charging for items in the game, and making too much money to stop.

I was admittedly envious. But I researched copyright law, and consulted my conscience, and decided I could not even use the code I had written because I honestly did not architect the game server from scratch.

So I decided to put my money where my mouth was and write from scratch, with a copy of W. Richard Steven’s UNIX Network Programming with me at all times, I started. Writing from scratch, my way, taught me so much more than when I had rewritten DikuMUD, and it also taught me that I didn’t really understand what it meant to stand on someone else’s shoulders. Within six months I had 50,000 lines of operational code that I could call mine. I named it MUD++ and released it under BSD. Badly written in early style C++, it was still the first free, open source C++ MUD that I am aware of. To this day nobody can take it away from me. I had the best TCP server at the time, nobody else could do a “hot reboot” without dropping players, and soon everyone was stealing the feature (and I’ve noted many GPL MUDs have snippets of my BSD code — always interesting how GPL can hijack BSD-ware but not vice-versa). Eventually, I moved on, so it wasn’t like the decision was a make or break for my fortune, but while the other guys made a lot of money for a while, last I looked they had dwindled, in a world of graphical games there isn’t much mass demand for text anymore.

The story doesn’t end… a few years later, I was working for IBM and Disney hired us to write a realtime 3D multiplayer game for Epcot center, and I was able to use the TCP core from MUD++ as a base for that game server! Had I not owned my own code, I wouldn’t have been allowed to use it, and it honestly saved me weeks of coding time. In the end, I am proud of the choices I made and I have a story to tell my kids.

People understate and underestimate the benefit of starting with someone else’s framework to build on.

If you think you “own” it, test yourself. Start over, with a Python book beside you. See how it feels. Don’t cheat and don’t look at the old codebase. Look at the output. Force yourself to think through every aspect on your own, doing the honest research. You’ll be better for it, and likely have a better product.

Before you do that, though, try to contact the original author. Ask them if they would be willing to relicense. If you plan to sell binaries, offer royalties. Many authors who released things GPL in the 90s and 2000s, are now in their 30s, 40s and 50s and understand what it means to make a living at software. I’ve seen more than one relicense their stuff from GPL to MIT, Apache, Boost or BSD.

Lastly, a license doesn’t override prior rights to code you may have. Or if you wrote a clean add-on independently, for example, if you wrote a TCP engine as an add-on to a single player Tetris game, and it can cleanly stand alone (especially if you previously released under another license) then you can reuse your code in other projects. You have authorship rights too.

My belief is free is FREE. If you gotta attach strings, don’t call it free. Someone mailed me years later and said that they had used my game in a commercial engine, mainly the TCP and possibly the bytecode interpreter. They were making money. I didn’t mind one bit. I was happy as I still am now, as a proud father.

This scenario is covered in the GPL FAQ:

What does the GPL say about translating some code to a different programming language?

Under copyright law, translation of a work is considered a kind of modification. Therefore, what the GPL says about modified versions applies also to translated versions.

It is doubtful, even if you rewrote the entire library from scratch, that it would pass legal scrutiny. The code would be considered “tainted” because you have seen the code in the GPL licensed library.

The standard approach to this problem is called “clean room implementation”. You write a requirements document and have someone else implement it (who hasn’t seen the GPL code).

Also see this question: Rewriting GPL code to change license

As someone aptly put it there, a Chinese translation of Harry Potter is still a derivative work, even though all the information has been replaced.

Of course, the probability of you getting sued over rewriting a GPL licensed library (and the morality of relying on that low probability) are entirely different discussions.

As far as adding functionality to the original code, this is (part of) the very definition of derivative works: adding to the original work. It doesn’t matter how much you added, or how small the initial work was – it’s still derivative.

Observation: The GPL is only relevant if you release your work. Have you released it yet?

Observation: This is not a legal-counsel website, so throw out all that legal FUD, and apply common sense.

Opinion: The GPL, or any license, does not copyright ideas, it claims the sourcecode, not matter how small its part. So, if, and only if your “derivative” work cannot be identified as being derived from the original, because you changed the structure of the code and reimplemented all functionality, it is for all practical purposes no longer derivative, because, well it would be indistiguishable from a clean room implementation.

This is very hard (impossible?) to acheive though when you have an existing codebase you modify, instead of starting from scratch.

You own the copyright for any code you write. What the GPL mandates is: any code you contribute or release alongside GPL code, you must also release under a similar license. However, the copyright is still yours.

So, if you release your software part-way through the re-write (so there’s a mixture of your code and old code), then you have to release that part of your code as GPL, and this cannot be revoked. However, the copyright holder is the one who decides on licensing terms, so you still have the right to essentially “dual-license” that part of the code, including combining it with other code you alone wrote and selling/relicensing, etc.

Caveats:

• although the copyright on code you write is yours by default, it can be changed by another contract/agreement, e.g. a CLA that specifies copyright transfer, or a contract with an employer who owns all the work you do on “their time”.
• whether your re-write constitutes enough of a “derivative work” that you end up sharing the copyright with the original author is a matter of degree. If you translate the code line-by-line into another language (as your question mentioned), then those parts might well count as derivative. If you implement an API-compatible replacement without looking at the details, then that probably wouldn’t.

(source: a “copyright and open-source” session organised by my company a few weeks ago)

Yes.

The other answers use far too much text explaining opinions on whether you should or not, but those opinions are not that relevant to the question.

The fact is that you will have a new work once you replaced the last parts, which admittedly was constructed by looking at a GPL’ed work. That’s not a major concern in copyright law (patents would be another issue). Everything you distribute will be your creation.

There is plenty of material backing the theory that the copyright in a software program is the sum of partial copyrights. For instance, the MPL explicitly acknowledges this model. The Google/Oracle lawsuit got down to line-level copyrights.

The short answer is that you cannot know.

When you talk with Richard, you find he is “crazy like a fox” in many of his implementations. The GPL is written specifically to have ambiguities and unclear phrasings. These are generally expressed against the benefit of the license writer but also give your IP lawyer concerns. Cleverly, it gives your IP lawyer increasing concerns as the company gets bigger. A small commercial enterprise doing the “reasonable interpretation” of the GPL might be an acceptable risk, but a large software company might find it more prudent to burn an entire team that managed to get a taint of GPL.

There is no answer. There will not be an answer. That is the answer.