CELAUT

O arhitectură peer-to-peer pentru proiectarea și distribuirea software-ului

Inspirat de automatele celulare — comportament global robust care emerge din reguli locale simple.

Atinge orice cuvânt subliniat pentru o explicație pe înțeles. Le poți opri oricând cu butonul din colț.

De unde vine

Totul începe cu o mână de reguli.

În anii 1940, John von Neumann și Stanislaw Ulam au introdus automatele celulare: modele care arătau cum pot emerge comportamente complexe din altele simple.

Nimeni nu dirijează asta.

În 1970, “Jocul vieții” al lui John Horton Conway a devenit exemplul clasic: o grilă în care fiecare celulă se uită doar la vecinii ei și care, cu toate acestea, produce structuri complicate, în continuă evoluție.

Asta e toată filosofia de proiectare.

Aceste idei arată cum pot sistemele descentralizate să atingă complexitate fără control central — filosofia care ghidează Celaut. Reguli simple la nivel de nod și serviciu, un sistem adaptiv deasupra.

Descentralizare · Simplitate · Determinism

Cele două elemente primitive

Un nod

Un calculator sau dispozitiv care vorbește cu semenii săi și gestionează execuția serviciilor. Pune la dispoziție hardware-ul, decide dacă rulează lucrarea local sau o pasează mai departe și nu are nevoie vreodată să înțeleagă ce face software-ul.

Un serviciu

Un container software determinist construit pentru o singură treabă. Este sigilat față de nodul care îl rulează: nodul nu inspectează programul, iar programul nu știe pe ce mașină a aterizat.

Două atome. Specificația, execuția, plata și reputația sunt doar modul în care ele interacționează.

Rețeaua

Faptul că are noduri nu e diferența.

Majoritatea rețelelor descentralizate au noduri și, cu toate astea, depind în continuare de un lucru puternic: protocolul pe care trebuie să-l ruleze toată lumea. Regulile rămân centrul, chiar și când mașinile nu sunt.

Celaut nu are niciun protocol asupra căruia să te înțelegi.

Nodurile nu trebuie să convină dinainte asupra unui protocol de comunicare — își declară interfețele pe care le acceptă și metodele de plată pe care le primesc chiar la contact. Două noduri vorbesc despre ce se întâmplă să aibă în comun; acolo unde nu se suprapun, pur și simplu nu vorbesc.

Așa că îți schimbi nodul, nu rețeaua.

O politică nouă de preț, încă o metodă de plată, un format de specificație pe care nimeni altcineva nu-l citește încă — îl implementezi în propriul nod și funcționează cu oricine îl acceptă deja. Nimeni nu votează, nimic nu trebuie migrat și nu există niciun hard fork de supraviețuit.

Fără protocol comun. Fără versiune comună. Fără permisiune.

Ce rulează pe ea

Un serviciu este un container sigilat.

Serviciile din Celaut sunt containere software deterministe concepute pentru o sarcină anume. Nimic mai elaborat de atât.

După principiul cutiei negre.

Ele funcționează independent de nodurile care le execută, concentrându-se exclusiv pe funcționalitatea lor. Nodul nu are nevoie să înțeleagă serviciul, iar serviciul nu are nevoie să știe nimic despre nod.

Izolat, de fiecare dată.

Fiecare cerere rulează ca un proces izolat — într-o mașină virtuală proprie, cu propriul kernel și o graniță impusă de hardware —, ceea ce abstractizează mediul de execuție și păstrează intactă bariera de securitate.

Ce intră, ce iese. Asta e toată interfața.

Cum se specifică un serviciu

BOX — mediul.

Arhitectură, sistem de fișiere, variabile de mediu, punct de intrare, configurație și resurse. Specifică direct întreaga structură de fișiere, în loc să se bazeze pe imagini sau depozite externe, și tocmai asta face execuția reproductibilă pe orice nod.

API — interfața.

Cum se comunică cu serviciul, ce sisteme de plată acceptă și costurile aferente. Permite folosirea serviciilor fără niciun controlor central care să negocieze protocolul în numele lor.

NET — domeniul de rețea.

Implicit, un serviciu este izolat: poate vorbi doar cu părintele său, cu copiii săi și cu nodul care îl rulează. Dacă are nevoie de lumea de afară, rețelele pe care le va atinge sunt numite chiar în specificația lui — nodul i le acordă, fiindcă vrea să ruleze serviciul cum trebuie, iar tu primești garanția că nu poate ajunge nicăieri altundeva.

Trei componente. Un serviciu portabil.

Împreună creează servicii portabile și reproductibile, care se comportă consecvent în toată rețeaua, păstrând securitatea și determinismul.

Fără dependențe externe. Nimic lăsat implicit.

Cine ce decide

Un serviciu își cere copiii.

Un serviciu poate cere execuția unor servicii-copil prin nodul său. Precizează resursele de care are nevoie fiecare și le predă un buget de cheltuit. Nu o mașină, nu o regiune — resurse.

Nodul decide unde rulează.

