Lexicon - An Invented Written Language Your Player Learns To Read

Lexicon invents a complete writing system from a seed, writes it on everything in your game, and lets the player learn to read it. Signs, tombstones, spellbook pages, banners, dialogue. The player cannot read a word of it. As they learn letters, those letters resolve into readable text in place, everywhere they have ever appeared, at once.

Learning is the mechanic. The alphabet is the art.

Every image on this page was rendered by the package itself, from a real GameMaker build. There is no image file in it: no sprite, no atlas, no texture page, and no font file for the invented script.

The whole thing in four lines

script = lxc_script_create(40312);        // the rules: a family, a lattice, a pen, a name
lex    = lxc_lexicon_create(script);      // 36 letters, proven distinguishable, plus progress
lxc_draw_text(lex, pal, "the gate opens at dusk", x, y, 24);
lxc_learn_string(lex, "threshold");       // every sign in the world opens that much further

lxc_draw_text does the resolution. You never branch on whether a letter is known. If you had to, this would be a font with a lookup table sitting next to it.

Six arrangements, not six skins

Each family is a genuinely different construction, not one generator restyled. What makes a real alphabet cohere is that every letter is built on the same skeleton, so a script here owns a lattice of anchor points and every letter is a walk between them.

• staved - one vertical stave with branches struck off it (the Futhark arrangement)
• impressed - clusters of wedges pressed at lattice points (the cuneiform arrangement)
• cursive - one continuous slanted pen path, joining on both sides (the chancery arrangement)
• geometric - chords and arcs on a ring of anchors (the Tifinagh arrangement)
• hanging - letters depending from a headline (the Devanagari arrangement)
• blocked - strokes inside a square field, sometimes enclosed (the seal-script arrangement)

Those are arrangements. Nothing here reproduces a real script's letters and nothing here encodes a real language: the shapes are sampled from your seed. The families are named after the arrangement so you can pick the one that suits your world.

The letters are PROVEN readable, not hoped readable

This is the part that is not decoration, and it is why the product exists rather than a font.

A generated alphabet fails in four ways, and every one of them passes every drawing check there is: two letters are near-identical, one letter is another mirrored, every letter is one shape with noise, or a letter is unreadable at the size a dialogue box renders it. All four are valid geometry and all four are ink in the right places.

So every letter is rasterised at 14 pixels - the size a dialogue box actually renders at, not the size a catalogue plate does - and compared against every letter already accepted, and against their mirrors and half-turns, because b/d and b/q are perceptual collisions that no distance between point lists can see. A letter that collides is resampled, deterministically, until it clears.

lxc_lexicon_report(lex) prints what your script actually achieved: the worst pair it measured, how many resamples it took, and whether any letter had to be forced.

What you get to steer

• 6 script families, each with its own lattice, allowed marks and joining behaviour
• 36 letters per script, 26 letters and 10 numerals, every pair proven distinguishable
• 16 stroke primitives - the alphabet the alphabets are written in, chosen to differ in SHAPE rather than orientation
• 10 materials - slate, sandstone, granite, vellum, parchment, bronze, oak, limewash, basalt, verdigris. One perceptual ramp per material plus two inks, so a bevel never introduces a colour the material does not have
• 8 surfaces - sign, tombstone, page, scroll, lintel, banner, rubbing, dialogue box. Each is relief geometry lit by the same lamp as the letters cut into it
• lean, pen weight, stroke count, ornament frequency, joining, baseline behaviour, weathering

The dialogue box is made of the same thing as the writing

There is no windowskin in this package and no nine-slice. The dialogue box is a rounded outline handed to the same bevel function that cuts the letters, lit by the same lamp, in a material you choose with one number. That is the whole reason it does not look like the engine: your interface is made of the same stuff as the writing on your walls.

The learning state is separate, on purpose

You will want to save it, reset it, grant letters by quest, grant them by item, and show a translation UI over the top. lxc_learn and lxc_is_known are the entire interface and everything else reads them. lxc_learn returns true only if the letter was not already known, so you can play your sound on the transition without tracking it yourself.

lxc_lexicon_save(lex) returns a 36-character string. Put it in your save file next to the seed you already store, and the world's writing and the player's progress both survive. A short or corrupt string restores what it can and never throws.

Two things this is NOT, stated plainly

• It is not a cipher. The mapping is a one-to-one substitution, which anybody can break by counting letters. It exists so a PLAYER cannot read a sign until their character has learned those letters. Do not hide a puzzle answer behind it.
• It is not a language. It invents letterforms and the arrangement they sit in. There is no grammar, no vocabulary and no phonology in it.

Performance

A letter is tens of primitives and a page is dozens of letters, so ship the cache. lxc_lexicon_cache(lex, 96) bakes the unlearned letters once, in white, and tints them at draw time, which means one cache serves every material in your game and the cached letters are identical to the pixel. The learned form is a single font draw and is never cached, so the mechanic can never freeze on the fast path.

Nothing in the package calls random(). The same seed is the same alphabet forever, so nothing flickers between frames and a player's world stays the world they learned to read.

Verification, stated honestly

GML cannot be unit-tested outside the engine. What this package does instead is test itself inside one: Lexicon.exe -selftest runs 709 assertions against the shipping build and writes the result to a file. It builds 216 letters across six families, compares 3,780 pairs, and prints the worst distance it measured rather than a pass mark.

The first block of assertions is negative controls: every instrument is first handed something it must reject. The distinctness metric is fed a letter against itself, the aloneness check is fed a blank raster and a solid one, the convexity check is fed a bowtie, and the fitter is fed both an oversized letter it must shrink and an inside one it must leave alone.

What none of that can do is judge a picture. The gallery above was reviewed by eye, and it is where the real defects were found.

Compatibility

Built and gate-verified against GameMaker runtime 2024.14.4.268 (the stable GMS2 runtime), on Windows, through a real Igor package build. Pure GML: no extensions, no shaders, no platform calls, so it carries to every export target GameMaker supports. Import with Tools ▸ Import Local Package, open rm_lexicon_demo, press Run.

GMRT is not a dependency and is not claimed. The GMS2 runtime is supported by the vendor until at least Q1 2028.

Every global, macro and function is prefixed lxc_ / LXC_. GML's global namespace is flat and a collision in your project is a support ticket nobody can debug remotely.

What you get

• Lexicon.yymps - the local package, 14 scripts of raw readable GML, header-documented
• a runnable demo room, which is the quickstart and the smoke test, and which calls every public function in the package
• the demo driver object, which is the shortest usage example there is
• two Open Sans fonts (Apache-2.0) used only for the RESOLVED letters and the demo readout. Not one glyph of any invented alphabet comes from a font file

One licence per developer who works with the source. Build anything you like with it, commercial or free, forever, and the alphabets it invents for you are yours - name them, print them, put them on your key art, with no attribution and no revenue share. Do not resell or redistribute the package itself.

Lexicon is one of a family of pure-GML generators from this studio. Hearth furnishes interiors from purpose and occupant, Borough draws the outsides of the same buildings, and Meridian generates skill trees. All of them are relief geometry lit by one lamp, and they sit on one screen without arguing.