Publishing

What has to be true before a game built on Kerosene goes to other people: what the licences require, what you may do, what you may not, and what you technically can do today but will pay for. The legal reasoning lives in Licensing and the technical gaps in Missing features; this page is the two of them condensed to the questions a release actually raises.

Note

None of this is legal advice. It is an accurate account of what the licences in this repository say and what the code does, so that you or an actual lawyer can move quickly.

Requirements

Kerosene is licensed GPL-3.0-or-later with the Kerosene Exception. The exception is what lets a closed-source game link the engine at all: it is an additional permission under GPL §7, granted on conditions, and shipping a game means meeting them. A distribution must carry:

1. The licence texts. LICENSE (the GPL) and LICENSE-EXCEPTION (the Kerosene Exception), in full, beside the game.
2. A notice that the program is built with Kerosene, what licence the engine is under, and that it comes with no warranty.
3. A pointer to the corresponding engine source. The obligation travels with the copy, so it has to be in the copy: a URL, or an offer, in the README.txt.
4. An attribution screen. Each time the game starts, before or together with its first interactive screen, it shows that it is built with Kerosene. Brief and dismissable is fine; disabled, hidden or illegible is not. A game with no graphical interface prints the line instead.
5. Third-party notices for what travels inside the binary. Two things do: smartstring (MPL-2.0, pulled in by the script engine) and the typefaces egui embeds (SIL OFL 1.1 and Ubuntu Font Licence 1.0). Both are satisfied by preserving their notices.
6. If you changed Kerosene’s own files: the whole modified engine stays under the GPL with the exception; it says “modified from Kerosene”, the version or commit it diverged from, and where Kerosene’s source is — in its notice, in the game’s README.txt and on the attribution screen; and its complete source is published where anyone can obtain it free of charge. See Forks and derived engines.

kiln --ship writes 1, 2 and 5 for you and leaves a labelled space for 3 and for the modified-engine line in 6. Item 4 is drawn by your game — the engine does not draw it for you yet (Missing features) — and the rest of 6 is yours alone; no tool can know whether the engine you built against is the one in the repository.

You can

You cannot

You can, but…

Everything here works, or can be made to work, and each has a cost the engine does not yet hide. These are the gaps a release runs into, in roughly the order you will hit them; the fuller list is Missing features.

Forks and derived engines

There are three ways to change the engine, and they are not equal.

A pull request. The cheapest by far, and the one the project asks for first. Send the change upstream, build on the updated engine, and the fix exists once — reviewed, tested, and maintained by someone other than you. Every other option below means you carry it.

A private fork. You changed something and you ship it inside your own game. A modified Kerosene is a modified Kerosene wherever the changed files live, so what you owe is what the exception says of one:

• the whole modified engine stays under the GPL with the exception (§1(a));
• if the game is closed — that is, if you are using the linking permission — the complete source of the modified engine is published where anyone can obtain it free of charge, not only offered to your players (§1(c));
• it says “modified from Kerosene” (or “built from Kerosene”), the version or commit it diverged from, and where Kerosene’s source is — in the engine’s own notice, in the game’s README.txt, and on the game’s attribution screen (§2(b), §2(e));
• it is not presented as the original or as endorsed by this project.

Decline the exception and you are under the plain GPL: the entire game is then a covered work, and only then is publication not required — recipients get the source instead.

A derived engine. The Source lineage has a precedent for this: Respawn took Source, rewrote large parts of it, and shipped Titanfall on the result — a branch that was recognisably Source and recognisably not. Kerosene would like to be forked that way. If you rewrite the renderer, or the physics, or half of everything, and other people are going to build games on what you made, that is a derived engine, and you are welcome to name it after this one so its lineage is plain: Kerosene: Ultimate, Kerosene NG, whatever fits. Everything a private fork owes, a derived engine owes too; the attribution-screen requirement is inherited, so every game built on the fork shows “built with Kerosene NG, modified from Kerosene”.

The naming policy

The licence grants no right to the name. §2(d) of the exception grants it, on conditions: call your engine something a reasonable person would take for a Kerosene branch — a name that contains “Kerosene” or is plainly derived from it — and you accept these:

1. Publish the whole modified engine as source, under the GPL with the exception — the engine, not only the files you changed — where anyone can obtain it free of charge. A Kerosene-named engine is open the way Kerosene is open, whether or not a closed game ever ships on it.
2. Attribute Kerosene as §2(b) asks: “modified from Kerosene”, the version or commit you diverged from, and a link to Kerosene’s source, in your engine’s notice and in the notice and attribution screen of every game built on it.
3. Say it is a derivative. Do not present it as the official Kerosene or as endorsed by this project; a line in the README saying it is an independent fork is enough.

Use a name that is not Kerosene’s and only §2(b) and the linking conditions apply. The project would rather see a well-named derivative than a closed one with a different label.

What stays the same whichever way you go: the two licence texts ship, the notices ship, kiln --ship still writes them, and no Valve or id mark becomes part of anybody’s branding.

How kiln --ship helps

kerosene-tools kiln --ship dist

builds the content if it is stale, builds the game package if the project names one, and assembles:

dist/
  my_game            the game, or the engine runtime when the project names none
  my_game.kproj   content = "content", so the game finds its own archive
  content/
    my_game.vault
  LICENSE            the GNU General Public License, version 3, full text
  LICENSE-EXCEPTION  the Kerosene Exception, full text
  README.txt         what this is, and the notices the licence asks for

Three properties are worth knowing:

• It copies a named list, not a directory. Nothing from target/ sweeps in by accident, and in particular no tool does.
• It refuses rather than warns. A missing archive, or one older than any file in the content tree, stops the ship stage. Run kiln again first.
• The licence texts are compiled into kiln, so shipping works from an installed toolset that is nowhere near a checkout.
• --steam adds Valve’s library and nothing else. It builds with the steam feature, puts libsteam_api beside the game with an rpath to find it, and writes SteamPipe scripts next to dist/ rather than inside it. See Steam. On Windows, every ship links the C runtime statically, so players need no Visual C++ redistributable.

What it leaves for you: the README.txt has an Engine source section that says the source must be available and asks you to say where — and, if your engine is modified, which version it diverged from and where the whole modified source is published. Fill it in. That, the attribution screen the game draws itself, and testing the result on a machine that is not yours — see the Shipping checklist.