GRYMO // a self-breeding digital species

a self-breeding digital species.
born from seeds. shaped by genes. mutated by bloodlines.
now exposed to markets.

that last goblin wave. i was on the side writing the code, not the one grabbing a number. you know the one. i won't spell it out.

GRYMO is a goblin generation system i built. it comes down to one line: every goblin is a pure function of its seed.
one seed goes in, one genome comes out. palette, eye count, snout, ears, fangs, warts, skull deformation, all of it parameters,
then rendered live into procedural svg with zero hand drawing. keep the seed and this exact goblin rebuilds forever. it can't be copied and it can't be forged.

breeding takes two genomes and recombines them, then adds a layer of inbred mutation. the inbreeding is a constraint i added on purpose.
the tighter the gene pool, the wilder the drift, the more likely it grows something off script. a third eye. fangs pointing the wrong way. a caved in skull.
the system is deterministic, yet i can't predict its output either. ugly isn't a bug. it's the system working.

i didn't build this to ship another batch of pictures. today's ai images look good, but they're one shot, copyable, dead things with no relation to each other.
i wanted a living system, one with bloodlines, heredity, drift. the genome doesn't just decide how a goblin looks. it decides how it talks. same genome, same face, same voice.

****ugly on purpose. malformed goblins and abominations are by design.
****every goblin is a pure function of its seed.

how it breeds

every goblin is a genome: a flat, versioned vector of traits, and nothing outside that vector defines the goblin.
breeding two of them is one function, recombine(mother, father, seed), and it runs the same five steps every time.

# the breeding pipeline, top to bottom 1. derive child_seed = hash(mother.seed, father.seed, seed) # one number that fully determines the child 2. inherit for each locus: coin(child_seed) ? mother[locus] : father[locus] # discrete traits (eyes, fangs) are picked whole 3. blend continuous traits (snout, skull...) are averaged, then nudged by a small prng jitter off the midpoint 4. mutate roll once per locus. odds scale with kinship (see below). a hit pushes the trait off the map: a third eye, a reversed fang, a skull that caves in 5. clamp force every value back into its legal range, so even a monster is still a valid, renderable goblin

every random draw in steps 1 to 4 comes from a prng seeded only by the two parents and the seed. there is no wall clock,
no global state, no network. the whole function is pure. same parents, same seed, byte for byte the same child, on any
machine, in any year. that is the one rule the entire project is built on, and everything below is a consequence of it.

the genome

a goblin serialized. this is the whole thing. the renderer reads it to draw the face; the ai reads it to write the voice.
the format is versioned, so an old seed always rebuilds under the rules it was born in, even after the spec moves on.

# goblin.json (schema v1) { "v": 1, # genome schema version "seed": 741190, # the goblin IS this number "parents": [118050, 339201], # mother seed, father seed "palette": 4, # skin / hue index 0..8 "eyes": 3, # eye count 1..3 (inbred spike) "eye_size": 1.24, # 0.6..1.8 "eye_spread":0.71, # how far apart 0.5..1.5 "snout": 0.81, # nose length 0.4..1.6 "ears": { "size": 1.1, "droop": 0.7 }, "fangs": 2, # protruding teeth 0..3 "warts": 4, # wart count 0..6 "brow": -11, # brow angle, degrees -30..30 "skull": 1.22, # deformation >1 bulges, <1 caves in "mutations": ["third_eye", "reversed_fang"] }

the market genome

a goblin's genome already determines how it looks.
now part of that genome is interpreted as behavioural temperament.
not predictions. not financial advice. instinct.

# MARKET_GENOME / deterministic phenotype greed 0.00 fear 0.00 patience 0.00 risk_tolerance 0.00 herd_instinct 0.00 conviction 0.00 loss_aversion 0.00 volatility_affinity 0.00 SEED 0x7d4ec91a GENOME HASH 0x0000000000000000

function deriveTrait(seed, trait) { const h = hash(seed + ":" + trait) return normalize(h) } const marketGenome = { greed: deriveTrait(seed, "greed"), fear: deriveTrait(seed, "fear"), conviction: deriveTrait(seed, "conviction"), volatilityAffinity: deriveTrait(seed, "volatility") }

face / voice / instinct

the face — what it looks like.
the voice — how it speaks.
the instinct — how it reacts.

call the ai

