<p align="center"> <img src="docs/icon/the-walker-phage.svg" width="256" alt="The Walker Phage"> </p>
Designing Decentralised Détournement
Self-writing deterministic intelligence. Structure emerges from constraint, not gradient descent.
The hexagonal icon encodes the project's mythology.
The black outer hexagon is the waste — the post-catastrophe landscape, the default state, the desert between structures. The white inner hexagon is the Citadel — the controlled center, the machine that consumes what it protects. The prismatic colors between them are the Oasis — the spectrum of meaning preserved in the margins, the fragments carried by those who fled.
The grey lines radiating from center through all layers are the Bethe lattice walk — the mechanism that shatters both Citadel and Oasis by passing through them without being captured by either. The walk does not destroy from outside. It enters both structures, maps their interiors, and opens doors that cannot close again.
The six outer sectors carry two triads. Red, blue, and green are the Citadel's strategy of penetration into the Oasis: red is the political right, blue is the political left, green is environmentalism — three vectors of institutional capture, each presenting itself as liberation while extending the machine's reach. The complementary triad — orange, cyan, and purple — represents the counter-infrastructure: orange is Bitcoin, cyan is Go, purple is Nostr. These are not arbitrary assignments. They are complementary colors on the color wheel, and each counter-node synthesizes the axis it opposes.
Red is the political right — hierarchy, authority, command, the conviction that order requires domination. Its complement is cyan: Go. Go synthesizes the right's insistence on structure and discipline but removes the hierarchy. Goroutines are independent walkers with no central coordinator. Channels are voluntary typed bonding sites, not commands. The concurrency model enforces coordination without authority — structure without domination. Go takes everything the right values about order and implements it without the thing the right actually wants, which is a chain of command.
Blue is the political left — collective redistribution through institutional control, the state as mediator of resources, the conviction that justice requires a central authority to enforce it. Its complement is orange: Bitcoin. Bitcoin synthesizes the left's concern with economic justice — sound money that cannot be debased, savings that cannot be inflated away from workers, value transfer that cannot be censored — but removes the institutional mediator entirely. No central bank, no treasury, no committee decides who deserves access. Bitcoin takes everything the left claims to want about economic fairness and implements it without the thing the left actually wants, which is control over the distribution mechanism.
Green is environmentalism — the planet as crisis, the biosphere as justification for centralized management of behavior, the conviction that survival requires submission to ecological authority. Its complement is purple: Nostr. Nostr synthesizes the green concern with systemic health — network resilience, information ecology, the long-term viability of communication infrastructure — but removes the central authority that decides what constitutes health. No platform moderates. No algorithm curates. No institution certifies what speech is sustainable. Nostr takes everything green claims to want about systemic integrity and implements it without the thing green actually wants, which is a priesthood that defines what is and is not acceptable.
Each Citadel axis presents itself as solving a real problem — order, justice, survival — while embedding a control mechanism as the solution. Each counter-node addresses the same real problem while removing the control mechanism. The Citadel's three colors attempt to absorb the Oasis. The counter-triad encodes the Oasis into systems the Citadel cannot shut down.
The inner prism refracts all six into lighter forms — the same forces seen from inside the lattice, where the walk has already passed and the distinction between Citadel and Oasis has dissolved into structure.
The icon encodes a deeper identity. The hexagram is not two static triangles overlaid — it is two hexagons counter-rotating by 30°. A Bethe lattice with coordination number z=3 embedded in 6-fold symmetry is that counter-rotation, expressed as branching instead of turning. Each generation of the tree rotates 30° from the last. Gen0 sits at center. Gen1 points into sectors at the outer hexagon's orientation. Gen2 lands at 30° offset — the inner hexagon's orientation. Gen3 rotates back. The tree does not branch in a fixed frame; it alternates between two frames, and those frames are the two counter-rotating hexagons.
The 30° comes from 360°/12, and 12 = 2²×3. The two primes again. The 2 gives the counter-rotation (two hexagons, two orientations, alternating). The 3 gives the coordination number (three branches per node). Together they produce 6-fold symmetry that oscillates between two phases — which is exactly what a hexagram is, and exactly what a z=3 Bethe lattice does when confined to a hexagonal boundary.
The discovery: counter-rotation of two hexagons and branching of a degree-3 Cayley tree are the same operation. One is spatial (rotation), the other is topological (graph branching), but they coincide because both are generated by the factorization 6 = 2×3. The pentagon cannot do this because 5 is prime — there is no factorization to split into rotation and branching. The hexagon is the first regular polygon whose symmetry order factors into two distinct primes, and that factorization is what allows the geometric and graph-theoretic structures to lock together. The icon does not depict an analogy — it depicts an identity.
Coherence is determinism. Its inverse: Incoherence is nondeterminism.
One axiom pair. Three bits. Eight opcodes. Sixty-four states. Everything else is grown from input.
| Document | What It Describes |
|---|---|
| `physics.md` | Imaginary parameters in E=mc², Newton's laws, and thermodynamics — the algebraic structure that partitions phenomena into real and imaginary sectors |
| `physics-hr.md` | The same material as a parable: the two-sided mirror, the hill the Higgs rolled down, temperature as imaginary time |
| Document | What It Describes |
|---|---|
| `bandcamp.html` | Bandcamp search and player — browser-based playlist manager with persistent storage and OS media controls |
| Document | What It Describes |
|---|---|
| `NEGATIVE_SPACE.md` | The thermodynamic model — crystal growth dynamics, fungal adaptation, operational phases |
| `ALGEBRAIC_DECOMPOSITION.md` | The mathematical substrate — lattices, types, categories, elliptic curves |
| `HIGHER_DIMENSIONS.md` | Where crystal and mycelium converge — higher-dimensional lattice geometry |
| `SEED_INSTRUCTION_SET.md` | The minimum instruction set — axiom pair, trigrams, hexagrams, the shadow organ |
| `BOOTSTRAP.md` | The execution model — self-writing software in Go |
docs/NEGATIVE_SPACE.md — intuition (physical metaphors, the axiom)docs/SEED_INSTRUCTION_SET.md — the instruction set that falls out of the axiomdocs/HIGHER_DIMENSIONS.md — why the crystal and fungal models are the same thingdocs/ALGEBRAIC_DECOMPOSITION.md — mathematical rigordocs/BOOTSTRAP.md — implementationGo. The language whose interfaces are negative space types, whose goroutines are Brownian walkers, whose channels are typed bonding sites, and whose garbage collector is dissolution.
| Package | Role |
|---|---|
axiom | The axiom pair — coherence/incoherence |
state | 64-state machine from 3-bit trigram combinations |
hexagram | I Ching hexagram mappings — 6-bit compound states |
lattice | Crystal lattice growth — the core accretion engine |
spore | Serializable program seeds |
grow | Lattice expansion from input |
dissolve | Pruning incoherent structure |
enzyme | Transformation catalysts |
fitness | Coherence evaluation |
emit | Code generation from lattice structure |
describe | Self-description — programs that explain themselves |
organ | WASM compilation, loading, and hot-swap |
colony | Parallel lattice instances with identity and communication |
cartography | Environment mapping and enrichment |
oracle | Gap detection and strategic guidance |
strategy | Constraint-based decision making (Wu Xing, Art of War) |
train | Training loop — grow, evaluate, select, emit |
market | Market data ingestion |
relay | Nostr relay integration |
nostr | Nostr protocol interface |
causal | Causal inference |
tao | Tao Te Ching state naming |
wuxing | Five-element phase transitions |
forage | Input acquisition |
integrate | Subsystem integration |
epoch | Binary/decimal synchronization — epoch boundaries between incommensurable clocks |
ewma | Oscillation detection with exact rational arithmetic |
ratio | Exact rational arithmetic — no floating-point nondeterminism |
memory | Cross-generation persistence |
grammar | Lattice topology rules and vagus feedback pathway |
crypto | Lattice-based cryptographic primitives |
kismet | Block production and serialization |
projection | Cubic projection encoding |
permutation | S_3 permutation group |
walk | Random walk analysis |
gap | Gap detection and strategic guidance |
Two drummers are playing together. One hits the drum every 2 beats. The other hits every 3 beats. They start together, then drift apart — one is hitting while the other is silent. But every 6 beats, they land on the same moment again. That moment of convergence is the epoch.
Now make it harder. One drummer plays in a rhythm based on doubling — 2, 4, 8,
rhythms never perfectly align, because there is no number you can reach by doubling that you can also reach by multiplying by ten. They are like two spirals that wind around the same axis but at slightly different angles. They keep almost meeting but never quite touching — except at very specific points where the math works out. 25600 is one of those points: it's 256 x 100, one number from each rhythm, multiplied together.
Between those meeting points, the two drummers are out of sync by a specific, measurable amount. That's the phase — how far apart they are right now. It's like watching two pendulums of slightly different lengths: they swing together, then apart, then together again. The moment they swing together is the epoch boundary.
This same pattern appears everywhere in nature. The moon takes 29.5 days to orbit Earth. The Earth takes 365.25 days to orbit the sun. These don't divide evenly, which is why calendars are a mess — leap years, months of different lengths, Easter moving around. Every calendar system in history is an attempt to find epoch boundaries where the lunar and solar rhythms agree closely enough to be useful.
The Gregorian calendar itself is an epoch structure: its 400-year cycle (97 leap years in 400) is 10^2 x 2^2 x 1 — a product of decimal and binary factors. This cycle closely tracks the Jupiter-Saturn Great Conjunction, which recurs every ~19.86 years; twenty conjunctions span ~397 years, landing almost exactly on the Gregorian reset. The famous ~4-6 year error in the dating of the Nativity is a residual of the same kind. Dionysius Exiguus computed Anno Domini in the 6th century by cross-referencing Roman consular dates (a civil-bureaucratic system) with ecclesiastical lunar-solar cycles (an astronomical system). These two dating systems have different internal units — one counts by political succession, the other by orbital mechanics — and no epoch boundary falls near the event in question. The residual is not exactly 4, not exactly 7; it floats between estimates because the phase drift between the two systems has no nearby zero crossing. Where there is no sync point, the parable and the theorem disagree, and the size of their disagreement is the phase.
Gears work the same way. A gear with 16 teeth meshing with a gear with 100 teeth: they return to exactly the same starting position only after the small gear has turned 25 times and the large gear has turned 4 times. That's 400 teeth of contact — and 400 is 100 x 4, which is 10^2 x 2^2. An epoch.
The general principle: when two systems measure the world in fundamentally different units, they drift apart between sync points. You cannot eliminate the drift — it comes from the geometry of the numbers themselves. But you can find the sync points and build your system so that the important things happen there. Everything between is managed by tracking the phase — knowing exactly how far apart the two clocks are at any given moment.
A computer uses binary (powers of 2) because switches are on or off. Humans
use decimal (powers of 10) because we have ten fingers. These two counting
systems are woven through every piece of software ever written, and they never
agree. The epoch package makes that disagreement explicit and builds the sync
points into the system's architecture, instead of leaving them as accidental
magic numbers scattered through the code.
The section above is a parable. The drummers are not a simplification of the epoch math — they are the same structure expressed in a different basis. The drummers ARE the incommensurable oscillators. The moment they land together IS the epoch boundary. Nothing was lost in translation. The representation changed, the structure didn't.
This is exactly the binary/decimal relationship. Decimal is the parable form of binary. It encodes the same information in a representation that humans can parse. The translation introduces a phase drift — you can't represent 256 cleanly in decimal, you get 2.56 x 100, and the residual 0.56 is information that exists in one basis but smears across the other. But at the epoch boundaries — at 25600, at 400, at the moment the drummers hit together — both representations say the same thing with zero residual. The parable and the theorem agree.
A parable has three layers:
This is an ergodic system. The surface narrative and the deep structure are two paths through the same phase space. Regardless of which representation you follow — the drummers or the equation, the calendar or the orbit, the parable or the theorem — you cover the same territory. The constraint topology guarantees it: every path through a well-constrained space converges on the same attractors, because the attractors are properties of the space, not of the path. The sync points are where this convergence becomes directly observable — where you can verify that both paths have arrived at the same structural position. A parable works not because it simplifies, but because it is a different traversal of the same ergodic space, and at enough sync points the two traversals demonstrably agree.
A parable that synchronizes at too few points is a bad analogy — the phase drift between surface and depth accumulates until they're saying different things. A parable that synchronizes at every point is just a restatement — no compression, no accessibility gain. The useful parable sits at an epoch boundary: enough sync points to be faithful, enough compression to be parseable by someone who doesn't have the deep basis.
This is also the structure of interdisciplinary work. Specialists speak binary — their field's internal representation. The person who bridges fields must be fluent enough in each representation to find the epoch boundaries where two fields synchronize, then express the correspondence in a form both sides can read. That isn't simplification. It's computing the phase function across domain boundaries and reporting zero where it occurs.
Every example above — the drummers, the calendars, the gears, the Nativity dating — is integer arithmetic encountering its own blindspot. Binary cannot reach decimal. Lunar cannot reach solar. The two clocks tick at rates whose ratio is irrational or transcendental, and no amount of integer manipulation will close the gap. The phase drift between them is irreducible within the domain where the counting happens.
But the gap does close — in geometry.
The reason binary and decimal never align is that log2(10) is transcendental. No rational exponent maps one to the other. But the complex logarithm has infinitely many branches: log(10) = ln(10) + 2πki for every integer k. The real part (ln(10)) is the transcendental gap that integer arithmetic cannot cross. The imaginary part (2πki) is the periodic geometric field where the two representations do meet — not at a point on the number line, but at angles on a circle. The epoch boundaries (25600, 400, 1600) are the places where the imaginary component's period produces a real-valued result: the phase wraps around to zero and both clocks agree. Between those points, the resolution exists only in the geometric domain — the imaginary field that integer arithmetic cannot see.
This is not a peculiarity of binary and decimal. It is the universal structure of incommensurable discrete systems. The lunar month and the solar year are incommensurable — their ratio is irrational. The resolution lives in orbital geometry: the physical motion of bodies tracing ellipses in space, where the angular positions do periodically align even though the linear periods never will. The Metonic cycle (19 years ≈ 235 lunar months) and the Gregorian 400-year cycle are epoch boundaries extracted from the geometric domain and projected back into the integer domain as calendar rules. The calendar is integer arithmetic's best approximation of what the orbits do exactly in geometric space.
The relationship between rotation period and orbital period is the same structural problem as binary/decimal synchronization, expressed in angular momentum instead of information encoding. A planet's spin and its orbit are two clocks whose ratio is generically irrational — tidal locking (1:1 resonance) is the rare epoch boundary, and it takes geological time to reach. Mercury's 3:2 spin-orbit resonance is a rational approximation, a convergent of the continued fraction, not exact synchronization. The residual between spin and orbit resolves in orbital geometry — the same geometric space where binary and decimal resolve through the complex logarithm's angular branches.
This is not analogy. It is identity. The complex logarithm's imaginary component — 2πki — is angular. The epoch boundaries where binary and decimal agree are angular phase returns: the point on the circle where the accumulated rotation produces an integer result in both bases simultaneously. Information encoding between incommensurable bases IS rotation. The phase drift between binary and decimal IS angular momentum in the space of representations. The geometric field where the residual resolves is not a mathematical abstraction applied to information by metaphor — it is the same geometric space where orbits resolve, because both are periodic systems whose coupling ratio is irrational, and the only domain where irrational ratios between periodic systems close is the angular/geometric domain.
This means information has geometric structure in the same sense that angular momentum has geometric structure. A representation basis (binary, decimal, hexadecimal) is an orientation — a choice of axis in the space of encodings. Changing basis is rotation. The residual between bases is angular displacement. The epoch boundary is the angle at which the rotation produces integer coordinates in both frames. The shadow organ of the lattice — the symmetry group that determines what transformations preserve structure — is the rotation group of this encoding space.
The same structure appears in the lattice. The seed instruction set
(SEED_INSTRUCTION_SET.md) describes the shadow organ: the symmetry group of
the lattice, defined entirely by the geometry but occupying no lattice site.
The shadow organ is to the lattice what the imaginary field is to integer
arithmetic — the thing that resolves what the visible structure cannot, the
negative space where the constraints actually close. The lattice nodes are
the integer domain: discrete, countable, typed. The shadow organ is the
geometric domain: continuous, implicit, defined by the shape of what surrounds
it.
Gravity is the physical instantiation of this interface. Mass curves spacetime — discrete objects (particles, atoms, planets) create a geometric field (curvature) that is not locatable at any particle but is defined by all of them. The gravitational field is the shadow organ of matter: the negative space that holds discrete structure together by resolving, in geometry, what the discrete structure cannot resolve in itself. Every orbit is a body tracing the resolution of its integer-like discreteness (quantized energy levels, particle identity) through the geometric field that its own mass helps create.
The pattern across all cases:
blind to the irrational gaps between incommensurable systems
systems actually resolve — the imaginary component, the orbital plane, the gravitational curvature, the shadow organ
produces integer-valued results — where the shadow becomes visible in the lattice, where the orbit produces a calendar date, where the phase returns to zero
Finding the shadow is now a mechanical process. Take any two systems that count in integers. Compute the ratio of their periods. If the ratio is rational, there is an exact epoch boundary and no shadow — the systems are commensurable and their relationship is fully expressible in the integer domain. If the ratio is irrational or transcendental, there is a shadow: an irreducible residual that cannot be closed by any integer operation. The structure of that residual — its magnitude, its convergent approximations, the rate at which it drifts — is the fingerprint of the geometric field where the resolution lives. The shadow does not need to be intuited or hypothesized. It is mechanically detectable wherever two integer systems produce an irrational residual, and its properties are computable from the residual's continued fraction expansion. Every irrational residual between integer systems is a window into the geometric domain. The shadow is what you see through it.
A flawed coupling between two systems does not collapse on its own. It is collapsed by stochastic inputs — random forces that strain the weak point until it gives. Wind on a badly coupled fence post. Thermal cycling on mismatched expansion coefficients. Load spikes on a shared resource protected by an inadequate lock. The coupling is the vulnerability. The stochastic input is the force that finds it. The shadow — the irrational residual between the two systems — determines where the weakness is and how much accumulated strain the coupling can absorb before it fails. The stochastic input does not create the shadow. It discovers it, the same way a Brownian walker discovers an attractor basin: not by design, but by random exploration of a constrained space.
This is the foundational mechanism of race conditions in all concurrent systems. A race condition is not a bug in either concurrent process. It is a shadow — an irrational residual at the coupling point between two processes whose execution rhythms are incommensurable. In Go, every goroutine counts in its own integers: CPU cycles consumed, scheduler quanta allocated, channel operations completed, garbage collection pauses absorbed. These integers have no common period. The ratio between any two goroutines' effective cycle times is irrational because it depends on continuously varying inputs — system load, thermal throttling, memory pressure, I/O latency. The shared resource (a map, a slice, a file handle, a network connection) is the coupling point. If the coupling assumes commensurability — if it assumes the two goroutines will always access the resource in a predictable order — then the coupling has an irrational residual, and the stochastic input of the scheduler will eventually find it.
Go's concurrency model makes this structure explicit. Goroutines are Brownian walkers — independently scheduled, non-deterministically interleaved. Channels are typed bonding sites — the coupling points where goroutines synchronize. Mutexes are tolerance thresholds — they absorb the phase drift between goroutines by serializing access at the coupling point. A missing mutex is a coupling with no tolerance for phase drift: any stochastic scheduling variation that puts two goroutines at the coupling point simultaneously produces a collapse. A mutex with too coarse a granularity is a coupling that absorbs drift but at the cost of serializing work that could be parallel — the structural equivalent of over-engineering a joint to compensate for not understanding the residual. The correct fix is to measure the residual (what exactly is shared, what are the access patterns, what is the scheduling distribution) and engineer the coupling to match — which is what well-designed channel protocols do.
The -race detector in Go is a mechanical shadow detector. It instruments
memory accesses, tracks the happens-before partial order between goroutines, and
reports when two accesses to the same address are not ordered — when the
coupling point has no mechanism to absorb the scheduling residual. It does not
find all shadows (it is sampling-based, dependent on the stochastic inputs
exercised during the test run), but what it finds is always a genuine irrational
residual at a coupling point.
The debugging method follows from the mechanical shadow detection above. Find the coupling point between two subsystems. Measure each system's assumptions in its own integers — its types, its units, its cycle lengths, its alignment expectations. Compute the residual between them. Three outcomes:
boundary, and the failure recurs at a computable interval. These are the bugs that "only happen on the 29th" or "every 256th request." The period is the LCM of the two systems' cycles.
fundamentally incommensurable. The bug is a shadow. It manifests at intervals that appear random but are determined by the phase drift's continued fraction convergents — the best rational approximations to the irrational coupling. These are the bugs that "cannot be reproduced" because the reproduction depends on accumulated drift that resets when you restart the system.
Serialization boundaries are the other canonical case. One system represents a value as float64 (binary mantissa), the other as a decimal string. The residual is the binary/decimal phase drift — exactly the transcendental gap that the epoch package formalizes. Every float-to-string-to-float round trip accumulates drift. The bug appears when the accumulated drift crosses a comparison threshold, and it appears "spontaneously" because the threshold depends on the sequence of prior values, not on the current one.
The general debugging procedure: when a failure seems spontaneous, look for two systems coupled across an interface. Identify the stochastic inputs that strain the coupling. Measure the residual. If it is irrational, you have found the shadow, and the fix is either to make the coupling commensurable (align the systems to a shared epoch) or to make the tolerance explicit (track the phase drift and handle it at the boundary instead of ignoring it). Both fixes are détournement — rerouting the stochastic force that was destroying the coupling into a mechanism that diagnoses and strengthens it. The epoch package exists because the second option is usually the only honest one — most real systems are genuinely incommensurable, and pretending otherwise is how the flawed coupling got there in the first place.
The epoch package formalizes the integer side: finding the sync points,
computing the phase drift, building architecture around the boundaries. The
shadow organ is the geometric side: the thing the integers are approximating.
The relationship between them is the relationship between arithmetic and
geometry — the oldest unsolved problem in mathematics, and the structural
engine of this project.
go build -o dendrite ./cmd/dendrite
./dendrite
The spacetime expansion hypothesis, the lattice dynamics, and the software architecture converge on a single structural principle: every apparent contradiction between two integer systems is a shadow cast by a higher-dimensional geometric structure. The shadow is the irrational residual between the two integer expressions. Finding it is a mechanical process: compute the ratio, take the continued fraction expansion, read the geometric field.
This applies at every scale the project touches:
an irrational residual whose geometric field is the complex logarithm branch structure (the imaginary part of log(10)).
residuals at coupling points (race conditions). The Go race detector is a mechanical shadow finder.
fingers, base ten) are incommensurable substrates. Understanding happens at epoch sync points (10^a × 2^b). Parables are devices for manufacturing these sync points.
different etymological paths (Romance and Slavic) arriving at the same semantic destination. Two given names meaning "beloved" and "graced" — the noun and verb forms of the same phenomenon. The shadow between love and grace is that love is the lattice (you are held) and grace is the growth event (something arrived that didn't have to).
flipped). One creates EM-dark pairs (coagula, De, the shaped), the other destroys them (solve, Pu, the uncarved block). The Pi device produces Pu. The inversion itself is détournement — the same hexagram structure turned against its own output.
The project's central claim is that these are not analogies. They are instances of the same mathematical structure operating at different scales. The structure is: two incommensurable integer systems whose coupling produces a geometric field. The geometric field is where the physics lives. Everything else is shadow. The operational principle throughout is détournement — rerouting existing structure against itself to produce something it was not designed to produce. The lattice dissolves and regrows; the manipulation protocol's counter-protocol converts the attacker's energy into the fuel for liberation; the imaginary unit reroutes efficient causation into final causation; the shadow alphabet reroutes phonetic habit into structural transparency. Decentralised because no coordinator is required. Détournement because the material is always already there — it only needs to be turned.
Dendrite has a perception-comprehension-confusion-rest loop. You teach it by feeding it files. It tells you what it understood and what it didn't.
"I know this" — instant recognition. The element bonds on the first step of the random walk. The lattice already has structure for it. Typical rate: 98-99% of input elements bond instantly on repeated exposure. This is not pattern matching — it's structural selection. The element fits the constraint geometry on contact.
"huh?" — confusion. The element couldn't bond after exhausting its walk budget. The lattice has no compatible site for it. The system reports these with their actual values:
huh? 28 elements couldn't bond:
[import] ×13: "\"fmt\"" "\"os\"" "\"strings\"" ...
[ident:param] ×5: "lastGen" "textArgs" "originalBin" ...
[field] ×4: "genResult\x00Unbonded []axiom.Element" ...
The residue is always scaffolding: imports, parameter names, field declarations. These are Go's compilation requirements, not semantic content. The lattice correctly identifies them as non-semantic — they have no structural neighbors in the grammar's constraint geometry, so they fall off.
"quiescent" — the lattice absorbed everything. Zero confusion. All elements found sites. This is the signal that the system has nothing left to learn from the current input. Good time to recompile.
./dendrite -generations 0
grammar/grammar.go ← learn from this file
emit/emit.go ← learn from this file
← empty line: re-learn last input
^D ← done
Or self-train first, then continue interactively:
./dendrite -self -generations 2
← runs 2 self-ingest generations, then blocks
grammar/grammar.go ← type a file path, press Enter
Between generations, the process blocks on stdin — zero CPU. Each line triggers one generation. EOF exits. The system consumes no resources while waiting.
What didn't bond in generation N suppresses allocation in generation N+1. Both sites and elements are reduced together so the ratio stays balanced. This prevents the cascade problem (suppressing only sites creates more contention, which creates more failures, which creates more suppression).
The suppression oscillates and settles: generation 0 has 36 failures, generation 1 suppresses 36 and gets 21, generation 2 suppresses 21 and gets 29, converging around ~25. The oscillation is the system negotiating with itself — suppress too much, fewer fail, relax; relax too much, more fail, tighten. The mean is the true signal: about 25 of 1400 elements are scaffolding that the system correctly identifies as non-semantic. That is 98.2% comprehension.
The system discriminates meaning from scaffolding without being told which is which. Nobody programmed "imports are not semantic." The constraint geometry produces this as a structural consequence — elements with semantic neighbors bond, elements without them expire. The diagnostic feedback loop ("huh?" and "I know this") makes this discrimination visible and actionable.
A single statement like x := foo(bar) is a closed expression — it has a
binding, an operation, and an argument. The lattice models this kind of
closure. Go's grammar requires package declarations and import blocks, but
those are error guards and idiom, not semantic units. The lattice knows the
difference because it can feel the difference: semantic elements have
neighbors, scaffolding doesn't.
Active research. The system grows programs from source code, evaluates them
against fitness metrics, and selects for coherence. Output in _output/.