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. Writing Kills, Slain or Eliminations all strike the same blade device, because the corpus knows those words. Writing something the corpus does not know, such as Caravans Lost, sets that row flush with no glyph at all.

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. Compose returns a Texture2D; Bake returns a raw pixel array that is pure arithmetic with no Unity object in it, so it is safe on a worker thread.

• A one-call export that writes a PNG and returns the path it wrote, with clipboard and reveal helpers beside it.

• An editor window under 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.

• Every script in a named, platform-constrained assembly definition. No Resources folder. Full commented source.

Getting Started

1. Import the package into a Unity 6 project (Assets ▸ Import Package ▸ Custom Package, or drop the .unitypackage into the Project window). Everything lands under Assets/CSAF/Signet/.

2. Open the editor window at Window ▸ CSAF ▸ Signet. Type your own stat labels into the rows and watch which ones resolve to a glyph. This is the fastest way to see how your game's vocabulary lands before you write any integration code.

3. Open Assets/CSAF/Signet/Demo/Scenes/SignetDemo.unity and press Play. SPACE rerolls the seed, keys 1 to 7 walk the seven standings, T switches between the social card and the thumbnail composition, and S saves a PNG and puts its path on the clipboard.

4. To wire it into your own game: build a RunRecord, add your stats with .With("Kills", "142"), then call SignetCard.Compose(run, 1200, 630, out var layout) for a Texture2D, or CardExport.ComposeAndSave(run) to write the PNG and get the path back.

5. Call SignetCard.Warmup() once on the main thread at load. The rasteriser compiles on the first card, so card one costs several times what card two does.

Full instructions, the API reference and the stat-label word lists are in the documentation link below.

Technical Information

Features: end-of-run card composition from a plain data record; 24 hand-authored run-stat glyphs matched to the buyer's own stat labels by whole-word lookup with a deliberate silence for unrecognised labels; 9 modelled outcome devices chosen from the run's ending phrase with a stable hash fallback; a seed sigil with 800 distinct shape combinations across arms, core, terminal, inner ring, barring and phase; 7 standing palettes; 50 struck letterforms drawn as signed distance fields so the package ships no font; automatic layout across Full and Compact card styles with the overflow reported rather than lost; PNG export with clipboard and reveal helpers; an editor window with a live vocabulary panel; a demo scene; zero shipped image, audio or font assets.

Code Modules: CSAF.Signet.Runtime (Runtime, all platforms), CSAF.Signet.Editor (Editor only), CSAF.Signet.Demo (Runtime, all platforms, sample content).

Number of Unity Visual Scripts: 0. The package contains no Visual Scripting graph assets and no references to the Visual Scripting packages; verified by walking the shipped tree.

Number of .cs Scripts: 20, measured by walking the shipped Assets tree: 18 Runtime, 1 Editor, 1 Demo.

Supported Development Platforms: Windows (Yes), Mac (Yes). Pure C#, no native libraries, no platform-specific code.

Supported Target Build Platforms: all platforms Unity targets. A CPU rasteriser using only Texture2D and Color arrays, with no shaders, no compute and no platform dependencies.

Supported Unity Pipelines: Built-In, URP and HDRP. The package draws into a Texture2D on the CPU and never touches the render pipeline, so it is pipeline-agnostic by construction.

Dependencies on other Plugins and/or System Libraries: none. No packages beyond the Unity engine and editor assemblies, and no network calls.

Documentation Link and Installation Guide: Signet user guide. The same guide is also included in the package.

Example Project: the package ships a runnable demo scene. On Play it composes one card and caches it; one key rerolls the seed and composes a new one, the number keys walk the seven standings, one key switches between the social card and the thumbnail composition, and one saves a PNG and puts its path on the clipboard. It composes on demand, one card at a time, never a whole gallery up front.

Performance: the marks are signed-distance fields evaluated per pixel on the CPU, so a card costs seconds rather than milliseconds and the cost is proportional to the pixel count. Measured on Unity 6000.5.7f1 in batch mode, in a blank project, importing the exact package bytes this listing 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 being 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 busier machine will exceed them. Compose ahead of the moment you need the card and cache it, or bake it on a worker thread, rather than composing on the frame the player is watching. Call 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.

Versioning and Release Notes: version 1.0.0, first public release.

Contact and Support Information: support is provided through the storefront this product was purchased from; use the Fab product support channel on this listing.

Code and graphics in this package are AI-generated. Every mark is procedural C#; no generative image model was used anywhere in the shipped art path. Copyright (c) 2026 Core Systems Asset Factory.