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.

  • 6
    Are you concerned about the legal issues here (which are relatively straightforward) or the community/ethical ones (which are harder and may actually better be asked on something like Academia SE if this relates to a primarily academic project)? Commented Nov 20, 2023 at 10:22
  • it is a largely academic project. both of our organisations are universities. yes, i guess i am more interested in the community/ethical issue of the project naming, but since it is an open source project, i wanted to ask the question here first to get the POV of the OSS community, like what are the standard practices? I fear it might be too overly specific to OSS for the Academia SE. If you have a straightforward answer to the legal issue, you can submit an answer, together with your opinion of the community/ethical issue. Commented Nov 20, 2023 at 15:01
  • 2
    "Scrubbing the codebase of all mentions of their organization feels like I'm just stealing their code" Am I right to assume that you would keep all the attribution and copyright notices intact, which refer to ABCLabs? As long as you comply with the license terms, you are not stealing the code. Commented Nov 20, 2023 at 15:08
  • ok perhaps i made it sound very harsh. i only meant the package/classnames. i will leave a comment string in each file if it was originally written by them, especially so if it was an algorithm that they wrote a paper about (and a link to said paper). I will edit my question accordingly. Commented Nov 20, 2023 at 15:26
  • 6
    I wouldn't bother renaming individual classes/files, but make sure that the project as a whole is clearly distinct, e.g. "OpenPotatoSimulator (based on AbcLabsPotatoSimulator v1.2.3)". Keeping the file structure similar will simplify any merging in either direction (if that's desired). An example of this is the "Jenkins" CI software, which was forked from Oracle-controlled "Hudson", and still contains tons of components using a "hudson" namespace. Or "LibreOffice", which still contains lots of references to "OpenOffice" and the even older "Star Office"
    – amon
    Commented Nov 20, 2023 at 15:35

3 Answers 3


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.

  • 1
    the convention appears to be there is no convention, you've probably heard stories of researchers writing spaghetti code that accompanies their paper, since academia is their main focus, not maintainability of the software. the entrypoint of the program is literally AbcLabsPotatoSimulator.m. I am, also extensively changing (breaking) how options and parameters are passed to the simulator, so I will probably make my own entrypoint as well. Commented Nov 20, 2023 at 16:09
  • 1
    @chesnutcase you've probably heard stories of researchers writing spaghetti code that accompanies their paper, since academia is their main focus, not maintainability of the software Ah yes. I've had some run-ins with that recently. Spaghetti is too nice of an adjective at times. I thought that spaghetti on the ground in an alley after a long night of drinking is more apt sometimes. Commented Nov 22, 2023 at 1:29

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.

  • 6
    Academically speaking, plagiarism would probably be claiming sections of their work as my work; I don't intend to do that of course - it would be the end of my academic career before it even started. I'll definitely give attribution in the documentation of the code, even if I end up renaming my own organization name, such as the headline description of the project, e.g. "MyOrgPotatoSim - fork of ABCLabsPotatoSim with added support for other vegetables" Commented Nov 20, 2023 at 15:35
  • 3
    @chesnutcase I think this is an excellent first question, and welcome to the site. That said, I got a huge laugh out of the line above, and although the issue is a completely sane and genuine one, I found myself desperately wishing for the release of the new general-purpose vegetable simulator. I personally would like to simulate beetroot!
    – MadHatter
    Commented Nov 20, 2023 at 16:10

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


ABCPotatoSimulator {

  int leaves(seeds)
   return seeds * leaves * sunlight

  int sunlight()
    return 44 

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.

  • 1
    Sorry, is that MATLAB code? I'm not completely familiar with MATLAB, but the above doesn't seem all that reminiscent of it.
    – MadHatter
    Commented Nov 21, 2023 at 6:28
  • 1
    It does not matter if it's matlab or not, his insight about spending the effort into preserving my own simulator versus getting changes merged back upstream was useful :) Commented Nov 21, 2023 at 11:59
  • 1
    No, it's not anything. It's pseudo-code, not in any language. The problem is not language specific.
    – coteyr
    Commented Nov 21, 2023 at 15:02

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.