Kera | Deterministic Systems Language and Compiler

Kodagent och operatörsassistans. Demomätvärdena är illustrativa.

Terminal, sökning, lint, test, git med mera.

Specialiserade agenter samarbetar över olika områden.

Varje steg registreras med tidsstämplar.

Policyer, kontroller och tester körs alltid.

Granska diffar, begär ändringar, slutgiltigt godkännande.

Spela upp valfri session bit för bit när något behöver granskas.

Autonoma agenter som skriver kod och lämnar kvitton

för att hantera nätverkstimeouts, 5xx-svar och idempotenta villkor. Ren hjälpfunktion, fullt enhetstestad.

en ändrad nod nycklar om endast dess påverkade härstamning

måttliga ensiffriga vinster på vissa bitvisa sökvägar

tydliga medelstora vinster på additioner och aktiveringar

starka stora vinster på flera matris- och vektorsökvägar

paritetsceller på samma nivå förblir synliga, inte raderade

vad som blir möjligt när innebörden överlever

en matrismultiplikation går in med tio kända fakta

varje konventionell sänkningsfas släpper flera kort

Core Native körs med Rust-inbyggd exekvering

Core på Kera visar graf- och kompilatorlager

den inbyggda banan är inte gjord för att se trasig ut

en nod misslyckas och återställs från kontrollpunkt

en odeklarerad nätverkskant blockeras vid planering

varje gräns har tydlig kapacitet och operatörskontroller

Ingen direkt Kera-åtkomst i hanterad Fabric

Samma semantiska graf genereras inom vilken gräns du än väljer.

tre mellanprodukter borttagna, två regioner sammanslagna, ett värde behålls på enheten

en besparingslist räknar start, allokeringar, överföringar och borttagna byte

varje torn bär en publicerad-med-harness-stämpel, ingen påhittad hårdvara

operationsetiketter faller bort vid varje IR-steg

etiketter överlever till målspecifik maskinkod

endast en känner fortfarande till operationen

öppna följeslagsprojekt ligger utanför den kommersiella gränsen

den konventionella banan kopierar över sex minnesutrymmen

en ägartoken följer med varje förflyttning

Keras kedja med en ägare från graf till maskin

den externa drivrutinsgränsen ligger vid kanten

egenskaper sprids endast genom den faktiskt licensierade banan

för det resulterande systemet till människor

kognition, organisationer, kunskap, beräkning

AI-operationer, träning, inferens, servering

varje plan länkar tillbaka till samma graf-hash

ingenting av uppgiften går förlorat på vägen

samma jobbkort är anpassat med en annan plan för varje

suveränitet beror på hela uppsättningen, inte bara geografi

användaren ser den överenskomna Fabric-funktionen ovanför

hanterad Fabric på den offentliga Dweve Mesh; ingen direkt Kera-åtkomst

Fabric på den offentliga Mesh inom dess avtalade behandlingsgräns

vissa steg går mycket snabbare än den vanliga vägen

ett fåtal fall är för närvarande lika snabba

en kortare stapel innebär kortare väntetid

en uppgift tar en lång zigzag genom översättningsrutor

Kera-vägen förblir en tydlig plan från jobb till maskin

maskinen tar emot arbete som är gjort för den

en ändrad åtgärd skapar ett nytt fingeravtryck

vilken maskinplan som valdes registreras

ett offline-system kan vägra nätverksåtkomst

Fabric och produkterna ligger ovanpå Core

extern hårdvara och operativsystem ligger i utkanten

ett recept som förs vidare genom människor förlorar sitt syfte

i Kera förblir syftet kopplat till stegen

köket kan fortfarande fatta förnuftiga val

färre fördröjningar och lägre strömförbrukning

den djupare vägen, där licensen tillåter

en strikt uppgift ger samma mönster varje gång

en kreativ uppgift tillåter olika mönster

ingen oavsiktlig förändring på en annan maskin

en genomskärning visar Kera-planen och maskinarbetet nedanför

det finns inga Kera-kontroller i vanlig användning

den direkta vägen ligger kvar under ytan

orangea celler markerar uppmätta vinster

konturerade celler markerar väntande analys

inspektera vilka fakta som orsakade skillnaden

okända paketceller förblir beskrivna tills paketeringen är slutgiltig

en kärnoperationsnod går in i Kera-planen

där Kera saknas förblir Core Rust-nativt

LLVM-banan är helt enkelt frånvarande, inte överstruken teatraliskt

Ingen LLVM IR-etapp ligger i centrum. Varje steg bevarar graf- och operationssemantik.

den valda sökvägen skrivs till körningsposten

ring all-reduce kopplar samman partitionerna

effektfulla noder passerar genom kapacitetsgrindar

en odeklarerad kapacitet avvisas av verifieraren

separata regioner med materialiserade mellanresultat

each bar carries an exact test-scope chip, no invented hardware

results differ by hardware, published with the harness

