I know the answer is probably no, but I'm confused about something. The underlying algorithm is never copyrightable. So as long as you "learn from the code" someone else has wrote, and re-implement it, you are allowed to reuse what you learned. But isn't this the same as making a few changes to the source code, i.e. reordering things, changing names etc.? So does this mean running source code through a code obfuscater would avoid copyright infringement issues? I know it's a strange question, but I'm serious.

I'm talking about small portions of code, less than 100 lines, not whole programs.

I ask this question after having read Does copyrighted code protect intellectual property rights on novel algorithms it implements? and Algorithm (pseudo)code in academic papers -- what is the copyright/license status?

  • Fewer than 100 lines does not preclude it from copyright. A whole program can be as few as 1 line. Are you reimplementing an algorithm or running code through a translator or obfuscator? The questions you linked to are about reimplementing, not obfuscating.
    – Brandin
    Nov 14, 2017 at 12:27
  • @Brandin my point is what's the difference between re-implementing it and running it through an obfuscator? If the requirement to not infringed on copyright is to make changes so that it's not a copy and paste, both achieve this result.
    – user14343
    Nov 14, 2017 at 12:53
  • If you take an algorithm and re-implement it as your own creative work without copying someone else's copyrighted work, that is not copying. If you take someone's copyrighted work and run it through an obfuscator, that is copying or perhaps a derivative work. If that is your question, clarify.
    – Brandin
    Nov 14, 2017 at 13:15
  • 1
    There is probably some gray area in the case of someone who reads a program's source code to learn how it works and then re-implements it. Whether the new implementation infringes the copyright in the original work would be a matter for a court to decide. But the obfuscator creates a work that is directly derived from the original; it's not at all analogous to learning an algorithm and then making a new implementation of it.
    – phoog
    Nov 14, 2017 at 20:18
  • @Brandin but the end result is the same. If you re-implement it, you still need to use the same algorithm, so what you're really changing are things like the variable names. And that's what an obfuscator does.
    – user14343
    Nov 14, 2017 at 23:25

3 Answers 3


No, it's still copyright infringement. When you modify a copyrighted work in any way, you generate a derivative work which you are not allowed to distribute without the permission of the original copyright holder.


So as long as you "learn from the code" someone else has wrote, and re-implement it, you are allowed to reuse what you learned. But isn't this the same as making a few changes to the source code, i.e. reordering things, changing names etc.?

Not, it is not the same. In practice, to make your re-implementation not infringing copyright, it needs to be written from scratch without copying the original code.

It might be indeed difficult to write an implementation of a fewer than 100-lines algorithm that would not look copied and re-shuffled original. But if you do it as if you have never seen the original but have been taught the algorithm only, you'll make it. A definitive way to make it is to explain the algorithm to somebody else who won't have access to the original, and ask them to code it.

So, to avoid doubt, running code through a code obfuscater will produce derivative work, which means copyright infringement issues cannot be avoided this way.


The copyright holder has the right to state who is allowed to copy, and who is allowed to modify their creation to create derived works. All the actions you talked about modify the original source code. Including the source code obfuscator, which is modification on a huge scale, but nevertheless just obfuscation and therefore not allowed without permission by the copyright holder.

What you are allowed to do, is write a program from scratch, not using anyone else's code, and implement someone else's idea.

Now in practice (that is if you are taken in court), a judge or jury has to decide whether your work is a derived work. You might think that a code obfuscator hides the evidence - but this would be in a civil court, and the court only has to decide what is more likely. With obfuscated code, it's obvious there must be some code that you obfuscated, so you will be asked to show that code. If you show the code, it will be found that it was derived, if you don't show the code the judge will assume that you are not showing it because you know it is derived.

And it is recommended that you find someone to write your code who has never seen the original code. Because then you can say in court "I swear I didn't modify the original, but more, I couldn't have modified it even if I wanted". It's not a matter what you are allowed to do, but how to prove you didn't do anything wrong.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .