Help me choose a license - Lemmy.World
So, I’m writing a piece of software (in Go). Specifically, a DSL for making 3D
models. (Roughly speaking, what I’m going for is that what I’m building is to
Blender as OpenSCAD is to FreeCAD. You write code in a language I’m designing
and it uses that code to build and spit out, for instance, 3d game assets with
textures, normal maps, rigging, animations, etc.) I intend to publish it under a
FOSS license once it reaches roughly an “alpha” stage. (Once it’s actually
usable to create generate meshes and export them as files of a couple of
different popular 3d file formats.) I intend at some point to support both
interpreting and transpilation of my DSL into Go. As in, you can write code and
execute it with something like modelgen run program.mg, or you can transpile it
into Go and run it with modelgen transpile program.mg program.go ; go run
program.go. (Yes, I get this is pretty ridiculously ambitious, but at least it’s
good to have a star to set my bearing to.) One potential feature of the
transpilation approach is that a game developer could write some code in my DSL
for generating models on the fly, transpile it to Go, and then build that Go
code directly into the binary of a game they write in Go for purposes of
generating models on the fly at runtime. (Based on, say, a list of parameters
that the game provides at runtime. “The biome here is cold, so let’s generate
some humanoid figures with lighter skin to soak up limited light and stockier,
stubbier purportions who might appear better able to conserve their body heat.
And maybe we generate some wolves with really thick fur that blends into the
snowy environment well. Oh, but the biome over there is a hot desert, so let’s
have some humanoid figures with darker skin to better handle harmful solar
radiation.”) Making that work properly would also involve building somewhere
between “a lot of” and “all of” of my DSL’s standard library into their
application. As to the license, first off, I think copyleft is a fucking awesome
idea and I want to leverage it to make sure that my DSL is never used to
subjugate users or developers, and to promote a cooperative means of
development. Given that I have such warm fuzzies for copyleft, my main
contenders are: AGPLv3, GPLv3, and LGPLv3. I’ve heard Stallman talks in which he
indicated that the reason the LGPL was developed in the first place was
“strategic”, which leads me to believe that less stringent copyleft provisions
in service to greater adoption can indeed ultimately serve the cause of
increasing users’ freedom. (Stallman isn’t exactly the most “practical” and
“flexible” sort of guy in a lot of regards, so for him to recognize this face
makes it seem important.) So I suppose one argument for using the LGPL is to
allow other developers to publish software using my project in a way that allows
them to keep their code proprietary, even if users who receive a copy of their
software still have the right to demand a copy of the source code of all
components of my DSL’s codebase (including any potential changes/improvements to
my DSL’s codebase) that might have been included. Does using the GPL or AGPL,
however, mean that if they either statically or dynamically link my code into
their program, their whole program becomes a derivative work covered by the
(A)GPL? And if so, is that a good thing or a bad thing? I definitely would love
to see a future in which some big/popular game includes a good portion of my
AGPL software in the server side of their MMO and players who connect to the
official servers are able to demand the source code of the entire server
codebase, enabling the game to be modified and improved, and enabling continued
playability even after the developer of the game has EOL’d it and shut down
official servers. Or if I use the GPL and a game company sells a game with a
bunch of my code in it, I’d love for users to discover they have the right to
the source code of the whole game and not just the part that is from what I
wrote. But honestly, I’m not sure if that’s quite how it works. I guess the main
argument to prefer AGPL over GPL is just that it afforts users more freedom and
more rights to assert their freedoms than the GPL does. But one major downside I
can see is that developers may well see that “A” on the front and completely
disregard using my code in their code as an option, making their software
entirely proprietary. Beyond that, I don’t want to see any future version of my
DSL become proprietary. If some day a very small number of people own the
copyright on my code and they conspired to change the license to something
proprietary (like, say, Redis did for a while), I think that’d be a bit of a
travesty. Which is why I intend for the copyright on contributions from others
to be owned by the contributors. A diverse mishmash of different copyright
owners for different tiny slivers of the codebase makes it somewhere between “a
lot harder” and “impossible” to change the license later. And that’s a feature,
not a bug. (See also “Ulysses pact
[https://en.wikipedia.org/wiki/Ulysses_pact]”.) And if I want to make it harder
to change the license in the future, that kindof implies that it behooves me to
choose the right license now before it’s difficult to change my mind later. So,
I’m hoping some folks here have had the same choice to make at some point in the
past, or at least have been involved in such decisions in the past, and might
have some insight that might help me choose what’s best. I do think probably
AGPL would best let me sleep at night, but something like LGPL might well in
practice much better preserve the freedoms of downstream users in a more
concrete way. I’m not sure! Thanks in advance for any input whatsoever!
