Понятия и решения
Понятия проекта и принятые решения — с тем, что было отвергнуто.
Replace a guess with a calculation
Which version is this, what does it need, does it need rebuilding, do these conflict, what may it touch, who is affected by this flaw, are these two things the same: each is guessed today and becomes a calculation once things have stable identities.
The three mistakes, and the one beneath
Things are identified by name; versions describe whole components; boundaries are treated as walls - and beneath all three, isolation is the default and connection is work. All inherited from tape drives that read one file at a time, never designed.
Identity by what a thing is
A definition is identified by a fingerprint computed from its own contents plus the fingerprints of everything it depends on (a Merkle tree; mutually dependent groups are fingerprinted together). Names become labels pointing at fingerprints.
Structure, not text
The fingerprint is computed from the structure of the code - formatting, spacing and the names of internal variables fall away (alpha-equivalence). Two people making the same change in different styles produce the same fingerprint.
The graph is the source of truth
What is stored, hashed, compared and edited is resolved structure. Text appears once on the way in and once on the way out, at one marked boundary; nowhere between is text anything but a derived rendering.
There are no files
With every reference a fingerprint, imports have no job, and then files have none: there is a graph of definitions and links, looked at through views - slices you choose and switch between, typing ordinary code, navigating relationships instead of folders. Your layout is remembered as yours; authors may suggest a reading order.
The closure
Start from what you want, follow every reference, stop when nothing new appears: exactly what is needed, nothing more.
Grafting
Taking a piece of someone else's software into yours: its closure arrives, attaches, and remembers where it came from so improvements can go home. Wrap what exists, replace it gradually underneath.
Changing is not editing
A changed thing is a different thing with a different fingerprint; the original stands and its users are unaffected. The chain above re-points with small records - 'same as before, except this reference' - bounded by your project. A succession link notes lineage.
Frozen, with a path to fixes
Nothing updates unless you say so - which also means nothing is silently fixed. So: who is affected is a lookup; a fix arrives classified (drop-in, needs conversion, needs a rebuild); and per item you pin, follow, or defer to someone you trust. When two you trust disagree, you are shown both.
Layers that can only add
Architectures, bindings, shims, features: each an additive piece with a condition on it, inert unless the condition holds - never fetched, never built, structurally unable to break anyone it does not apply to.
No configuration files
Arguments, environment variables, configuration files and build flags exist because the finished program is a sealed box. A value is another item in the graph; configuring is pointing a reference elsewhere. Authors mark intended settings as exposed; some values genuinely arrive only at runtime.
Secrets as handles
Secrets are never in the graph (nothing can be deleted from it, and fingerprints of short values can be reversed). The graph holds a handle resolved outside it when the program runs.
Folklore becomes evidence
A measurement attaches to the exact value it concerns, with its conditions - this hardware, this workload, this result - and because the configuration is exact, anyone who doubts it can reproduce it.
Stop searching the internet for your own computer
Every exposed value carries its names, its author's default, its explanation in place, its lineage, what it affects and what others measured; search narrows to what you are actually running, and alternative names anyone adds become search terms.
The program is a receipt
The graph is the valuable thing; the program is a consequence recomputed from it, a cache entry nothing refers to. Understanding code is done once for everyone; preparing it for a machine is the cheaper half; only what actually changed rebuilds; results are stored by fingerprint too, so values sit beside the code.
Everything visible, almost nothing present
The machine appears to hold the entire tree of all software; a thing arrives the instant it is needed - done at the filesystem so every existing tool works unchanged.
One kitchen, many dishes
A long-running process keeps the shared groundwork warm; each program starts as a copy-on-write copy of it, in its own memory space.
Absent, not forbidden
The list of pieces that built a program is its entire visible world: what it does not need is not denied to it - it is not there.
Changing things while they run
Calls go through an index of where each thing lives; replacing a thing is updating its entry. Whether a change can go live is computed beforehand: inside of a function - swap; shape of stored data - convert first; a boundary - restart.
Rigor as a dial
The same definitions expressed loosely - copying freely, vague errors, like a scripting language - or tightly - explicit ownership, no copying, precise types - tightened where a real wall is met; and tightening done once lives on the definition for everyone.
Conjuring a shoot
You do not install software: you point at the rhizome, draw a boundary, and a working shoot materialises. The shoot and its names are yours and die with the conjuring; only the changed substance goes home.
It behaves like a living system
Fingerprints are the genes and names the appearance; the Weismann barrier - the shape you drew and the name you gave stay yours, only substance is inherited; grafting is lateral gene transfer; renaming is a silent mutation; settings are gene regulation; disuse is how things die.
Assembly, not invention
Every layer runs in production somewhere: structural identity (Unison), whole-tree-visible stores (Google, Microsoft, Meta), reversible slicing (josh), optional parts that stay unbuilt (the Linux kernel), fine-grained change analysis and edition morphing (Rust), the zygote model (Android), live patching (Linux).
The first user ahead on day one
The risk is not the engineering but adoption: the first person to use it must come out ahead at once, alone, with no community behind them.
Hypha
The first milestone: the content-addressed core. It reads real Rust, fingerprints every definition by structure and dependencies, keeps them in one shared graph per machine, and turns a chosen piece back into running code (graft).
Ingest talks to a small persistent daemon that keeps the analysis warm; reads against the store are a stateless command.
Loading and resolving a workspace is expensive and worth keeping warm; the daemon is the first instance of the later genome process.
Отвергнуто: A fresh process for every call.
2026-09-09
Structure is extracted with rust-analyzer's own semantic layer (ra_ap_hir), pinned, behind a stable SymbolGraph boundary; everything downstream speaks language-agnostic graph types.
Real name resolution as a library on stable Rust; the boundary insulates from its 0.0.x instability and is where another language's extractor plugs in.
Отвергнуто: The compiler's internals, MIR or a nightly-only interface; writing a parser or resolver.
2026-09-09
Graft - a closure turned back into compilable, running code - is in the first milestone.
If the structure cannot go back into something executable there is no point in it; proving the round trip first tests the representation before anything is built on it.
Отвергнуто: Ending the first milestone at ingest, hash, store, sync.
2026-09-09
The graph is the source of truth, without qualification; text is read once on the way in and emitted once on the way out.
Describing it as 'a store of source text indexed by structure' quietly re-centres files - the old world with a hash bolted on.
Отвергнуто: Text as the content with structure as its index.
2026-09-09
H(node) = blake3(postcard(hash form) ++ sorted references); local names replaced by positions; cycles condensed and hashed as one unit.
Deterministic, structural, fast; alpha-equivalence built in from the start because it changes what the hash is.
Отвергнуто: Hashing text; adding alpha-equivalence later.
2026-09-09
The kernel is not in the prototype; its only near-term role is the filesystem view, stages later.
'Rust in the kernel' is an argument about timing, not a build target; kernel work is the slowest feedback there is.
Отвергнуто: Starting at the kernel.
2026-09-09
Sync is proven between two local stores before any network transport.
Deciding what to transfer is the part worth testing; the transport is mechanical after.
Отвергнуто: Starting with the network.
2026-09-09
Macros are expanded on the way in and not preserved as such.
They are a convenience of text-based development; once the structure itself is edited they have no job.
Отвергнуто: Treating macros as something the graph must round-trip.
2026-09-09
The project is Rhizome - a root system with no root, any point connecting to any point; its foundational engine is Hypha, the single filament; the tools are rz and hy. The substrate is the rhizome, definitions are nodes, a conjured shape is a shoot.
Biology is load-bearing in the model, so the vocabulary comes from the same well.
Отвергнуто: Alkahest; Aleph (taken); Mycorrhiza (the most exact, the hardest to spell).
2026-09-09
No new language: the host language's type system expresses boundaries and transformations.
Inventing a language to avoid using one was Nix's mistake.
Отвергнуто: A DSL.
2026-09-09
One shared store per machine (~/.local/share/hypha/store); a project holds only a hypha.lock - a small pointer file of closure roots.
A store per project would be isolated and non-deduplicating: the very thing the manifesto opens by attacking.
Отвергнуто: A hidden .hypha per project, like .git.
2026-09-09
The compiler is a black-box oracle at the single text boundary - today the only socket it has; Cranelift is the named long-term destination for code generation.
It keeps the first milestone free of compiler engineering while naming where the text boundary finally disappears.
Отвергнуто: Treating the round trip through text as the destination.
2026-09-09
Hypha is to be developed from its own graph, proven by a fixpoint: built from the graph, it ingests and re-emits itself to the identical hash. Files and git demote to a projection.
The field's answer to the trust hazard of self-hosting systems, and the hardest stress test for free.
Отвергнуто: Keeping its own source in files for ever.
2026-09-09
Each node keeps its verbatim source span beside its hash form; graft emits the original bytes, never a reconstruction.
Nothing is inferred on the way out; the structural hash is identity, the text a rendering of it.
Отвергнуто: Regenerating text from stripped structure.
2026-09-09