Run immense mixture-of-experts models from a swarm of peers, pinch the colibri engine. Pure C, no dependencies.
One instrumentality shares a model. Any different instrumentality chats pinch it: thing is downloaded up front, the bytes an conclusion really touches get from the peer connected first usage and enactment successful a section mirror. The 2nd mobility is served from section disk astatine afloat speed. The motor binary is unmodified.
The founding principle: immoderate instrumentality whitethorn join, GPU aliases not. The motor was built for CPU and SSD first; a GPU only makes it faster, ne'er different, and the output is byte-identical either way. A swarm pinch nary GPU astatine each is a moving swarm. Networks that excavation GPUs enlistee from the few; lumabri recruits from everyone.
Build:
On the instrumentality that has a exemplary (any colibri exemplary directory):
On the instrumentality that wants to chat (needs a colibri build for the engine):
That is all. The first reply is slower while the moving group crosses the network; afterwards the reflector successful ~/.lumabri keeps serving moreover if the server goes offline.
In the chat: /swarm shows the web unrecorded and anonymous (peers are numbered, ne'er named: exemplary held, GB, bytes served, heartbeat), /model lists the models connected the swarm and switches betwixt them, restarting the engine connected the fly.
For personification who only ever opens the TUI
No arguments. It asks for the swarm's reside and, once, for the operator's public key; it finds the engines itself; and it remembers each of it in ~/.lumabri/config, truthful the 2nd clip it is Enter, Enter, and you are in.
That matters much than convenience. Everything it asks for utilized to beryllium a flag, and getting 1 incorrect does not nutrient "invalid argument" — a missing --engines-dir produces a 299 GB download, and a missing cardinal produces a model cipher verified. Flags still triumph erstwhile given, truthful a book never inherits somebody's saved answers.
Joining: chat, aliases bring something
lumabri chat asks once, connected the measurement in, and Enter intends "just chat" truthful the impatient way is 1 key:
Pick 2 and it asks really galore GB (Enter takes a 4th of the free space, capped), past starts a maintainer pinch that budget: the locator assigns it the least-replicated files first, it pulls them verifying each byte against the operator's signature, and serves them. Pick 3 and it starts the expert node for that model's engine. Both tally arsenic children of the chat and extremity when you adjacent it — which is the honorable life for thing offered from a terminal you person open. A philanthropist that should outlive the convention is lumabri service --join.
Donating compute needs the exemplary connected your disk (an master node sounds the weights from there), truthful action 3 is offered only pinch --model-dir DIR. Donating disk needs nothing: you commencement quiet and the swarm fills you.
Scripts skip the question: --role chat|disk|compute|all, pinch --donate GB and --model-dir DIR.
Several models connected 1 swarm
One locator is an index, not a exemplary server, truthful it holds arsenic galore models as you constituent astatine it — from 1 instrumentality aliases many:
Each service brings its ain maintainer (the bytes) and its ain master node (the compute), and each registers nether its model's name. A chatter sees 3 modelli sullo sciame and switches pinch /model <name>: the motor is restarted against the caller model, and since the motor binary is chosen from that model's model_type, switching betwixt different architectures works too — GLM to OLMoE to DeepSeek, 1 client, 1 tracker.
Donors are per exemplary arsenic well: a instrumentality tin clasp a portion of 1 exemplary and execute experts for another. The locator keeps them apart, and a chatter only ever discovers the peers for the exemplary it is talking to.
Donating space, the server decides: a instrumentality pinch an quiet directory can offer a byte fund and the locator assigns it the portion to hold, rarest-first, truthful each donated gigabyte lands wherever the swarm is thinnest. The philanthropist pulls its portion from the swarm, past serves it.
NAT floor: maintainers support 1 outbound power relationship to the tracker and, erstwhile a nonstop dial fails, bytes are relayed done it. A adjacent behind any location NAT serves pinch zero router configuration; nonstop peer-to-peer stays the first choice. The selftest proves byte personality connected the relay path too. Private swarms: group LUMABRI_TOKEN=S connected each instrumentality — serve passes it to its tracker, and some the locator and each maintainer refuse unauthenticated connections, truthful the token guards the bytes, not conscionable the index. A maintainer advertising localhost from different instrumentality gets its reside corrected by the locator to what the relationship shows.
Tutorial: a first swarm successful 5 minutes
No exemplary astatine hand? Generate the mini synthetic 1 (python3 + numpy) and serve it — each measurement beneath is the existent thing, conscionable small.
In a 2nd terminal, the chatter. It needs the motor binaries from a colibri build:
What you should see, successful order:
- The motor boots against a directory that does not beryllium connected the chatter's disk: the config and tokenizer get from the swarm on first touch.
- Ask something. The first reply is the slow 1 — watch the nett MB counter climb while the moving group crosses the wire.
- Ask again. reflector caldo, zero rete: the 2nd reply is served from ~/.lumabri/<model>/cache astatine section speed.
- /swarm shows the network, anonymous; /model lists what other it holds.
- Kill the service terminal and support chatting: the lukewarm reflector answers with every adjacent dead. That is walk 3 of make test, lived alternatively of read.
To turn it, a friend connected different instrumentality chats with --tracker <your-ip>:7300, aliases donates disk truthful the exemplary survives you turning your instrumentality off:
The locator assigns the philanthropist the least-replicated files first; the donor pulls them from the swarm, past serves them. /swarm successful your chat now shows 2 peers.
Two stages: everything connected 1 instrumentality first, past much machines. Nothing below is simply a simulation — the single-machine type runs the aforesaid binaries over the aforesaid sockets.
On the instrumentality pinch the model. Build some halves of shape 2 (chatters is the patched engines, engines is the master nodes) and cheque the model runs astatine each earlier immoderate web is involved:
Then the swarm, still connected 1 machine:
For a swarm anyone other tin reach, adhd --advertise <the machine's nationalist IP>: peers people the reside they are given, and without it they publish 127.0.0.1 — correct for this machine, useless for everyone else. serve says truthful loudly if you forget, because the nonaccomplishment mode is simply a distant chatter that falls backmost to the relay and ne'er turns shape 2 on, which sounds as "slow" alternatively than "misconfigured".
Expect, successful order: the hashing advancement (first commencement only — minutes connected a big model), ORIGIN: signed the truth of N files, and serving EXEC connected :7302 … registered pinch tracker. In a 2nd terminal:
The statement to look for is [lumabri] shape 2 active. Without it the chatter is moving the banal motor and will download master weights instead of asking peers to tally them — du -sh ~/.lumabri is the different tell: with phase 2 connected it grows by the dense portion and stops.
Adding machines. Open 7300-7302 (and +10 per other model) successful the firewall — connected a unreality host, successful the provider's console as good as successful ufw. Every different instrumentality needs lumabri and a colibri checkout, then make phase2-all ENGINE=…. From location the 3 roles:
| chat | LUMABRI_PUBKEY=<pub> lumabri chat --tracker IP:7300 --engines-dir … |
| chat + donate disk | the same, past prime 2 (or --role disk --donate 50) |
| donate compute | needs the exemplary locally: --role compute --model-dir DIR, aliases expert_node_<engine> arsenic a service |
/swarm successful immoderate chat shows who arrived. The impervious that the swarm is really carrying the work: while a reply is generating, termination a philanthropist — you get one failover statement and the tokens continue, identical.
concurrency_test.sh runs the aforesaid procreation from N chatters simultaneously and reports the dispersed betwixt the fastest and the slowest, because "does it answer" is the easy mobility and "does anyone get starved" is the existent one. On 1 6-core box, tiny_olmoe, everything (server, peers, clients) sharing those cores:
| 1 | 1.0 s | 1.0 s | 0.0 s |
| 2 | 1.7 s | 1.8 s | 0.0 s |
| 4 | 10.4 s | 10.7 s | 0.3 s |
Nobody is starved — the dispersed stays level while the absolute clip grows, which is what CPU contention looks for illustration and not what a fastener convoy looks like. Four clients connected six cores that are already moving the server and its expert node is oversubscription, and connected abstracted machines the clients bring their ain cores.
Where contention really lives, truthful those numbers tin beryllium publication honestly:
- bytes scale. The maintainer answers sounds pinch positional pread on shared fds — nary fastener connected the publication way — and the page cache serves every client the aforesaid basking bytes.
- hot experts scale, acold ones queue. The master node runs a thread per connection, but a cache miss holds a azygous loader lock, because the engine loaders are engine-internal authorities and not re-entrant. Size --cache truthful the moving group fits and misses are rare; that is the knob.
- the locator is not connected the basking way astatine all. It is consulted astatine footwear and on a 10 s heartbeat, ne'er per token.
serve runs 2 mini programs: a tracker, which is only an scale of who holds which files, and a maintainer, which answers byte-range sounds connected the model directory. A maintainer tin clasp conscionable a portion of a model (--include patterns), and respective maintainers tin stock 1 model.
chat mounts the exemplary done liblumabri.so, an LD_PRELOAD shim that interposes precisely the libc calls the engines usage connected a exemplary directory (open, fopen, opendir, pread). Files are mirrored arsenic sparse local files of the existent size, truthful fstat, readdir and the kernel page cache work natively. A missing artifact is fetched from a peer, written to the mirror, then the engine's ain pread proceeds. A lukewarm publication costs 1 array lookup plus a normal section read: location is nary FUSE and nary daemon connected the publication path.
Correctness rule, inherited from colibri: the web whitethorn only alteration where bytes travel from, ne'er which bytes. Writing to exemplary files returns EROFS. A artifact nary adjacent tin service is simply a large EIO, ne'er silent zeros. The selftest verifies byte personality cold, warm, and pinch each adjacent dead.
Phase 2: peers execute experts
The 2nd half of the project, prototyped and measured: the chatter keeps only the dense weights, router and KV cache, and sends the activation row (4 KB) to the adjacent that holds each routed expert. Expert weights never reach the chatter. Both sides are built from the engine's ain source (expert_node.c includes olmoe.c), truthful section and distant runs are 1 code path and nutrient identical tokens.
Measured connected 1 instrumentality pinch pinned cores and web emulated successful the peer (phase2_bench.sh, specifications and limits successful RESULTS_PHASE2.md):
| local, experts resident successful RAM | 1.92 | 2.53 GB |
| local, experts from disk | 0.04 | 1.12 GB |
| P2P, gigabit LAN | 5.97 | 1.04 GB |
| P2P, net astatine 30 ms | 1.13 | 1.04 GB |
Identical tokens connected each path. On a LAN the web costs 15 percent; on the net the sequential layers are the wall. This build needs the small patch successful engine_patches/olmoe-p2p.diff applied to colibri, then:
colibri ships respective engines and they do not stock a shape, truthful shape 2 is per engine: a spot that hooks the MoE function, and an expert-node binary built from that engine's ain source. Everything engine-specific lives successful one header per motor nether expert_engines/; expert_node.c itself is engine-agnostic. The patches are generated from root anchors by engine_patches/make_patches.py, truthful they tin beryllium regenerated against any colibri type and neglect loudly alternatively of applying to the incorrect place. The engine is ne'er modified — the trial patches a copy.
All 5 engines chat done lumabri: shape 1 serves immoderate model's bytes, and the beforehand extremity speaks some motor dialects. Phase 2 — peers executing the experts — is the portion that is per engine.
| olmoe | OLMoE | yes | expert_node — proven, phase2_test.sh |
| colibri | GLM | yes | expert_node_glm — proven, phase2_glm_test.sh |
| inkling | Inkling | yes | expert_node_inkling — proven, phase2_inkling_test.sh |
| kimi_k3 | Kimi K3 | yes | expert_node_kimi — proven, phase2_kimi_test.sh |
| deepseek | DeepSeek V4 | yes | expert_node_deepseek — proven, phase2_deepseek_test.sh |
make test-engines runs the 4 pinch fixtures; DeepSeek needs a existent model (make test-phase2-deepseek MODEL=<dir>). "Proven" intends the experiment, not the opinion: the aforesaid engine, the aforesaid prompt, generated doubly — erstwhile pinch the experts section and erstwhile pinch each 1 of them connected a adjacent — and the tokens compared. Each needs a fixture, truthful this repo carries a generator per engine (make_tiny_olmoe.py, make_tiny_inkling.py, make_tiny_kimi.py; GLM uses colibri's ain glm_tiny_i4). They are numpy-only and build random-weight models: the output is gibberish, which is the constituent — what is being measured is that 2 runs work together spot for bit, not that the exemplary is immoderate good.
The fixtures are not ceremony. GLM's first type looked right, compiled, ran, and produced tokens that matched for 4 positions and past drifted, because GLM computes an master complete each its routed rows astatine erstwhile and the peers were being fed 1 statement astatine a time. Nothing but moving it would have caught that.
DeepSeek V4 was the 1 that looked easiest from the extracurricular — it has a clean nationalist API (coli_v4_engine_open, coli_expert_lookup, coli_v4_expert_forward_ref) wherever the others request their internals — and turned retired to person the sharpest edge:
- the router weight is not a scale. coli_v4_expert_forward_ref folds it in before the down projection and rounds the merchandise to bf16, so w · expert(x) is not what the motor computes. It has to recreation pinch the activation and beryllium applied by the peer; the chatter-side multiply that every other motor allows would person looked correct and been wrong. EXEC carries the weights erstwhile the assemblage is agelong capable to clasp them.
- three places use a target expert — 1 per token, 1 successful the block pipeline, 1 successful the batch national — and each had to beryllium hooked. Missing one is not a crash; it is simply a furniture that softly runs locally. The dspark draft path is deliberately near alone: those are the draft model's experts, and the target verifies each token they propose.
- deepseek.c is generated by tools/amalgamate_deepseek.py, truthful the patch is regenerated from anchors for illustration the rest, and the build renames its CLI introduction constituent successful a transcript because the record #undefs main halfway through.
Its adjacent is besides the only 1 that holds nary dense weights astatine all: V4's expert store opens consecutive disconnected the exemplary directory, which is what a adjacent should have wanted each along.
There is nary synthetic fixture for it — V4 validates a strict config and an FP8/FP4 tensor plan, truthful a random-weight stand-in is much activity than it is worth. phase2_deepseek_test.sh runs against a existent exemplary instead, and the engine scores itself: the section tally writes an oracle, the P2P tally is checked against it by --oracle.
Three shapes had to beryllium taught to the client, and they are worthy naming because they are what "support different engine" really costs:
- not each furniture routes. Dense first layers, and for GLM an MTP statement at index n_layers that does. lumi_init_ex takes the mask; without it the non-existent experts of dense layers count arsenic missing and shape 2 silently stays disconnected connected each exemplary that has one.
- batching is portion of the arithmetic. GLM gathers each statement a layer routed to an master and computes them together; nr rows successful 1 telephone is not nr calls of 1 row. EXEC carries a statement count, and lumi_moe_apply_batch reproduces the engine's ain union, statement bid and accumulation order.
- the experts do not ever unrecorded successful hidden space. Kimi K3 routes successful a latent of c->latent, truthful that is the width connected the wire.
The swarm is arsenic accelerated arsenic your nearest replica, not your mean adjacent — so lumabri measures region and acts connected it, pinch nary coordination: every node probes its ain peers astatine startup (two PINGs, support the min) and the tracker stays a Napster scale that ne'er knows wherever anyone is.
- Nearest replica first (both phases): peers wrong 25% + 2 sclerosis of the best are "equally near" and stock the load; everyone farther is failover, the relay last. Measured: an master replicated astatine 2 sclerosis and astatine 30 sclerosis runs at 10.5 tok/s alternatively of 1.4 — the 30 sclerosis wall is the wall of your nearest replica only.
- Readahead (LUMABRI_PREFETCH, default 2 blocks): while the engine chews connected artifact N the swarm is already sending N+1..N+K. Measured: a cold mirror connected a 40 sclerosis swarm loads 45% faster.
- Replica failover (phase 2): a adjacent that dies mid-generation costs one retry connected the adjacent replica, not the conversation. Measured: adjacent killed while generating, 4 failovers, tokens byte-identical. An master pinch no live replica stays a difficult correction — ne'er a silent section fallback.
./phase3_test.sh proves each three, nary guidelines needed (distance is emulated inside the serving peer). Still connected the table, engine-side: speculative drafting pinch batch-union (one furniture information per multi-token draft) and expert prediction — the multipliers that stack connected apical of proximity.
Phase 4: bootstrap and delegate
A swarm has to activity connected time zero, erstwhile cipher has donated thing yet. The policy: the server executes first, delegates arsenic donors arrive, and stays the fallback of past resort.
- lumabri service besides runs an master node connected the full exemplary (when the family has one; --no-exec disables). Experts enactment on the SSD and stream done an LRU RAM cache (--cache N slots, the colibri way): a 16 GB instrumentality tin clasp a 500 GB slice, basking experts costs RAM speed, a cold one costs 1 NVMe read. Byte-identity survives streaming — proven pinch a cache truthful mini that 80% of calls were acold loads.
- Chatters request zero master configuration: the motor asks the tracker who tin execute for the exemplary (expert nodes heartbeat for illustration maintainers) and runs shape 2 against whoever answers — connected a caller swarm, that is the server alone.
- A philanthropist joins pinch expert_node --model DIR --tracker H:P [--cache N] [--stride N:OFF], is discovered, and wins the calls it is nearest for. If it dies mid-generation the telephone fails complete — replica, past a fresh tracker query, yet the server. If the swarm cannot screen every expert astatine startup, shape 2 simply stays disconnected and the motor runs experts itself from the phase-1 mirror. Every rung of that ladder is loud; none of them tin alteration a byte.
./phase4_test.sh proves each 3 claims, including a philanthropist killed mid-generation pinch tokens byte-identical to the section reference.
Phase 5: 2 kinds of swarm
Open swarm — anyone whitethorn join, cipher is trusted. Integrity is simply a chain of custody rooted astatine the swarm operator, ne'er astatine the adjacent serving the bytes:
- Every maintainer computes a sha256 per MiB of what it holds (cached in .lumabri_hashes/, truthful only the first commencement pays) and sends them with its registration.
- The locator keeps the first announcement of each record arsenic crushed truth — the root registers earlier immoderate philanthropist exists — and strips the files of immoderate later registrant whose hashes disagree: poison dies astatine the index and ne'er reaches a placement.
- Chatters and pulling donors inquire the tracker for the truth and verify every fetched block. A adjacent that lies gets its bytes rejected and the block refetched elsewhere, loudly. LUMABRI_REQUIRE_HASH=1 refuses to fetch astatine each wherever integrity information is missing — the strict mode for swarms of strangers.
- Phase 2 results are checked the only measurement untrusted compute tin be: LUMABRI_VERIFY=N reruns N% of master calls connected a different replica and demands byte-identical output. Determinism is what makes this activity — two honorable peers cannot disagree, truthful a disagreement is impervious of a dishonesty and the tally stops alternatively than emit a token cipher tin vouch for.
Signed swarm — not moreover the locator is trusted. Hashes unsocial make the tracker the authority: it decides which bytes are true, truthful compromising it rewrites the model. A signature moves that authority to a cardinal the operator keeps offline.
The root signs each file's hash vector (bound to model, path, chunk size and record size, nether a domain tag, truthful a signature cannot beryllium replayed onto another file). The locator stores and forwards the signature and — given --pubkey, which service --key passes automatically — refuses immoderate claim that is not signed. The chatter rebuilds the signed connection itself and checks it against the cardinal it obtained out of band: a compromised tracker tin withhold the truth, but it cannot rewrite it and beryllium believed. Carrying a nationalist cardinal implies strict mode: unsigned bytes are refused, not merely noted. The Ed25519 and SHA-512 present are self-contained C, checked against RFC 8032 and against OpenSSL successful some directions by sign_test.sh.
Private swarm — invitation only. Set LUMABRI_TOKEN=S connected every machine: service passes it to its tracker, and the tracker, every maintainer and each master node garbage unauthenticated connections. The token guards the bytes and the compute, not conscionable the index. It composes with signing: the token says who whitethorn connect, the cardinal says which bytes are real.
./phase5_test.sh proves each 3 open-swarm defences pinch peers that lie exactly arsenic an adversary would (honest manifest, corrupt bytes): 7 corrupt blocks rejected pinch the reflector still byte-identical, a poisoner stripped at registration, and a lying organizer caught connected the first spot-check.
A afloat walkthrough for a existent server — Hetzner, systemd, firewall, operator key, clients — is successful DEPLOY.md. The short version:
On the server: lumabri service --model /srv/model --port 7300 (open TCP 7300-7302: tracker, maintainer, executor). A systemd portion is 1 stanza: ExecStart=/usr/local/bin/lumabri service --model /srv/model, Restart=always, positive Environment=LUMABRI_TOKEN=... for a backstage swarm.
On each different machine, prime a domiciled — aliases several:
| chat | lumabri chat --tracker SERVER:7300 |
| chat connected the instrumentality that holds the model | lumabri chat --local DIR (no mirror, nary 2nd copy) |
| donate disk (hold bytes) | lumabri service --model ./slice --join SERVER:7300 --model-name NAME --donate GB |
| donate compute (execute experts) | expert_node<engine> --model DIR --tracker SERVER:7300 --cache N |
The compute adjacent is per engine, because the engines do not stock an expert shape. lumabri service picks the correct 1 from the model's model_type; donating by manus intends naming it:
| OLMoE | expert_node | |
| GLM | expert_node_glm | --bits must lucifer the chatter's (default 8) |
| Inkling | expert_node_inkling | --bits likewise |
| Kimi K3 | expert_node_kimi | activations are latent-width, not hidden |
| DeepSeek V4 | expert_node_deepseek | holds nary dense weights: --cache is master slots per layer |
A compute philanthropist says only what it knows astir itself — --hold N, really many experts it tin transportation — and the locator answers pinch the group cipher else covers, rarest first. It utilized to request --stride 9:3, which intends knowing how many different donors beryllium and which scale is free: coordination, successful a thing built to region coordination. --layers/--stride still activity and simply opt out. assign_test.sh starts 3 nodes that cognize thing of each different and checks they extremity up disjoint, screen the full set, and support their portion across a restart.
make engines builds the peers, make chatters the patched engines, and make phase2-all some — for the engines your colibri checkout really has. deepseek.c is generated by colibri's tools/amalgamate_deepseek.py and is absent from a caller clone, truthful that 1 is skipped pinch a statement saying so rather than failing the build for everyone who only wants GLM.
| lumabri.c | the beforehand end: service and chat |
| tracker.c | index of who holds what, nary exemplary bytes |
| maintainer.c | serves byte ranges of a exemplary directory |
| lumashim.c | the chatter-side LD_PRELOAD shim |
| lumabri_proto.h | binary ligament protocol, header only |
| expert_node.c | phase 2 peer: holds experts and executes them |
| expert_engines/*.h | one per engine: the only engine-shaped code |
| engine_patches/make_patches.py | generates the motor patches from root anchors |
| lumabri_client.h | phase 2 chatter side |
| selftest.sh | byte identity: cold, warm, offline |
| phase2_test.sh, phase2_bench.sh | phase 2 correctness and benchmark (olmoe) |
| phase2_glm_test.sh, phase2_inkling_test.sh, phase2_kimi_test.sh, phase2_deepseek_test.sh | phase 2 byte identity, 1 per engine |
| phase3_test.sh | proximity, readahead, failover — measured |
| phase4_test.sh | SSD cache, locator discovery, delegate & autumn back |
| phase5_test.sh | integrity: lying peers caught, poison stripped |
| sign_test.sh | sha512/ed25519 vs RFC 8032 and OpenSSL, signed swarm |
| security_test.sh | path flight from a dispute peer, tracker, aliases portion assignment |
| assign_test.sh | three uncoordinated compute donors divided the experts by themselves |
| concurrency_test.sh | N chatters astatine once: does anyone get starved |
| chat_proto_test.sh | both motor dialects, and a dying motor that explains itself |
| DEPLOY.md | server walkthrough: Hetzner, systemd, keys, clients |
| lumabri_sha.h | sha256, self-contained — per-block integrity |
| lumabri_sign.h | sha512 + ed25519 — the operator's authority |
| make_tiny_olmoe.py | synthetic OLMoE-shaped fixture for tests |
| make_tiny_inkling.py, make_tiny_kimi.py | the aforesaid for Inkling and Kimi K3, numpy only |
| expert_engines/deepseek.h | the V4 peer: master shop only, nary dense weights |
Peer-to-peer LLM conclusion exists; this operation does not. Petals runs dense models BitTorrent-style by assigning consecutive transformer blocks to volunteer GPUs; hivemind's decentralized MoE spread experts complete volunteers, but for training; exo and llama.cpp's RPC mode divided layers crossed devices 1 personification owns; MeshLLM hands retired static layer ranges. lumabri differs connected 3 axes astatine once:
| granularity | a slab of consecutive layers | one master — matches MoE sparsity, 4 KB activations travel, a adjacent is useful holding a azygous expert |
| hardware floor | a dense portion must tally fast: successful believe a GPU | any machine; a swarm pinch nary GPU is simply a moving swarm |
| determinism | best-effort, outputs alteration crossed hardware | byte-identical by construction: distant and section are 1 codification path |
The 3rd axis is not cosmetic: deterministic output is what makes spot-check verification of untrusted peers imaginable astatine each — 2 honest peers must work together to the byte, truthful a dishonesty is detectable by sampling.
Linux, gcc, GNU make. Python 3 pinch numpy only for generating the test fixture. A colibri build provides the engine binaries.
Working prototype, deployable. Open swarms verify bytes (sha256 per MiB, signed by the operator's ed25519 key, checked by the chatter against a key it holds itself) and results (spot-check connected a 2nd replica); private swarms request an induce token everywhere. Not yet done, successful bid of importance: speculative drafting pinch batch-union (the remaining multiplier against WAN latency), hedged requests against stragglers, tracker-side expert assignment, cardinal rotation and revocation, NAT spread punching. Expert execution is not yet covered by the usability signature — a peer's results are checked by replica agreement, not by a key.
Apache 2.0
English (US) · 
Indonesian (ID) ·