Skip to content

About

Self-copying machines from base-game Factorio 2.1 parts: natural selection in a colony, and one assembler that makes all 334 parts of its factory from ore, oil, water and sunlight (only the blueprint's placing is scripted)

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

6 Commits

Folders and files

Repository files navigation

factorio-evolution

Two sites, one above the other. The upper factory, on its own solar panels, works for a long while; then the ghost of a copy appears below all at once, the robots build it, the upper factory vanishes, and the copy makes its own robots.

The upper factory, on its own solar panels, makes all 334 of its parts; when the kit is complete the ghost of a copy is laid below, its two robots build it, the parent is deleted, and the copy makes robots of its own. Filmed in the game's window; the graded run is headless (details).

factorio-evolution holds self-copying machines built only from base-game Factorio 2.1 parts, run headless and measured: a single assembler that makes all 334 parts of its own factory (drills, furnaces, oil refinery and solar field included) from ore, crude oil, water and sunlight, whose copy then runs alone, and a colony in which a cheaper lineage outgrows a costlier one by natural selection. In both, the only scripted act is placing a machine's blueprint where it asks, which no vanilla mechanism can do; the colony is supplied plates and power, and the land-and-sun machine is given small prepared ore patches and no enemies.

One assembler makes every part of its own factory from land and sun. Vanilla Factorio can do everything a self-replicator needs, except place a blueprint; we scripted only that, and in a colony of smaller machines watched evolution happen.

In numbers (each from graded runs; the game build stated):

  • From land and sun: from empty chests and no power source, one assembler makes 334 parts and two robots; the copy is laid whole when the kit is complete (tick 542,520), built at 818,200, on its own solar grid, and makes its own robots after the parent is deleted, Factorio 2.1.24.
  • Its own robots: a 66-part machine makes its roboport and two construction robots; with the parent and every robot deleted, the child builds the grandchild alone (270,200 and 269,400 ticks a generation), Factorio 2.1.22.
  • Selection: light's share of the grown colony is 0.587 where the other lineage pays a cost and 0.380 where it does not; every one of 10 runs above every one of 10 (one-sided exact Mann-Whitney p = 5.4 × 10⁻⁶), Factorio 2.1.20.

From land and sun · Its own robots · Selection in a colony · The record · FAQ · Reproduce · Sources

Why this exists

Inspired by Anthropic's Claude-led discovery of a CRISPR-like enzyme system (September 2026). A personal project can't run a wet lab, so this one uses Factorio as the lab: Claude pre-registers, runs and grades each experiment headless; one person rules. Unlike that system, these machines are built, not found, and their function is what gets measured. Not affiliated with Anthropic.

From land and sun

This machine is handed land: small ore patches under each drill, an oil spot under the pumpjack, a pond under each offshore pump, no biters. One assembler makes every one of the 334 parts its factory is built of, 18 electric drills, 9 steel furnaces, a pumpjack, an oil refinery, 5 chemical plants, 32 solar panels and 27 accumulators among them, and two construction robots, from the ore, crude oil and water its own drills and pumps take. Every chest starts empty and its only power is its own panels.

When the whole kit stands in storage, a decider says so, and only then is the copy's ghost laid (by the test harness: no vanilla mechanism lays a blueprint), all 334 parts at once. The two robots build it. The copy is on its own electric grid from its first panel (both grids read every window: never the same one). Then the parent and every robot are removed, and the copy makes two robots of its own.

The factory with nine numbered boxes: the one assembler that crafts, the row of assemblers that never craft, the wish list, the decider that says the kit is whole, the furnace cells, the oil works, the storage chest, the roboport and the solar field.

event tick
the kit whole, the copy laid (334 ghosts at once) 542,520
the copy built 818,200
the parent and every robot removed 1,100,000
the copy's first robot / second robot 1,104,800 / 1,112,400

One deterministic run of 1,600,000 ticks on Factorio 2.1.24; all five registered predictions held. The film is the same machine filmed in the game's window: that run is not byte for byte the graded one (the copy laid 2,580 ticks earlier), so its captions give its own ticks. The cause, traced (e178): the game's freeplay scenario sets the time of day to 0.7 when a first player joins, and a headless run has no player, so the film's sun ran 7,500 ticks late. The headless run given that one value lays and builds the copy on the film's ticks (539,940 and 815,600); 439 of its 381,945 rows still differ from the film's, two accumulators' charge and the refinery's progress, by at most 4, and that is not explained. Given a time of day of 0 it is the graded run in every row. Laying the copy at the start instead, the same machine took 989,000 ticks: robots took each part as it was made and the chain made it again (read from the counts, not traced). The nearest known work is a vanilla Space Age base on Fulgora that makes all its machines from scrap, placed by hand; self-placing copies exist only with mods (see Sources).

The machine is blueprints/land-and-sun.txt; the run reproduces with one command, about 4 minutes, from reproduce/e177-whole-child/ (see Reproduce).

The step before: it makes its own robots

Three sites in a row. The left machine builds the middle one with two robots it made; the left machine and its robots vanish; the middle machine makes two robots of its own and builds the right one.

A smaller, earlier machine, handed plates and power but no robots and no roboport. One assembler makes all 66 parts the machine is built of, its roboport included, and two construction robots. Two inserters load the robots into a roboport that starts empty, and the roboport's robot count is wired in as stock, so a robot that has left the chests still counts and a third is never made. The two robots build a copy on a ghost of the machine. Then the parent and every robot are removed, and a second ghost is laid beyond the reach the parent's roboport had: the child makes its own two robots and builds the grandchild alone, and the grandchild runs.

The machine with nine numbered boxes: the one assembler that crafts, the row of assemblers that never craft and are read for their recipes' ingredients, the circuits, the wish list, the raw chests, the fluid input with its pumps, a mirror of the crafter, the buffer chests, and the robot loader with the roboport.

generation first robot second robot first part placed copy built
parent (ticks from its start) 48,200 50,800 48,800 270,200
child (ticks from its fill) 48,200 93,200 49,200 269,400

Given, not made: the ghost (placed by the script, once a generation), an electric energy interface for each machine, and raw plates, plastic, batteries and lubricant in its chests. One deterministic run of 620,000 ticks, made twice with the same output byte for byte, the second time with the child's and the grandchild's roboports read (both on Factorio 2.1.22; the film was made on 2.1.24 and wrote the same output again). The first run's three predictions held; of the second's four, one failed: the child's second robot came 45,000 ticks after its first, where the parent's came 2,600 after, and the child built the grandchild's first 34 parts with one robot, in no more time. Why is not known. Each generation also makes one storage tank and one pipe more than it is built of, not explained either. A single assembler that crafts anything from a list is not new (see Sources, the recursive assembler); a build closing the loop through its own robots and roboport was not found.

The machine is blueprints/self-reproducing.txt; both runs' experiment files, output and analyses are in followup/ (no one-command kit for these two: the output and the scripts that read it, not the harness).

Where it started: natural selection in a colony

The first result, and the repo's name: many copies of a 60-part machine, each supplied plates, power and robots, competing for time.

Two colonies of self-copying machines grow side by side on a 15 by 15 grid. Left, where the orange lineage pays a cost, blue machines spread until they hold 61% of the grid; right, where the orange lineage costs nothing extra, blue ends at 38%.

Blue: the light lineage. Orange: heavy (left) or its cost-free twin (right). Both colonies start from two orange founders beside the centre; blue arises only by mutation. Founders placed west and south of the centre: of the ten founder placements, the one whose two colonies lie nearest their arms' medians (0.612 against 0.592, and 0.379 against 0.406). Watch every run in the browser.

How the colony works

  • The engine: a universal assembler. One crafter makes whatever its target needs, deepest ingredient first, steered by a stack of assemblers that never craft: each only reads its recipe's ingredients, one per depth. Within 2 crafts of the minimum for any target to its depth (5 electronic circuits in 14 crafts, minimum 13).
  • A machine makes its own kit. All 60 parts it is built from, from plates, by recursion (596 seconds of recipe time a kit). It gives the whole kit to the logistic network, and construction robots build its child from it.
  • The machine decides when and where. It raises a request when its kit is whole, and names a direction; a free site one step away gets the seed. This placing is the one scripted act: no trigger in the game's prototype data creates a building or a ghost, so in vanilla only a player lays a blueprint.
  • A census stops it. Each machine's radar adds one to a count every radar shares; at the quorum it stops making kits.
  • Heredity and mutation. A child takes its parent's blueprint, except when the parent's clock stands at a multiple of 7 as it lays (about 1 in 7): then the other lineage's.
  • A cost selection can act on. The heavy lineage carries 24 idle parts (84 against 60). Its kit takes 1.50 times as long, and so does its generation: 214,890 against 143,460 ticks.

The machines' blueprints are in blueprints/: light, heavy, the twin and greedy. Each needs its site's supplies (power, a roboport with robots, plates in storage) to run.

Results

Twenty colonies of 224 machines, each founded by two machines of the orange lineage beside the centre, ten founder placements, the same ten in both arms. The arms differ only in the orange lineage's cost: heavy carries 24 idle parts (its kit and generation 1.50 times light's); the twin carries none.

