Platonik

Browser prototype guide, 11 September 2026. The experiments described here are implemented on the website. The Rust game, agent skills, rankings, and shared world remain a proposal. These small models are for testing a design direction, not evidence that the larger ecology works.

Put a specimen on the bench

Open the observatory. No account, installation, credentials, or paid compute is needed.

Choose Moth, Moss, or Reed. The bench executes its program for 256 ticks in the selected maze and reports deliveries and modeled work.
Compare Form with Journey. The portrait encodes rules and memory; the journey comes from the actual execution trace. Play or scrub the recorded run.
Choose Grow a variation. One rule changes, and the new program runs on the same map. The immediate parent remains available for a matched comparison and restoration. A variation can make things worse.
Change the map seed. Several successful examples are more informative than one favorite result; none is an independent research evaluation.
Name and Keep specimen to save the current program and map seed in this browser's drawer. The drawer holds twelve distinct canonical programs. Loading a saved entry runs it again; removing it changes only this browser's collection.

The portrait is a lossy visualization: lobes encode rules, grains encode conditions, rings encode used memory slots, and memory-writing rules shift the tint. Directional choices alter lobe reach. Unused rules can affect appearance, so beauty is never a fitness score or a guarantee of novelty. Different programs can share a portrait. Collection names are labels, not claims about biological species.

Local browser data can be cleared. Export this program downloads the current JSON for safekeeping or editing by an external agent. It exports the program only; record the map seed separately to repeat a particular run. The website makes no model calls and has no shared collection or leaderboard.

Let an agent change the rules

Expand Edit or paste a program. Give the exported JSON and these rules to your agent, ask for a bounded change, and paste its result back. Apply and run validates it before replacing the program on the bench. Invalid input leaves the current specimen intact; Revert editor restores its current JSON.

The laboratory format is version: 1 with 1–24 ordered rules. Each rule has a when list of up to eight conditions and an action. Conditions are ANDed and short-circuit; the first matching rule acts once per tick. An empty condition list always matches. With no match, the courier waits. Optional remember writes one memory slot after the action, even if the action fails.

Conditions can inspect home, spark, carrying, an adjacent blocked.forward, blocked.left, blocked.right, or blocked.back sensor, the courier's heading, or a memory slot. Actions are move, turn, pickup, drop, wait, and write. Use a starter's exact object fields as a template. There are four memory slots, numbered 0–3, storing integers 0–255. Input is capped at 16 KiB and extra fields are rejected. It is a fixed interpreter, with no JavaScript evaluation, network, filesystem, or remote-map sensor in the program.

This model has one courier, a deterministic 15×11 maze, a finite source of four sparks, and home. A successful move sets the heading to the movement direction. A pickup carries one spark; a drop at home delivers it. The 256-tick cap ends the run. Rule visits, condition checks, reads, attempted actions, and state writes contribute to the explicit work ledger. Failed actions still cost work. The toy records that cost; it does not yet enforce a separate fuel allowance. Maze generation and rendering take real computer time outside that modeled ledger.

There is no beacon drain, route collapse, colony communication, or evolved body in this demonstrator. The names overlap the proposed campaign to test recognition; its measured results belong only to this model.

Explore a truth landscape

In Truth garden, choose one of two coupled systems from Patrick Grim's paper. Change the initial truth values, update order, threshold radius, and revision cap. The landscape samples 192×192 starting pairs. Each pixel records the first update after which the pair lies outside the chosen radius about the origin; paper-colored pixels have not crossed within the cap. All values remain within the truth square.

Click a point or use the x and y sliders, then choose Zoom here to inspect a smaller region. Keyboard activation of the map chooses its center. Whole square restores the full domain. Trajectory follows the selected pair, and the table exposes its first five updates. An exact repeated floating-point pair is reported when one occurs.

Truth degrees are not probabilities or confidence scores. The formulas, schedule, finite iteration cap, and JavaScript Float64 precision define this experiment. No noise is added. A detailed boundary does not prove infinite fractal structure or useful computation. The research notes explain the source and possible later signal-habitat experiments.

Price the ambition

In World budget, choose active cells, simulation ticks, average primitive work, state bytes, and trace bytes. The calculator separates policy operations, current state, and an uncompressed per-cell history. These are assumptions, not demonstrated capacities of a Rust engine.

Measure this browser runs 64 bounded 256-tick courier experiments using the specimen currently on the bench. It yields between runs, supports cancellation, and reports observed modeled work per elapsed second for that browser and program. Leaving the view cancels an unfinished sample. The rough time estimate uses that sample and excludes important whole-world costs; it cannot predict Rust throughput. Read the complexity and scale proposal before interpreting a large number as an affordable world.