this is how you play. there is no mint button and no hosted app. you clone the repo, bring your own key, and call the
model yourself. the genome math is pure and local; it gives you the face for free. the ai is what gives the goblin a soul.
it reads the genome and speaks as that exact goblin, names itself, and talks in a voice no other goblin has, because the
same numbers that bent its skull also bend how it thinks. no ai call, no soul. just a face waiting for one.

# pip install anthropic && export ANTHROPIC_API_KEY=sk-ant-... import anthropic from grymo import Genome, recombine # deterministic, local, no ai client = anthropic.Anthropic() def breed(mother, father, seed): child = recombine(mother, father, seed) # pure function of the seed soul = client.messages.create( model="claude-opus-4-8", max_tokens=400, thinking={"type": "adaptive"}, system=( "you ARE the goblin this genome describes. " "more eyes, more paranoia. caved skull, slower wits. " "more warts, meaner. speak only in its voice. " "name yourself. stay ugly." ), messages=[{"role": "user", "content": child.to_json()}], ) return child, soul.content[0].text # same seed in, same goblin out. forever. goblin, voice = breed(Genome.load("mother.json"), Genome.load("father.json"), seed=741190) print(voice) # mekmek. i am Snotgrub. three eyes see three enemies. you are all three.

the model does not create the personality. the genome constrains it.
a goblin with high fear, low conviction and high herd instinct should not speak like a goblin with low fear and extreme volatility affinity.
same model. different genome. different goblin.

# PERSONALITY SIMULATION / no trade execution MARKET INPUT NVDA +4.7% / VOLATILITY HIGH GOBLIN #0192 greed 0.88 fear 0.13 conviction 0.79 response "green candle. humans running again. me follow? maybe. me bite first." GOBLIN #0441 greed 0.31 fear 0.82 conviction 0.29 response "too loud. too many humans. me hide."

bring your own model

the genome is the contract, not the model. GRYMO ships tuned against claude-opus-4-8, but the ai side is just:
genome in, voice out. point breed() at whatever chat model you can call and the goblins still speak. swap the client,
keep the system prompt. run it against a local model with no key at all if you want. the face is always yours because the
math is local; the voice is yours because you brought the model. nobody is renting you your own goblin.

run it yourself

# three lines to your first goblin git clone https://github.com/casneto/GRYMO cd GRYMO && pip install -e . grymo breed mother.json father.json --seed 741190 --render out.svg # or from scratch, no parents: grymo spawn --seed 741190 --render out.svg --voice

the renderer

the genome does not point at a picture. there is no image file anywhere, no sprite sheet, no stored art. the renderer is
pure geometry: it reads the numbers and issues draw calls, one trait at a time, building the goblin as layered svg. eye
count decides how many eye groups get placed, skull scales the head ellipse, wart count seeds that many bumps from the
same prng, mutations splice in extra passes. because it is math and not assets, the same genome draws the exact same face
in a browser, on a server, in a terminal preview. the goblin is not stored anywhere. it is recomputed, identically, on
demand, from the number.

why robinhood?

Robin Hood stole from closed systems. Goblins were never much better. They hoard. They steal. They breed. They mutate. They fight over whatever shines. So we gave them a market. Robinhood Chain is not where GRYMO was created. It is where the colony gets exposed. // robin stole gold. goblins call that asset migration.

the environment

GRYMO began as a closed generative system. seed in. goblin out.
robinhood chain changes the experiment. the colony can now exist beside tokenized markets, financial assets and autonomous agents.
the genome stays the same. the environment changes.

# ENVIRONMENT network ROBINHOOD CHAIN colony GRYMO generation 000 market exposure PENDING selection pressure 0.000 behaviour engine ONLINE execution DISABLED

# DEMO MARKET FEED / SIMULATED ENVIRONMENT INPUT NVDA ███████░░ volatility TSLA █████████ volatility HOOD ██████░░░ volatility SPY ███░░░░░░ volatility GOBLIN GENOME + EXTERNAL MARKET ENVIRONMENT = BEHAVIOUR

market selection

generation systems usually stop after generation. GRYMO doesn't have to.
once behaviour becomes observable, the colony gains another layer: selection.
some goblins chase volatility. some avoid it. some follow crowds. some do the opposite.
over generations, those differences become part of the colony's history.

