Signet: Generated Run Result Cards for Unity

At the end of a run, Signet composes a card. Not a screenshot with a frame on it. A struck metal plate that draws the outcome as a device, sets every stat beside its own glyph, and stamps a seed sigil no other run in your game will ever get. It comes out as a Texture2D or a PNG, sized for a social post, and it is built to be posted.

Nothing in this package is a texture. No atlas, no sprite sheet, no material and no font. Twenty-four run-stat glyphs, nine outcome plates, fifty struck letterforms and figures, a seed sigil with eight hundred distinct shape combinations and seven standing palettes are all drawn in C# by a software rasteriser that ships with the package. A thousand runs cost a thousand different cards and zero import time.

The labels are the interface.

There is no enum to map and no second field to fill in. The label you already print is what picks the glyph.

run.With("Kills", "142");          // strikes the blade device
run.With("Slain", "142");          // the same device, the corpus knows the word
run.With("Eliminations", "142");   // and this one
run.With("Caravans Lost", "1");    // no match: the row sets flush, with no glyph

Twenty-four devices cover kills, depth, time, gold, distance, accuracy, combo, deaths, damage dealt and taken, healing, secrets, bosses, score, waves, rank, streak, multiplier, items, energy, shots, blocks, traps and rooms, each with a list of words a game might actually use.

An unmatched label draws no glyph, deliberately. It does not fall back to a hash, because a wrong glyph beside a real number is a false claim about what that number means. The outcome behaves the opposite way: it falls back to a stable hash rather than to silence, because every run that ended has an outcome and a blank hero plate is never the honest answer. Both rules are in the source, which is plain readable C# with the word lists at the top of each entry.

Two axes that multiply. Standing is the metal a run is struck in, seven of them from unfired clay to sovereign. The outcome is what happened, nine devices. They vary independently, because a losing run can be the deepest a player has managed and a win on the easiest difficulty is not a sovereign. That is sixty-three distinct hero plates before a single stat glyph is struck, and before the seed sigil adds its own eight hundred.

What ships

• A runtime composer: SignetCard.Compose(run, width, height, out layout) for a Texture2D, or SignetCard.Bake(...) which is pure arithmetic with no Unity object in it and is safe to run on a worker thread.
• A one-call export: CardExport.ComposeAndSave(run) returns the path it wrote, plus clipboard and reveal helpers.
• An editor window at Window > CSAF > Signet. Type your own labels into the stat rows and watch which ones resolve to a glyph. That is the fastest way to find out how your game's vocabulary lands before you write any integration code.
• A demo scene you press Play on. SPACE rerolls the seed, 1 to 7 walk the standings, T switches between the social card and the thumbnail composition, S saves a PNG.
• Every script in a named, platform-constrained assembly definition. No Resources folder. Full C# source, commented, with the design decisions written down rather than implied.

Performance, measured rather than promised. Signet is a software rasteriser and it does real work. Measured on a busy workstation, in a blank Unity 6000.5.7f1 project, importing the exact package this page sells, a 1200x630 card breaks down as roughly half a second of plate, under a fifth of a second of type, and one to three seconds of devices. The seed sigil is the single largest item because it is five rasteriser passes over a million samples of a radially folded distance field.

Those are samples on one shared machine and not a ceiling. The same card has varied by more than a factor of two between runs, so a quieter machine will beat them and a busier one will not. The Readme in the package says the same thing in the same words.

So compose it off the main thread. Everything except the final texture is arithmetic over arrays and touches no Unity object, which is why Bake and ToTexture are separate calls. Two seconds behind a run-end animation is invisible; two seconds on the frame the player is watching is a stutter. Call SignetCard.Warmup() once on the main thread first, because the runtime compiles the rasteriser on the first card and card one costs several times what card two does. Four concurrent worker bakes are proven byte-identical to a main-thread bake in the package's own test suite.

Requirements. Unity 2022.3 or newer, built and gated against 6000.5.7f1. Editor and runtime, any render pipeline, because nothing here touches one.

AI disclosure. Code: yes. Graphics: yes. Sounds: none ship. Text and dialogue: none, the package authors no prose and every word on a composed card comes from your own RunRecord. No generative image model was used anywhere in the shipped art path. Every mark is procedural C# you can read.