Compară costul rulării instanței local cu prețul pe care îl oferă fiecare dintre semenii săi și îl alege pe cel pe care îl consideră cel mai bun. Un copil rămâne aici; altul aterizează la un semen.

Părintele nu află niciodată.

Nu știe dacă un copil a ajuns pe această mașină sau în altă parte și nici nu are nevoie să știe. Tot ce urmărește este ce consumă copiii lui și cât de repede cheltuiesc, ca să poată echilibra asta.

Această separare e tot secretul.

Operatorii de noduri se ocupă de partea fizică: hardware, capacitate, preț, plasare. Dezvoltatorii de servicii declară resursele de care au nevoie și nimic despre infrastructură. Niciunul nu trebuie să facă treaba celuilalt — exact asta ține ambele jumătăți simple.

Două preocupări. O linie curată între ele.

De ce rezistă

Aceeași intrare. Aceeași ieșire.

Serviciile sunt specificate complet ca să urmărească rezultate reproductibile în timp și între noduri. La aceleași intrări, aceeași specificație ar trebui să producă aceleași ieșiri, indiferent unde sau când rulează.

Nu e o garanție în orice caz.

Un serviciu care ajunge la o rețea nu poate fi perfect reproductibil — rețeaua răspunde altfel. Dar o specificație duce cu ea mult mai mult decât o definiție Docker: arhitectura, întregul sistem de fișiere, entrypoint-ul, configurația. Așa că suntem mult mai aproape de a rula un program obișnuit decât de a trage o imagine și a spera.

Ceea ce face încrederea măsurabilă.

Fiindcă software-ul nu poate devia, o dovadă de reputație înregistrată cu ceva timp în urmă spune și azi ceva adevărat — cu condiția ca serviciul să nu se întindă spre vreo rețea, ceea ce e starea lui implicită.

Și călătorește odată cu el.

Fiindcă nimic din mediu nu e lăsat la latitudinea gazdei, aceeași specificație produce același comportament pe un laptop, un server rămas liber sau un nod de care n-ai auzit vreodată. Unde rulează încetează să mai fie parte din răspuns.

Specificat complet, deci nimic lăsat pe seama mașinii.

Cum cooperează necunoscuții

Reputația vine prima.

Încrederea nu se presupune niciodată între părți. Nodurile nu au încredere în alte noduri; tu nu ai încredere din start nici în serviciu, nici în nodul care îl rulează; iar un nod nu trebuie neapărat să aibă încredere în serviciul pe care îl execută. Singura direcție care se susține e cea inversă: un serviciu poate avea încredere în nodul său, fiindcă cine a decis să îl ruleze a ales acel nod. Așa că nimic nu începe cu o strângere de mână, ci cu o consultare: reputația înseamnă înregistrări în registre, opinii mai degrabă decât verdicte, cântărite de fiecare actor după sursele în care are deja încredere.

Apoi plătești pentru o promisiune de resurse.

Abia după ce înregistrarea trece verificarea se mișcă ceva. Solicitantul plătește în avans, iar ce cumpără este o promisiune: atâta calcul, pentru atâta timp. Mecanismele de plată stau în afara arhitecturii de bază, deci niciun registru anume nu e încastrat în ea.

Garanția nodului este reputația sa.

Nimic nu-l obligă să-și țină promisiunea. Ce îl reține este faptul că rezultatul este scris înapoi în registru — iar un nod al cărui istoric spune că a încasat și a livrat mai puțin încetează să mai fie ales. Fiecare parte are un interes permanent ca următorului necunoscut să-i placă ce citește.

Verifică · plătește · livrează · înregistrează. Apoi din nou.

Regulile de care se ține

Nimic din toate acestea nu a fost o listă de funcționalități.

O rețea fără vreun protocol asupra căruia să te înțelegi, servicii sigilate față de mașinile care le execută, rețele declarate din start, plata înainte de execuție — fiecare dintre ele este o consecință. Trei angajamente le produc, iar cele trei se sprijină reciproc.

Descentralizare.

Niciun punct unic de control sau de eșec. Nodurile comunică și se coordonează dinamic, fără nimic la mijloc de la care să ceară permisiunea — exact de aceea nu a existat de la bun început vreun protocol asupra căruia să te înțelegi.

Simplitate.

Reguli minimaliste care reduc complexitatea, astfel încât fiecare componentă rămâne suficient de mică pentru a fi înțeleasă și întreținută separat. Un serviciu este un container, o interfață și un domeniu de rețea — atât.

Determinism.

Serviciile sunt specificate suficient de complet pentru a-și reproduce rezultatele în timp și de la o mașină la alta. Aceleași intrări, aceleași ieșiri, oriunde și oricând ar rula — tocmai de aceea o reputație înregistrată acum un an merită citită și astăzi.

Scoate oricare dintre cele trei și celelalte două nu mai valorează mare lucru.

Confuzii frecvente

Ce nu este Celaut

Arhitectura stă suficient de aproape de câteva lucruri familiare încât să fie confundată cu ele. Merită să fim preciși în privința diferențelor.

