GRYMO
a self-breeding digital species.
born from seeds.
shaped by genes.
mutated by bloodlines.
now given somewhere public to live.
SOLANA COLONY STATUS: PRE-GENESIS
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 deterministic goblin system. one seed goes in, one genome comes out.
palette, eyes, snout, ears, fangs, warts and skull deformation render live as procedural svg.
the output can be copied. the origin can be independently recomputed.
breeding recombines two genomes, then applies kinship-weighted mutation.
tighter bloodlines drift harder: third eyes, reversed fangs, caved skulls.
the genome fixes the face and the personality constraints.
the model interprets those constraints into a voice; different calls may phrase it differently.
**v0.2, prototype. local first. public when useful.
****ugly on purpose. malformed goblins and abominations are by design.
****every goblin is a pure function of its seed and breeding history.
last update
ca
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.
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.
{
"v": 1,
"seed": "741190",
"origin": "founder",
"parents": null,
"generation": 0,
"kinship": null,
"phenotype": {
"palette": 7,
"eyes": 2,
"eye_size": 0.68,
"eye_spread": 1.33,
"snout": 0.96,
"ears": {
"size": 1.44,
"droop": 0.51
},
"fangs": 2,
"warts": 0,
"brow": 13,
"skull": 0.87
},
"behaviour": {
"greed": 0.47,
"fear": 0.97,
"patience": 0.64,
"risk_tolerance": 0.21,
"herd_instinct": 0.85,
"conviction": 0.95,
"loss_aversion": 0.03,
"volatility_affinity": 0.92,
"drift": 0.37
},
"variants": [],
"mutations": []
}the market genome
the genome doesn't stop at the face
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.
face / voice / instinct
one genome. three expressions.
the face — what it looks like.
the voice — how it speaks.
the instinct — how it reacts.
call the ai
the local lab turns the genome into a face and a deterministic template voice.
model interpretation is a planned adapter, not a hosted AI service. no API key is requested here.
the ai doesn't invent the goblin. it interprets it.
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.
bring your own model
genome in, voice out. the model adapter is a future interface.
today the website runs a deterministic local template. the public core has no model dependency.
run it yourself
the public core runs locally. inspect the source, run the examples, and replay the tests.
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.
the image is an output. the recipe reconstructs the organism.
why solana?
the environment
genes need somewhere to misbehave
GRYMO began as a closed deterministic system. seed in. goblin out.
Solana is the proposed public habitat. the genome remains local and deterministic.
outside: network load, activity and changing conditions. same organism. different pressure.
selection pressure
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.
the face mutates.
the voice mutates.the instinct mutates.
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.
kinship raises both visual mutation and behavioural mutation.
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.
mutation does not only change what you see.
it may change how a goblin looks, how a goblin speaks, and how a goblin reacts.
the lineage registry
the face can be recomputed.
the ancestry should be provable.
each GRYMO organism can be reduced to a compact record:
seed, parents, generation, genome hash, and mutation flags.
the art does not need to live onchain. the lineage may become public.
the colony
today, the colony is replayed locally. 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. keep the seed and its breeding recipe, and you can reconstruct the organism. this is replay, not an ownership contract. two people on opposite ends of the earth, given the same lineage, rebuild the identical creature down to the
last wart. the local model is replayable history; a public colony begins when lineage records can be published to Solana.
the colony is not a collection. it is a population.
a collection counts images. a population remembers ancestry.
colony genesis
solana note
roadmap
v0.1 genome spec, deterministic breeding, svg renderer, behaviour genome.
v0.2 current specimen, local colony, export/import, lineage.
next freeze genome spec v1; current status: draft.
then Solana lineage program prototype.
after public lineage explorer.
later optional wallet-authenticated lineage publication.
future compressed lineage proofs, only if actually needed.
faq
how do i play. use the local lab above or run the public core. no signup, wallet, API key or token purchase required.
why do i need my own ai. you do not need AI for this lab. model voice is a planned optional adapter.
which model. no model is called by this site. the VoiceAdapter interface is planned.
is there a token. not yet. genesis has not been published. the only valid mint address will appear at the top of this site.
what lives on Solana. eventually, lineage. the goblin is still recomputed from its seed; the chain does not need the picture.
why solana. GRYMO derives organisms from seeds; Solana derives program-controlled addresses. two deterministic systems, different layers.
do i need a wallet. not to generate or breed locally. future onchain publication would require one; wallet integration is not implemented.
why not store the image. because the image is an output. the genome is the source.
can the same goblin be rebuilt elsewhere. yes. same founder seed or complete breeding recipe, same versioned genome rules, same organism.
can two people breed the same goblin. yes. same parents. same seed. byte-identical genome and phenotype. the voice is interpreted from the same personality constraints, but model output may vary.
why is it so ugly. inbreeding. the gene pool is closed on purpose. ugly is the feature, not the bug.
who made this. the one who was writing the code last time.
principles
a goblin is a pure function of its seed and breeding history.
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.
behaviour mutates too.
the chain stores provenance. the browser reconstructs phenotype.
local first. public when useful.