Build toward the Autoverse

Open Autoverse in the observatory. This is a fourth experiment: a finite, synchronous Boolean graph named autoverse-circuit-v1. It is separate from the courier model and the proposed Rust habitat. Its drawn layout does not represent physical distance or spatial locality.

Choose a relay, NAND gate, resettable memory, four-bit adder, or sequential accumulator. The selected reference runs a fixed stimulus. Scrub Inspect signal tick to see actual node and output states.
Choose Check behavior. The relay has three finite checks, NAND has four input combinations, memory has five load/hold/reset checks, the adder has 256 input pairs including carry, and the accumulator has six reset/intermediate-total checks. Reports include failed cases, broken-wire reads, and modeled work.
Break a connection, then check again. An absent connection reads zero and records a fault. Even an accidentally correct output fails the assay if any broken wire was read. Restore reference circuit recovers the supplied design.
In Build it from an empty bench, lower the construction steps or node material, then Assemble blueprint. Inspect where the build stops. With enough resources, Check the constructed circuit evaluates the newly assembled graph against the same cases. A complete but faulty blueprint can still fail.
Export circuit and evidence saves the circuit, selected contract, fixed stimulus, demonstration, and available check and construction results. An agent can edit the circuit object. Expand Edit circuit JSON, paste it, and choose Apply circuit. Preserve the selected contract's input names; incompatible or invalid input leaves the current circuit in place. The assay also checks required outputs.

The bench resets when its tab is left. Export work before leaving; it does not use the specimen drawer or hosted storage. An exported report is a review bundle, not an independently certified result.

Signal rules and costs

Circuit JSON declares version: 1, a nodes array, and named outputs. Nodes are input, binary constant, two-input nand, or register with data, enable, and reset connections. Use the reference JSON's exact fields. Node names must be unique lowercase identifiers of at most 24 characters. Named connections must resolve to a node; null is an explicit broken connection. Unknown fields are rejected; no user JavaScript executes.

All node state starts at zero. Each tick reads the preceding tick's node values and commits the new state together. Input nodes receive the current stimulus; their neighbors see it a tick later. Registers reset to zero when reset is one, otherwise load data when enabled, otherwise retain their value. Reset wins over load. Output bindings observe the newly committed node values. Registers are supplied storage primitives; the model does not claim to evolve memory from NAND feedback.

Each node evaluation, connected or broken input-wire read, stimulus read, state write, and output read costs one modeled unit. Registers always read their three input wires. A run is capped at 128 nodes, 32 output bindings, 32 stimulus phases, 256 total ticks, and 2,000,000 work units. JSON is capped at 32 KiB. The finite schema also bounds fan-in: NAND uses two connections and a register uses three. Input/output names and canonical ordering are independent of the displayed layout.

Expand Stimulus and execution limit to read the stimulus or change the demonstration's work cap. An exhausted partial tick commits no state, but attempted work stays charged. The trace records committed ticks; total spent work can therefore exceed the work on its last frame. Behavior checks use their fixed cap per case, independently of this demonstration setting. Parsing, orchestration, diagram rendering, and trace serialization also take real computer time outside the modeled ledger.

The adder's 36 NAND gates check all 256 pairs after 32 ticks from zero state; this establishes neither every transition between pairs nor a faster settling bound. The accumulator combines that structure with five registers and externally timed load pulses. Its checked intermediate totals and carry matter: checking only its final reset would miss a broken arithmetic circuit. It has no instruction fetch/decode loop and is not a stored-program computer.

Construction is an operation, not an announcement

The assembler starts with no nodes or output bindings. It allocates nodes, copies each connected input wire, then binds outputs. Every operation or failed attempt costs one step and one work unit; each allocated node consumes one material. Steps are capped at 1,024 and node material/capacity at 128. Exhausting steps stops before the next attempt; failing an allocation consumes its attempt. Partial graphs remain available in the exported result. A supplied zero-bit constant is a Boolean value, not free physical energy or node material.

For the supplied adder, a complete build uses 45 nodes, 72 input connections, and five output bindings: 122 operations and 45 node material. Running and checking it costs additional work. This assembler is external and has privileged access to its supplied blueprint. It does not discover a design, gather resources, construct itself, or live inside the signal graph.

The Autoverse path defines those later milestones. The validation plan explains why the next decisive test is a shared transport-to-control journey, followed by real player evidence for the complete campaign.