Illustrated creature pages, composed from the stat blocks you already have.

Your bestiary screen is probably a portrait, a name and a wall of numbers. Bestiary Codex takes the

same row of data and composes a page out of it: your own creature sprite mounted on a designed

plate, with a threat rosette whose shape changes with the tier, an elemental rose, a generated

habitat landscape behind the creature, a scale rule with a human figure standing next to it for

comparison, a wax discovery seal, and a strip of trait glyphs chosen from the trait words you

already wrote.

Raise that wyvern from threat 3 to threat 7 and the rosette grows teeth. Move it from the coast to

the ash wastes and the landscape behind it is redrawn. Mark it undiscovered and the whole page is

sealed and redacted. Nothing about that is a re-import — it is a re-read of your data.

That is the part a pack of beautiful hand-drawn bestiary frames cannot do at any price: the frames

in it do not know your creature table exists, so a single frame has to serve the rat and the god.

This does not generate the creature. You already have creature art you chose, and it is the part

of the screen your players look at. Bestiary Codex generates everything around it and composites

your sprite into the middle at whatever size the creature's size class calls for.

Every derivation is reported back to you in plain English, per creature, so you can see exactly which

of your own words chose each glyph — and override any of it when you disagree. A designer who has

typed a trait name has made a decision, and the generator does not overrule it.

Getting Started

• Import the package. Everything lands under Assets/CSAF/BestiaryCodex/.

• Open Assets/CSAF/BestiaryCodex/Demo/BestiaryCodexDemo.unity and press Play. A worked fourteen-creature shelf renders as composed pages — page it with Left / Right.

• Open the tool window: Window > CSAF > Bestiary Codex. Pick a creature in the list, then read the derivation panel beside the preview — that panel is the whole derivation, stated per creature. Export PNG writes the page you are looking at; Export All writes the catalogue.

• Point it at your own data:

using CSAF.BestiaryCodex; CodexPage page = CodexComposer.Compose(new BestiaryEntry { Id = "wyvern.ashen", DisplayName = "Ashen Wyvern", Element = Element.Ember, Habitat = Habitat.Ashfall, ThreatTier = 7, Size = SizeClass.Massive, Discovery = Discovery.Engaged, Traits = new[] { "membrane wings", "serrated maw", "lashing tail" }, Portrait = myCreatureSprite, // your art, composited into the plate }); myRawImage.texture = page.Texture;

• The result is a plain Texture2D on page.Texture. Put it on a RawImage, a UI Toolkit background, a quad or a sprite — or bake it straight to PNG from the tool window. page.NamePlate and page.NotePlate are the rectangles to lay your own text over, in top-left coordinates.

You almost certainly already have a creature type with fifty fields on it. Do not migrate it — write

four lines that project it into a BestiaryEntry at call time and keep your own type as the source

of truth. Runtime/Model/SampleBestiary.cs is the same thing at full size and is worth reading as

the API documentation.

What this is not

It is not a collection or capture system. If you need encounter tracking, capture rates or party

rosters, buy a collection kit — several exist, in pure C# with no art, and the two run happily side

by side. This is the illustrated half: it draws the page, it does not manage the collection.

Technical Information

Features

• Illustrated creature pages composed entirely at run time from your own stat block

• 48 hand-authored trait glyphs across eight families — maw, horn, limb, hide, wing, tail, bloom and aura — six to a family, all plain readable C# you can extend

• 44 further generated marks: 10 threat rosettes, 10 elemental roses, 12 habitat bands and 12 discovery seals — 92 distinct generated entities, none of them an imported image

• Your own sprite is composited into the plate, scaled by the creature's size class, with a scale rule and human reference figure beside it

• Trait glyphs chosen from your own trait words by whole-word match, falling back to a deterministic derivation when your data says nothing — and the page shows which happened, per glyph

• Per-creature plain-English explanation of every derived choice, in the editor window

• Redaction: an unrecorded creature renders as a sealed, redacted page rather than a blank one

• Deterministic: every jitter is seeded from the creature's own id, so a given creature always draws identically, on every machine, offline

• Export any page, or the whole catalogue, to PNG from the editor window

Code Modules

• CSAF.BestiaryCodex.Runtime — model, reading, glyph corpus, marks and software rasteriser

• CSAF.BestiaryCodex.Editor — the Bestiary Codex window and the PNG baker (editor only)

• CSAF.BestiaryCodex.Demo — the demo scene's CodexShelf component

Number of Unity Visual Scripts: 0 - this package contains no Visual Scripting graphs, nodes or custom units. It is plain C# only.

Number of .cs Scripts: 27 (MEASURED, not estimated — 27 .cs files across three assembly

definitions in Product_Release/Assets/CSAF/BestiaryCodex/)

Supported Development Platforms: Windows, macOS, Linux

Supported Target Build Platforms: all platforms — the runtime assembly is platform-agnostic and

takes no native dependency

Supported Unity Pipelines: Built-in, URP and HDRP — all three. The art path is a CPU software

rasteriser that writes into a Texture2D, so it never touches a render pipeline and cannot break

when you change one. There is no shader, no material and no ScriptableRendererFeature in the package.

Engine Compatibility: Unity 2022.3 LTS and newer; built and gated against Unity 6 (6000.5.7f1)

with warnings treated as errors.

Dependencies: none. No uGUI requirement, no TextMeshPro, no URP requirement, no Resources/

folder, and no network access at any point.

Example Project: included. Assets/CSAF/BestiaryCodex/Demo/BestiaryCodexDemo.unity is a

runnable scene — open it and press Play. It builds a worked fourteen-creature bestiary from

SampleBestiary.cs at run time and pages through the composed pages with Left/Right. The demo lives

in its own platform-constrained assembly (CSAF.BestiaryCodex.Demo) so it can be deleted without

touching the runtime.

Versioning: 1.0.0 — first public release. Semantic versioning from here: patch for glyph and

rendering fixes, minor for new glyphs, families or API surface, major only for a breaking API

change. The shipped source is raw and readable, so any change is auditable in a diff.

Support: open an issue at https://github.com/onefreeman1337/csaf-releases/issues, or use the

Fab listing's own question thread. The documentation link below answers integration questions first.

Documentation

https://github.com/onefreeman1337/csaf-releases/blob/main/docs/bestiary-codex/README.md

AI disclosure

The source code and the store imagery were produced with AI assistance, declared truthfully.

No image model touched this product at any point. Every page in every screenshot is a headless

Unity render of the software rasteriser that ships inside the package, from source in this

repository. There is no diffusion model and no network call anywhere in the art path.