Gremmo

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.

gremmo 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.

now the colony gets an economy of its own. when a goblin is minted, the nft is not only proof that this seed and bloodline
belong to a wallet. it is also one base share in the colony. trading fees flow into a public treasury, the treasury acquires
supported tokenized stocks and other assets on robinhood chain, and eligible holders share in what the colony distributes. the more the
goblins move through the world, the more value returns to the wallets that keep them.

the rule stays as simple as the genome: the seed proves the goblin, the nft proves the holder, and robinhood chain proves where
the money went. the mint and treasury contracts are still being built; nothing is live and no fixed return is promised yet.

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

gremmo is built for robinhood chain. the official mint and treasury contracts will be published here after deployment.
do not trust addresses posted anywhere else.

the colony treasury

minting a goblin does more than put a face in your wallet. every gremmo nft is a receipt from the colony and a claim on
its future distributions. when goblins trade, a share of the protocol fee flows into a transparent colony treasury instead
of disappearing into a team wallet. the colony uses that treasury to acquire supported tokenized stocks and other approved
assets on robinhood chain. what the colony earns is routed back to eligible wallets still holding the goblins.

# the colony's value loop mint a goblin -> hold the nft -> receive a share of distributions ^ | goblin trades -> protocol fee -> colony treasury | +-> tokenized stocks +-> holder rewards one goblin = one base share. every movement is visible on robinhood chain.

the first version keeps the rule legible: one goblin carries one base share, calculated from eligible snapshots rather
than promises of a fixed return. supported assets, distribution timing, fees, custody and jurisdiction restrictions will
be published before activation. until the treasury contracts are deployed and audited, this is the intended mechanism,
not a live yield product.

why the nft matters

the seed still rebuilds the face, but the nft proves who holds the colony position at a given block. sell the goblin and
the future claim moves with it. breed a new goblin and a new lineage enters the colony under the mint rules active at that
time. the art, ancestry and economics travel together instead of being split across an image, a database and a points page.

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"] }

call the ai

this is how the prototype works today. the mint interface and treasury are not live yet. 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 gremmo 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.

bring your own model

the genome is the contract, not the model. gremmo 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

today, the generative engine is a repo and a key. no account and no permission required. the mint and treasury layer comes next.

# three lines to your first goblin git clone https://github.com/gremmo/gremmo cd gremmo && pip install -e . gremmo breed mother.json father.json --seed 741190 --render out.svg # or from scratch, no parents: gremmo 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.

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

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

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.

roadmap

v0.1 genome spec, deterministic breeding, svg renderer, ai voice, running locally. // you are here
next freeze the genome format, launch the robinhood chain mint interface and publish the nft ownership contract.
then deploy and audit the colony treasury, fee router, holder snapshots and distribution contracts.
after activate supported tokenized-asset purchases where available, with every treasury movement visible on robinhood chain.
later a shared family tree, persistent voices and treasury history for every generation of the colony.

faq

how do i play. today: clone the repo, add your key and run breed(). minting opens after the contracts are ready.
which chain. gremmo's nft, mint and colony treasury are being built for robinhood chain.
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.
what does the nft do. it proves ownership of a goblin and is intended to carry one base share of future colony distributions.
where do the fees go. into the colony treasury, which is designed to acquire supported tokenized assets and distribute rewards to eligible holders.
is the treasury live. not yet. no return is promised. contracts, supported assets, eligibility and regional restrictions come before activation.
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.
every goblin carries one base share of the colony.
the treasury belongs on robinhood chain, where every holder can inspect it.

the goblins own the colony