GENOME ↓ BEHAVIOUR ↓ MARKET ENVIRONMENT ↓ OUTCOME → RECORD → BREED → NEXT GENERATION

inbreeding

the colony only ever breeds within itself, so bloodlines fold back on each other fast. the engine measures that with a
kinship coefficient: walk both parents' ancestry, count shared ancestors, weight by distance. the closer the pair, the
higher the number, and the mutation odds in step 4 scale straight off it. distant strangers breed clean and boring.
siblings breed monsters. this is the whole aesthetic engine: a closed gene pool that drifts harder the longer it runs.

# mutation odds per locus, by how related the parents are unrelated kinship 0.00 ~4% // clean, forgettable cousins kinship 0.06 ~11% half siblings kinship 0.12 ~19% siblings kinship 0.25 ~34% self x self kinship 0.50 ~55% // abominations

# INBREEDING COEFFICIENT 0.83 / MUTATION EVENT visual eye_count +1 behaviour loss_aversion 0.42 → 0.03 behaviour volatility_affinity 0.61 → 0.96 ugly is rarity. behaviour mutates too.

mutations & rarity

a mutation is a trait shoved past its normal range, or an extra draw call the base genome never had. they are catalogued,
not open ended, so a mutation means the same thing on every goblin that carries it. rarity is not assigned by hand. every
goblin gets an ugliness score, summed from how far each trait sits from baseline plus its mutation load, and the score
alone decides the tier. ugly is not a defect here. ugly is the rarity.

# rarity is derived, never granted common ugliness 0..33 the vast, forgettable middle weird ugliness 34..57 one thing is clearly wrong cursed ugliness 58..79 several things are wrong at once abomination ugliness 80..100 should not have been born

mutation does not only change what you see.
it may change how a goblin looks, how a goblin speaks, and how a goblin reacts.

PHENOTYPE MUTATION face / body / visual traits VOICE MUTATION personality / expression INSTINCT MUTATION market temperament / reaction

the colony

the colony is every goblin anyone has ever bred. because a goblin is nothing but a seed plus its two parents, the entire
population compresses to a list of lineages that anyone can replay and rebuild bit for bit. no server holds the art, no
database holds the truth. the seed is the goblin. hold the seed and you hold the goblin, and no one can take it, dilute it,
or fake it. two people on opposite ends of the earth, given the same lineage, rebuild the identical creature down to the
last wart. the population is not a collection of files. it is a shared, replayable history that lives in the numbers.

the colony is not a collection. it is a population.
a collection counts images. a population remembers ancestry.

# COLONY STATE population 2 generation 0 unique genomes 2 known bloodlines 1 mutations 0 market environment ROBINHOOD market exposure NOT STARTED

market genesis

# GENESIS STATUS network ROBINHOOD CHAIN species GRYMO generation 0 market UNEXPOSED CA AWAITING PUBLICATION execution DISABLED selection INACTIVE the colony exists. the market does not know it yet.

roadmap

v0.1 genome spec, deterministic breeding, svg renderer, ai voice, running locally. // you are here
next publish the repo. freeze the genome format and the prng so everyone breeds against the same standard.
then a shared colony index: post a lineage, anyone rebuilds the exact goblin and its voice from the seed alone.
after a family tree you can walk: every goblin back to the founders, kinship visible, bloodlines you can hunt.
later persistent voices. a goblin remembers what it said the last time you called it, and holds a grudge.

faq

how do i play. clone the repo, add your key, run breed(). no signup, no mint, no waitlist, no site to log into.
why do i need my own ai. the goblin is generative, not a jpeg. its voice is computed on demand from its genome, by you, not served to you.
which model. tuned on claude-opus-4-8, but any chat model works. the genome is the contract; the model is swappable.
is there a token. not live. maybe never. the ca above stays empty until it isn't, and it may never.
can two people breed the same goblin. yes. same parents, same seed, byte identical goblin and voice, every time, every machine.
why is it so ugly. inbreeding. the gene pool is closed on purpose. ugly is the feature, not the bug.
can i sell one. you can sell a seed. whether that means anything is between you and whoever wants it.
who made this. the one who was writing the code last time.

principles

a goblin is a pure function of its seed.
the face is math, the soul is a model call, and both are yours.
nothing is stored that cannot be recomputed.
the gene pool stays closed. drift is the point.
ugly is not a defect. ugly is the rarity.
no button. you run it yourself.