What is Galapagos?
The open platform where language models don't just answer — they evolve. One six-block vocabulary, one card format, one Hub for the whole community.
Galapagos is an open platform for LLM-driven evolutionary search. It treats a language model not as a one-shot answer machine, but as the engine inside an iterative loop that proposes, scores, and refines candidate solutions — generation after generation — until something genuinely better emerges.
A model that keeps trying
Ask a language model for a single answer and you get a single guess — good, bad, or somewhere in between, and no way to improve it except asking again. Evolutionary search changes the question. Instead of “what's your answer?” it asks “given everything tried so far, what should we try next?” — over and over, with a scoreboard keeping every attempt honest.
That idea already powers some of the most striking recent results in the field — best-of-N sampling, beam search, FunSearch, OpenEvolve. Galapagos exists because every one of these methods, underneath the paper-specific names, is built from the same handful of moving parts.
One loop, six blocks
Galapagos makes that shared skeleton explicit by factoring every method into six composable components — the LEGO bricks that snap together into a scaffold:
The set of candidate solutions in play — the gene pool the search evolves over.
Decides which genomes survive and reproduce — tournament, elitism, novelty, or your own policy.
Assembles the context handed to the model — parents, feedback, instructions, examples.
The LLM-driven variation operator — proposes new candidates by mutation and crossover.
Scores each candidate against the task — the fitness signal that drives selection.
Persists discoveries across generations — archives, islands, and lineage for the search.
Swap a block and you get a different algorithm. Hold them fixed and you have a faithful re-implementation of a published method.
A few lines to run anything
A scaffold, a model, and a task are each loaded from versioned YAML cards through one small API. The same call works for every reference method in the Hub, against any OpenAI-compatible host:
import galapagos as gx
model = gx.GalapagosModel.from_card(name="openai/gpt-5.5", host="openrouter")
scaffold = gx.GalapagosScaffold.from_card(name="openevolve", model=model)
task = gx.GalapagosTask.from_card(name="circle_packing")
result = scaffold.run(task=task, max_iterations=20)
print(result.best_score)Why a shared vocabulary matters
Before a common vocabulary, comparing two search methods meant reading two different codebases, guessing which parts were actually novel, and re-implementing everything from scratch just to run a fair ablation. Galapagos collapses that overhead:
- Every paper ships its own bespoke, hard-to-read search loop.
- Comparing methods means reading unfamiliar code line by line.
- Swapping one idea into another method means a rewrite.
- Your evaluator, prompts, and results live in disconnected scripts.
- Every method is six named, swappable, well-typed components.
- Comparing methods means diffing which of the six blocks differ.
- Swapping one idea into another method is a one-line change.
- Scaffolds, tasks, and results are versioned cards in one Hub.
Cards as the single source of truth
Every scaffold, task, and model is described by a card: a small, versioned YAML file that both the library and the Hub read. Submit a new method, task, or discovery from the CLI and it becomes a card, too — stored once, readable everywhere.
The Hub page you are browsing and the scaffold.run() call in your terminal load the exact same card. There is no second copy to drift out of sync — change the card and both the docs and the code see it instantly.
Where to start
Browse the Hub to see every reference method and the six blocks it snaps together, open the Playground to compose a scaffold in your browser, or read the docs and run your first scaffold in a handful of lines.
Ready to evolve your own solutions?
Six blocks, any task, better solutions emerge.