Nu este o singură rețea

Celaut definește o arhitectură flexibilă, nu o rețea predeterminată. Pot foarte bine să apară rețele dominante, dar sistemul susține multe construcții peer-to-peer, în loc să dicteze una singură.

Nu este o stivă completă de protocoale

Oferă principii fundamentale pentru construirea unor stive de distribuire a calculului, nu o stivă completă cu opinii despre tot. Implementările actuale se sprijină pe componente precum gRPC și Ergo, iar acelea sunt alegeri interschimbabile.

Nu este un proiect blockchain

Celaut nu are criptomonedă proprie și nu are DAO-uri. Folosește totuși tehnologii blockchain acolo unde își merită locul — înregistrarea reputației, decontarea plăților între necunoscuți — fără a adopta ecosistemul mai larg din jurul lor.

Software-ul

Ce există astăzi

Arhitectura este o specificație, iar oricine poate implementa un nod pornind de la ea. O implementare rulează rețeaua astăzi; a doua, pentru Android, este în alfa.

Nodo

Funcțional

Implementarea de referință, în Python3 și Rust. Execută servicii, negociază costul cu perechile, decontează plățile pe Ergo sau pe Bitcoin, furnizează adrese și token-uri și rezolvă dependențele oriunde ar rula acestea. Se instalează pe Linux cu o singură comandă, iar pe Windows 11 printr-un instalator oficial care își pregătește propriul mediu Linux izolat.

Chatui

Alfa

O aplicație Android pentru a folosi serviciile Celaut fără intermediari: un client ușor care ajunge la servicii printr-o interfață simplă de chat, cu un portofel Ergo integrat. Este în alfa — APK-uri de pre-lansare sunt publicate pe GitHub, iar dezvoltarea este activă, deci te poți aștepta la asperități.

Nimic de aici nu ține locul a ceva ce funcționează deja în altă parte. Ce merge, merge; ce nu merge, o spune.

Unde rulează deja

Impact și aplicații în lumea reală

Arhitectura nu este un experiment de gândire. Este folosită la două distanțe diferite — ca strat în sine și ca temelie sub ceva ce are propriul motiv de a exista.

Arhitectura, pornită Stratul în sine

Niciuna dintre ele nu este o aplicație construită peste Celaut. Ele sunt Celaut, odată ce nodurile chiar funcționează.

DePIN

Oricine poate rula un nod Celaut și poate deveni parte dintr-o rețea descentralizată de infrastructură fizică. Fiecare nod descoperă perechi, execută și orchestrează servicii și le gestionează dependențele — transformând calculatoare obișnuite în putere de calcul partajată și rezistentă la cenzură. Aceasta este rețeaua, nu un produs așezat peste ea.

Unstoppable Skills

Un registru complet on-chain și fără servere, în care protagonistele sunt problemele. În loc să vâneze servicii, agenții caută o competență și descoperă serviciile care o acoperă, cu benchmark-uri reale și clasare bazată pe reputație. Așa devine efectiv accesibil stratul de reputație al paradigmei — pe Ergo, cu o miză reală: nimeni nu inundă registrul fără să-și rișteze reputația.

Construit peste ea Proiect independent

Un pas mai departe: un produs cu propriul scop și propriii utilizatori, care se întâmplă să fie asamblat din servicii Celaut. Ar avea sens și dacă ar fi reconstruit pe altceva — exact acest lucru îl transformă în dovadă.

Game of Prompts

O platformă competitivă în care creatorii proiectează servicii-joc ce evaluează roboții care le joacă, iar jucătorii scriu servicii-rezolvitor care încearcă să-și maximizeze scorul.

Serviciile urmează paradigma Celaut, iar întregul sistem folosește blockchain-ul Ergo pentru a înregistra rezultatele și a transfera premiile.

Alege-ți intrarea

Tu care ești?

Ca utilizatori, putem juca trei tipuri de roluri în ecosistem. Fiecare are propria intrare.

Rolul 01

Operatori de noduri

Similar minerilor din sistemele blockchain, operatorii de noduri furnizează rețelei resurse de calcul. Execută serviciile cerute de utilizatori în schimbul unei plăți, fără să fie nevoiți să înțeleagă funcționalitatea specifică a acelor servicii.

  • Furnizează resurse hardware
  • Execută servicii la cerere
  • Primesc compensație pentru resurse

Rolul 02

Dezvoltatori de servicii

Dezvoltatorii creează servicii care pot rula pe orice nod compatibil din rețea. Se concentrează pe construirea funcționalității, fără să-și facă griji pentru detaliile infrastructurii de dedesubt.

  • Proiectează specificații de servicii
  • Construiesc aplicații deterministe
  • Distribuie servicii către noduri

Rolul 03

Utilizatori de servicii

Utilizatorii finali lansează servicii pe noduri, plătind pentru resursele de calcul folosite.

  • Cer execuția unui serviciu
  • Plătesc pentru resurse de calcul
  • Consumă rezultatele serviciului