Maintaining a parallel fork of a project that contains the original authors' company name

Question

I have been working on my own changes to a complicated academic/scientific project whose name contains their organization (university) name that I am not part of, for example, if their organization name was ABCLabs, the project name is ABCLabsPotatoSimualator. This is not just used as the Github repository name, but also the name of the source files, namespaces, etc in the source code.

After some initial collaboration, the original authors do not seem very receptive of merging my changes (active development is sparse and they often don't publish their working branch until they have published academic papers about it).

Myself / my colleagues need significant changes made to the codebase for our own research, so I have forked it, but I am conflicted about the program name. Sure the code is open source, but I technically do not have the rights to their organization name ABCLabs. Scrubbing the class names / package namespaces of all mentions of their organization feels like I'm just stealing their code - but at the same time, it is going through a significant refactor that will not be backward compatible with their version. The classes/interfaces are going to be significantly changed, but several of the internal underlying algorithms will still remain untouched, as written by them.

What are my options regarding naming the new repository and dealing with classnames that contain their organization name?

1. Append my organization name in the repository name (e.g. ABCLabsPotatoSimulator-MyOrgFork, but leave the classnames intact. Again, I am worried that I do not have the rights to use the name ABCLabs in both accompanying documentation and the names of the source code classes/executables.
2. Replace all instances of their organization name in both the repository name and the classnames in the source code with my own organization name. MyOrgPotatoSimulator.
3. Remove all organization names in both the repository and the source code. However, I am worried just PotatoSimulator is extremely ambiguous, because there might be other potato simulators written in other languages etc (I cannot use the name of the programming language, because it is written in MATLAB, and MATLAB is trademarked by MathWorks)

The code is GPL licensed.

Edit: regardless, I will leave comment blocks attributing the original authors of the files/classes that I left intact, or sections of code that is largely left intact.

Answer 1

From a legal point of view, the GPL license allows you to rename everything in sight, except for mentions in the copyright lines.

In practice, a complete renaming of all files and classes is rarely to never done, primarily because it is a lot of work with no (or even negative) added value. Keeping the original names makes it easier to provide your changes to the upstream developers (ABC Labs in your case), or to integrate subsequent changes from upstream in your fork.

My advise would be:

• Name your repository as you like
• Name new files/classes as you like
• When you change existing code in a manner that it is still recognizably derived from the class of ABC Labs, keep the original name. Especially if the change is backwards-compatible.
• When you change code in a more extensive manner, or in a non-backwards compatible manner, consider changing the name to clearly indicate that it will not work together with code that expects the original version.

Within OSS projects, it is not common to include organization names within file or class names, they appear at most in the package names (for example in Java packages). I am not sure what the convention is in academic settings.

Answer 2

In copyright terms, you must obey the GPL - leave intact all copyright notices, and provide a copy of the source etc to anyone you distribute the binaries to. If you do that, you can remove all mentions of the original source from the code, the documentation and everywhere else and be legally in the clear. This would generally be considered bad form in the FLOSS community but everybody acknowledges that it is legal, and something that we allow to happen when we publish our code under a FLOSS license.

In academic terms, you would almost certainly be commiting plagirism if you did this. That's not something anyone here can really advise on.

Answer 3

This is going to depend on how much effort you want to do. But a solution I have used in the past is to include "their" classes and then overload where I needed to.

GenericSimulator extends ABCPotatoSimulator {

  int leaves(seeds)
    return seeds * 4 * sunlight / 2
  end

end

ABCPotatoSimulator {

  int leaves(seeds)
   return seeds * leaves * sunlight
  end 

  int sunlight()
    return 44 
  end
end

There's no reason this can't work if you're trying to maintain everything. Then you're taking over the responsibility for preserving GenericSimulator, but not messing with ABCPotatoSimulator. Contributing to ABCPotatoSimulator becomes more challenging, but they sound like they don't want that anyway. And! There's nothing stopping you from contributing to ABCPotatoSimulator when working on potatoes.