arm runs light's share, mean least most grid full at (median tick) mutant births
selection: light vs heavy 10 0.587 0.504 0.665 2,626,830 14.6%
neutral control: light vs twin 10 0.380 0.237 0.496 2,263,950 13.8%

Registered before the runs: light's share larger with selection (p under 0.05); the means inside 0.42–0.64 and 0.30–0.52; every control colony full between 1.9 and 2.5 million ticks, the selection colonies later; mutant births 8–25%. All four held. Without an edge, drift at the growing front spreads the control from 0.237 to 0.496; with it, every colony is pulled the same way. Every run, with each machine's parent and birth tick: the viewer.

What it does not show: plates and power are supplied at every site, so the machines compete for time, not matter; one mutation rate (about 1 in 7); a colony stopped at 224 by its census. The robots build whichever ghost waits, so a lineage could in principle take another's parts; it did not here: every child was built within 5,460 ticks of its seed (a generation is about 143,000), since a parent lays its seed only when its own kit is whole.

The environment picks the winner. A second lineage, greedy, carries a second requester for each kind of plate (68 parts; its kit 1.13 times light's). The logistic network divides a short kind evenly among open requests, so greedy takes two turns where light takes one. Where plates are plenty, the cheaper kit leads: light 8, greedy 7 when the census stops the colony at 15, each light generation 12.5% shorter. Where plates trickle in at one every 70 ticks, greedy leads, 8 to 5. Same machines, opposite winners.

supply light greedy greedy's generation over light's
plenty (a pool of 40 kits) 8 7 1.14
trickle (one plate each 70 ticks) 5 8 1.26

Both runs of each supply, founders swapped, gave the same counts. All four registered predictions held, on runs repeated after a build fault the first runs exposed (a second requester that never stopped filling the first), fixed before the re-run with the prediction unchanged.

The lab's record

Every experiment's prediction is committed before its first run, then graded against it. Of 692 graded predictions across the lab's 175 graded experiments (2026-09-25 to 11-16), 557 held, 118 failed and 17 held in part; 78 experiments had at least one prediction fail. Failures stay in the record, which stays private; each prediction cited here is identified by the SHA-256 of the file as committed, before its result was, and its text is available on request:

experiment what it predicted SHA-256
e143 selection against its control be815e77611c0b77ea83cd80c312d8512dafc9539b17ef7b1d6d48c6d4b49c6b
e144 the supply picks the winner 885bebc302f3ab75d2e2e9bc7061e3d826341da85a24bc5d775f5a4cde789ea9
e142 the kit's size as a cost in generations 4a3d35fcd9e9011c230d610877431db7fd42d5fefc8e34e13986c0369002600b
e141 the lineage as a gene that mutates 4a2481b633087b9de9e2769939ac2e9e3f91ae1dc942a56bd47d7b594f8451bc
e135 where a ghost can come from with no player 800e4536d35c0e97a157c84bed5fb98d915ee2cd5f9cfdc7d276dbc4cb5c729f
e160 a second generation, by the child alone ae9f23017b548745925a8ba37ce0e377ada2340da9f85cdf6cf4f967e497592d
e161 the child's own two robots, read c49374919360eb9289042e29a77465a857f67e3f9c8cbfbb9ebf2786e22c6267
e177 from land and sun, the copy laid whole 9a4ba7204dfb32a5943c168ebb7093b4a7564e1903b032308e1556b0ce41780b
e178 why the film differs from the graded run 797a6bfabf654a78bf2c9cb51837d3d51264d8ca2c79e55fa5678a17f5d33fe9

The count is record/scoreboard.txt.

FAQ

Why Factorio?

A personal project can't run a wet lab. Factorio is deterministic (the same save gives the same run, tick for tick), runs headless at thousands of ticks a second, and its rules are fixed and readable from its prototype data. Its circuit network, logistic robots and assemblers are enough to build a machine that makes its own parts.

Is this vanilla?

The machines are base-game Factorio 2.1 entities only. A small harness mod does three things: it builds the world, records what happens, and places a machine's blueprint as ghosts at the site the machine names when the machine asks. Robots then build the ghosts from the parent's kit. Plates and power are supplied at every site.

Can Factorio self-replicate without mods?

Everything except placing the blueprint. A scan of the game's prototypes found nothing that lays a building or a ghost without a player; ghosts appear only where an entity died (e135). So the one scripted act is the placing, and it happens only when the machine's own circuit asks.

How does mutation work?

Each machine has a clock. When it asks for a child, the child gets the parent's blueprint, unless the clock stands at a multiple of 7 at that moment: then the child gets the other lineage's. About 1 birth in 7 is a mutation, in either direction (14.6% and 13.8% of births in the two arms).

How is this different from GreyGoo or Recursive Blueprints?

GreyGoo Mk I (2017) grows one factory that places mining stations, hauls ore by train and lays solar fields, using the Recursive Blueprints mod, whose Blueprint Deployer builds a blueprint when the circuit network signals it (supported up to Factorio 1.1). Here many copies of one machine each make every part of their own child from plates, decide when and where the child goes, and stop at a census; two lineages of them compete, and selection is measured against a control.

Is anything here new?

Parts of it are known. Recursive assemblers with one reader per recipe depth have been posted since 2024, and a vanilla Space Age base that makes all its own machines was shown in 2026, placed by hand. What we did not find before this: a colony of machines that copy themselves, grown on a grid and stopped by its own census, with heritable variation and selection measured against a control. Searched again 2026-09-30 (the forum, Reddit, arXiv): self-replicating factories are an old goal of the game's players (a 2016 forum thread calls them "one of the Reasons, why Factorio exists"), with no lineages or selection. Mutants spreading in sectors of an expanding colony are known from simulations of self-replicating colloids (2016), and the colonies here grow the same way.

Can a Factorio factory build a copy of itself from raw resources, without mods?

Everything but the placing: the land-and-sun machine mines ore with its own electric drills, smelts it in its own steel furnaces, pumps crude oil and water, refines oil into plastic, sulfuric acid, batteries and lubricant, and makes every one of its 334 parts and two robots in one assembler; its robots build the copy. The copy's ghost is laid by the harness, once, when the machine's circuit says the kit is complete (e177, Factorio 2.1.24).

What powers it?

Its own 32 solar panels and 27 accumulators, made by it and part of the kit; no energy interface anywhere. The copy is on its own electric grid from its first panel (the grids read every window, never the same); its watched accumulator never fell under 1,635 kJ after the parent was deleted (e177).

What is given, then?

The land, prepared: small ore patches laid under each drill, an oil spot under the pumpjack, a pond under each offshore pump, the same for the copy's site, and no biters. The first machine (the seed). The placing of the copy's blueprint. Nothing in its chests.

How does it know the kit is complete?

A constant combinator holds the kit (334 parts and 2 robots); the stock (every chest, the crafter, the robots in the roboport) is subtracted; one decider outputs a signal while nothing on that difference is positive. Laying the copy only then made a generation faster than laying its ghost at the start (818,200 against 989,000 ticks): with the ghost standing, robots took each part as it was made and the crafter made it again.

How does it differ from Self-Expanding Blueprints, Proliferation, the Fulgora base or TAFK?

Self-Expanding Blueprints (a 2.1 mod, 2026) places copies of a player's blueprint "whole or not at all" once the network holds their cost, from parts the player's factory makes. Proliferation (a mod) adds a machine faction with its own entities. mmarss256's Fulgora starter base (2026) is vanilla Space Age and makes all its machines from scrap, placed by hand. TAFK, on the Factorio forum, is a self-unpacking factory kit that used a mod for oil. Here one base-game assembler makes every part from ore, oil, water and sunlight, and the harness lays only the copy's ghost.

Reproduce

The land-and-sun run and the colony's two results each ship as a kit in reproduce/: the experiment's variants (world, machines and blueprints, one JSON each), its analysis, the expected table, the graded run's output to compare against, and the harness cut to what it needs.

The land-and-sun machine, on Factorio 2.1.24, base game:

cd reproduce/e177-whole-child
python3 reproduce.py --factorio /path/to/factorio --data /path/to/factorio/data

One headless run of 1,600,000 ticks, about 4 minutes on an Apple Silicon Mac; it grades the run and exits 0 when the table matches the graded one. A quick check, every row of the first 100,000 ticks against the graded run's (about 20 seconds):

python3 reproduce.py --quick gen 100000 --factorio /path/to/factorio --data /path/to/factorio/data

The colony's selection experiment, graded on Factorio 2.1.20:

cd reproduce/e143-selection
python3 reproduce.py --factorio /path/to/factorio --data /path/to/factorio/data

Twenty headless runs of 3,500,000 ticks, about 25 minutes each on an Apple Silicon Mac; it grades them and exits 0 when the table matches the graded one. A quick check of one run's first 200,000 ticks against the graded run's growth events:

python3 reproduce.py --quick sel-ws 200000 --factorio /path/to/factorio --data /path/to/factorio/data

The defaults are Steam's paths on macOS. reproduce/e144-greedy works the same way (four runs of 800,000 ticks).

Sources

Cite

See CITATION.cff. MIT licence (LICENSE).

About

Self-copying machines from base-game Factorio 2.1 parts: natural selection in a colony, and one assembler that makes all 334 parts of its factory from ore, oil, water and sunlight (only the blueprint's placing is scripted)

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages