Docs / Your game's name
The mark
EngineMark is the engine's mark, the element Du, as geometry. Draw it into your HUD at any size to credit the engine in a corner, a credits screen or an about box; the splash uses it the same way. The SVG files in Brand/ are written from the same geometry, so there is one drawing of the mark, not several that drift apart.
What it is a picture of
Ductane is named for ductile metal, so it is drawn as a metal: a tile from the periodic table, cobalt, with the symbol Du in white. The corners are square, never rounded. The tile is a cell of a table, and a rounded one is an app icon.
The mark is square: EngineMark.width(forHeight:) returns the height.
Drawing it
// Your game, inside encodeHUD, between hud.begin(viewportSize:) and hud.draw(into:frameSlot:). let height: Float = 48 EngineMark.draw(into: hud, origin: viewportSize - height - 24, height: height)
draw(into:origin:height:opacity:) fills the tile with its top-left corner at origin in the HUD's coordinates, and picks the right cut of the letters for the height. It needs no texture, no resource and no pipeline of its own: it is a call to HUDRenderer.fillRect(origin:size:color:) and one to HUDRenderer.fillPolygon(_:color:feather:) for each shape of the letters. opacity runs from 0 to 1 over the whole mark, for a fade, and is 1 unless you say otherwise. A height of 0, or an opacity of 0, draws nothing.
Two cuts of the letters
Letters that are right at 64 points close up at 16, so a small tile sets them larger:
| Cut | Tile height | Type size on a 64 grid | Baseline on a 64 grid |
|---|---|---|---|
EngineMark.Cut.plain | 24 points and up | 36 | 45 |
EngineMark.Cut.small | under 24 points | 42 | 47 |
EngineMark.smallBelow is the height where the cut changes, 24 points, and EngineMark.cut(forHeight:) returns the cut a tile of that height uses. Both cuts are centered on the tile, with the letters drawn 1.5 units closer together than the type sets them.
The letters
EngineMark.letters(_:) returns a cut's letters as filled shapes: three lists of points in a unit square, origin at the top left, y downward, the same as HUDRenderer. They are the stem of the D, the bowl of the D, and the u. The stem and bowl overlap, so fill them in one color and they read as one letter. Scale and offset them yourself if you want the mark in something other than the HUD:
let cut = EngineMark.cut(forHeight: height) let shapes = EngineMark.letters(cut).map { shape in shape.map { origin + $0 * height } }
The letters are outlines, traced once from Inter Tight ExtraBold and kept as data, so nothing needs the font and no host can substitute another. The tests check that they stay inside the tile, are centered across it and stand on the cut's baseline, that no shape crosses itself, and that the small cut really is larger.
Colors
| Color | Value | For |
|---|---|---|
EngineMark.tile | #1C3FE0 | the tile: cobalt |
EngineMark.letter | #FFFFFF | the letters on the tile: white |
EngineMark.ground | #0B0B0C | the ground under the mark when it has the screen to itself, as on the splash: black |
All three are InterfaceColors, drawn exactly as authored because the HUD draws after tone mapping. draw takes no color: the tile is always cobalt and its letters always white.
The files in Brand/
EngineMarkTests holds what every SVG of the mark should say, written from EngineMark.letters(_:), and fails if a file on disk disagrees:
| File | What it is |
|---|---|
ductane.svg | the tile in the plain cut, for 24 points and up |
ductane-icon.svg | an app icon on a 1024 canvas: an 824 tile inset 100 |
favicon.svg | the tile in the small cut, full bleed, for a browser tab |
Each file carries the engine's name as its title. Brand/exports/ holds PNGs of all three at the sizes a site, a store page and a Dock need, rasterized from the SVGs (a brand step, not part of the build).
The letters' outlines come from Inter Tight, © The Inter Tight Project Authors, under the SIL Open Font License 1.1. The font itself is not part of the repository.
Changing the mark means changing the drawing in EngineMark.swift, never a file:
DUCTANE_RECORD_MARK=1 swift test --filter EngineMarkTests
Then the PNG exports are drawn again, and the splash's recorded frame with them. That frame keeps a picture of the mark on screen with a tolerance of its own, because a lit scene's tolerance could not see a mark move. See frames.
Crediting the engine
Required: a credits line. A game that ships the engine names it in its credits or legal screen — for example "Uses Ductane © 2026 Pixla LLC" — with where the license can be read (PolyForm Small Business 1.0.0, whose Required Notice: line this is). That is the whole requirement, as it is for Unreal and Godot. A splash is not required. Showing the engine's name or mark more visibly is your choice; ways to do it, from most to least visible:
- The splash.
SplashScreen(lead: "Made with")at launch: the tile with Made with Ductane beneath it, two and a half seconds, skippable. See the splash. - The mark in your interface.
EngineMark.drawon a title screen, a credits roll or an about box, withEngine.nameset beside it throughHUDRenderer.text. - The files.
ductane.svgon a store page, a website or printed material, or the PNGs fromBrand/exports/.
Write the name as Ductane, in title case, wherever it appears. Where the name sits beside the mark, it is set in a font.
Don't recolor the tile, round its corners, or redraw its letters from a picture. EngineMark.letters(_:) is the mark.