varje sändning använder en annan vektorbredd

nya hashvärden förökas endast genom den påverkade härstamningen

oförändrade subgrafer behåller sin identitet

token korsar värd-, enhets- och fjärrutrymmen

planeraren behåller värdet där det hör hemma

generiska liveintervall utan operationskontext

upprullning, vektorbredd och spills valda från operationen

varje mål bär sin egen genererade artefakt

kontrollera, bygga, inspektera, planera, köra, verifiera

den gemensamma orsaken är bevarad semantisk information

Kera håller operationer, effekter, ägande och rörelse synliga från källgrafen till exekvering på målet. Läs arkitekturen, inspektera grafens IR, eller ta med en produktionssökväg som redan har optimerats genom LLVM.

Direkt beräkning. Grafen förblir programmet.

Ring allreduce, kontrollpunktsåterställning

x86-64 (SSE2/AVX2/AVX-512), ARM64 (NEON), RISC-V (Vector)

Kera är ett statiskt typat systemprogramspråk med en grafbaserad, innehållsadresserad IR. Det kompilerar program till .keg-filer, riktade acykliska grafer av operationer, och exekverar dem på CPU, GPU, FPGA och WASM. Kera använder egen kodgenerering för x86-64, ARM64 och RISC-V istället för LLVM, med registerallokering och val av SIMD-kärnor. Sideffekter spåras, och ägande i Rust-stil sträcker sig över värd-, enhets-, pinnad och enhetligt minne. Projektet är en Rust-arbetsyta med distribuerad exekvering, kapacitetsbaserad säkerhet och LSP-verktyg.

Ta med operationen, formerna, målet, flaggorna och determinismkraven du använder i produktion. Vi jämför den genererade sökvägen och visar var bibehållandet av grafen ändrar resultatet.

Kera kombinerar ett grafbaserat systemprogramspråk, en innehållsadresserad IR, en kompilator, en JIT och ett heterogent exekveringssystem. Det håller typer, effekter, ägande, dataflöde, minnesutrymmen och exekveringspolicy synliga samtidigt som det producerar målspecifika planer för stödda CPU-, GPU-, FPGA- och WebAssembly-sökvägar. LLVM är inte i centrum av kompileringskedjan.

Kera prissätts separat för licensierade distributioner. Prata med oss om målportföljen, isolerad drift och eventuella separat valda rättigheter för källkod, granskning eller tekniköverföring.

Beräkningen behåller sin identitet till maskinen.

Inbyggd maskinkod via en egen JIT-kompilator

Dweve AI-inferens- och simuleringsarbetsbelastningar

Programspråk för konsekvent, snabb beräkning

Programvara passerar ofta genom så många översättningslager att datorn inte längre ser jobbet som en helhet. Kera håller beräkningen organiserad som en graf och förbereder sedan en exekveringsplan för maskinen som utför arbetet. Det kan ta bort onödiga steg, minska rörelse och lämna en tydligare logg över vad som faktiskt kördes.

Dweve Kera är ett grafbaserat systemspråk och en kompilator för deterministisk beräkning på heterogen hårdvara. Dess statiskt typade, innehållsadresserade mellanrepresentation håller operationen synlig genom planeringen och genererar sedan exekvering för CPU, GPU, FPGA och WebAssembly. Grafen förblir programmet.

En generell kompilator måste tjäna alla typer av programvara. Dess bredd begränsar hur djupt den kan förstå en specialiserad operation när en frontend har sänkt ner den i loopar, pekare och generisk aritmetik, och inget senare steg kan återställa det som sänkningen tog bort.

Operationsidentitet, algoritmer, packningsavsikt, förväntade former, determinism och minnesägande kan spridas över verktyg innan slutlig optimering. Kostnaden är varje användbart val som blir omöjligt när beräkningen har glömt vad den var.

Matrismultiplikationen blir anonyma loopar.

Förväntade tensor- och vektorformer försvinner.

Ackumulator- och packningsavsikt är borta.

Regler för värd- och enhetsminne faller bort.

Relationen mellan operationer klipps av.

den första fördelen är inte en snabbare instruktion

det är att komma ihåg vad instruktionerna är till för

Kera håller dessa fakta fästa vid operationen.

Kera representerar beräkning som en typad graf. En operation förblir en operation istället för att bli anonym lågnivåkod för tidigt. Dess inmatningar, utmatningar, former, effekter, ägande, minnesutrymmen och exekveringspolicy förblir fästa vid den.

Behållen kontext låter Kera välja från operationen själv, slå samman relaterat arbete över grafen och planera förflyttning från deklarerat ägande. En generisk kedja måste sluta sig till dessa fakta från lågnivåmönster efter att de har gått förlorade, vilket är varför samma källkod kan kompileras till mycket olika maskinbeteende beroende på hur mycket innebörd som överlevde resan.

En vektorlogaritm förblir en vektorlogaritm

Den deklarerade fixpunktsprofilen behålls