{"kera-hero-glyph.63f5b4e967":"bit-for-bit · 6 targets","kera-hero-glyph.7f5bc5b5e0":"4 ops · 1 graph","kera-hero-glyph.6757848af7":"DETERMINISTIC","kera-hero-glyph.b7e402267d":"xmm0, xmm1, xmm2","kera-hero-glyph.7c1edc585e":"KERA:GRAPH · 9f4c2a","kera-hero-glyph.271973aefe":"xMidYMid meet","kera-hero-glyph.c914763746":"directed acyclic","kera-hero-glyph.4b0bb22353":"graph IR","kera-hero-glyph.8b201083a7":"pure · no LLVM · no GC","kera-hero-glyph.14878f89f6":"Compiled","kera-hero-glyph.7be5de5882":"graph-native compiler ·","kera-hero-glyph.1a2e6a35a3":"Dweve Kera [v1.0.0]","kera-hero-glyph.61cc55aa04":"Xor","kera-hero-glyph.84acd8bc95":"Xor","kera-business-glyph.b57dd9805c":"All rights reserved","kera-business-glyph.a92831c31f":"Built in the Netherlands","kera-business-glyph.3fe9901ae8":"Same program runs on","kera-business-glyph.8cdde04eea":"With Kera","kera-business-glyph.56d5a5605b":"Without Kera","kera-business-glyph.8ac7aa173f":"What you get","kera-business-glyph.08b22e1ba0":"One contract","kera-business-glyph.d5f412e831":"Kera","kera-business-glyph.005fd98d0b":"Outcomes board","kera-business-glyph.4e946026a7":"WASM","kera-business-glyph.cef7f9bd36":"FPGA","kera-business-glyph.a6a6318544":"GPU","kera-business-glyph.ff221d4752":"CPU","kera-business-glyph.13eda1aa9b":"None, all explicit","kera-business-glyph.b0c6296753":"Undefined behaviour","kera-business-glyph.ad05929824":"Runtime surprises","kera-business-glyph.20fe0bc90a":"Reproducible by design","kera-business-glyph.38c0a17432":"Hard to reconstruct","kera-business-glyph.9f2fd37a9c":"Audit and replay","kera-business-glyph.a8565e2ba8":"One language, every chip","kera-business-glyph.84544ee5cb":"Rebuilt per vendor","kera-business-glyph.bcb0410330":"Compute targets","kera-business-glyph.287bfff429":"Identical, bit for bit","kera-business-glyph.e6f3dca8fa":"Vary by machine","kera-business-glyph.ebf7bdcae3":"Results across hardware","kera-consumer-glyph.5e31591036":"Always the same. Nothing to learn.","kera-consumer-glyph.f7e1292a46":"Followed anywhere","kera-consumer-glyph.d5f412e831":"Kera","kera-consumer-glyph.ba434a333f":"The same recipe","kera-consumer-glyph.5ef71c13ae":"Get the same result","kera-consumer-glyph.8261302aee":"Follow them in order","kera-consumer-glyph.e901eb3303":"Take the same steps","kera-consumer-glyph.ab1f9ad6b1":"at work","kera-consumer-glyph.8b8c5250f8":"On a big machine","kera-consumer-glyph.48e83d5768":"on the go","kera-consumer-glyph.f3a96713b7":"On a phone","kera-consumer-glyph.775c9eb98b":"at home","kera-consumer-glyph.e3cde12066":"On a laptop","aura-ask-grid.af0854de67":"Aura","aura-business-sides.a0853da24b":"Spec sheet","aura-business-visuals.40417391c5":"Aura · resolves","aura-business-visuals.271973aefe":"xMidYMid meet","aura-business-visuals.3e91add48a":"BOARD","aura-showcase.eyebrow":"Dweve platform","aura-showcase.subtitle":"Coding agent and operator assistance. Demo metrics are illustrative.","aura-showcase.pillTools":"25+ tools","aura-showcase.pillRunning":"running","aura-showcase.pillAnalysing":"analysing codebase","aura-showcase.capabilityToolsTitle":"25+ tools","aura-showcase.capabilityToolsBody":"Terminal, search, lint, test, git, and more.","aura-showcase.capabilityMemoryTitle":"Semantic memory","aura-showcase.capabilityMemoryBody":"Remembers your codebase and team context.","aura-showcase.capabilityAgentsTitle":"Multi-agent orchestration","aura-showcase.capabilityAgentsBody":"Specialised agents collaborate across concerns.","aura-showcase.guaranteeAuditTitle":"Audit trail","aura-showcase.guaranteeAuditBody":"Every step is recorded with timestamps.","aura-showcase.guaranteeGuardrailsTitle":"Guardrails","aura-showcase.guaranteeGuardrailsBody":"Policies, checks, and tests always run.","aura-showcase.guaranteeApprovalTitle":"Code changes with approval","aura-showcase.guaranteeApprovalBody":"Review diffs, request changes, final sign-off.","aura-showcase.guaranteeReplayTitle":"Deterministic replay","aura-showcase.guaranteeReplayBody":"Replay any session bit-for-bit when something needs review.","aura-showcase.workflowUnderstand":"Understand","aura-showcase.workflowUnderstandCaption":"Read retry.ts, traced timeout bug","aura-showcase.workflowPlan":"Plan","aura-showcase.workflowPlanCaption":"Extract guard + cap retries","aura-showcase.workflowImplement":"Implement","aura-showcase.workflowImplementCaption":"Patched retry.ts + types.ts","aura-showcase.workflowTest":"Test","aura-showcase.workflowTestCaption":"28 tests, 94% coverage","aura-showcase.workflowVerify":"Verify","aura-showcase.workflowVerifyCaption":"Running lint & typecheck...","aura-showcase.workflowAudit":"Audit","aura-showcase.workflowAuditCaption":"Awaiting summary write-up","aura-showcase.footer":"Autonomous agents that write code and keep receipts","aura-showcase.testsPassing":"passing","aura-showcase.testsFailing":"failing","aura-showcase.modified":"modified","aura-showcase.af0854de67":"Aura","aura-showcase.73989d9c59":"Running","aura-showcase.f9e94338d0":"Analyzing codebase","aura-showcase.d7a484140f":"Workflow","aura-showcase.287fda8114":"Unified","aura-showcase.80e13549b4":"Coverage","aura-showcase.b71cc78b34":"Extracted isRetryableError","aura-showcase.c37a8a9e2b":"to handle\n                    network timeouts, 5xx responses, and idempotent-safe\n                    conditions. Pure helper, fully unit-tested.","aura-tech-middles.7fba7d244f":"Hot path","aura-tech-middles.1be47ef71c":"Cross-cutting","aura-tech-middles.92096d78df":"Ingress","aura-tech-middles.8e05a902ed":"Egress","aura-tech-middles.49a66c994d":"Builtin agents","aura-tech-middles.a60792e996":"Outer loop","aura-tech-middles.0dfd4db698":"Inner loop","aura-tech-middles.bbd88bff92":"Incoming request","aura-tech-middles.a618b4be8d":"Query","aura-tech-middles.a4942c26d0":"SELECT","aura-tech-middles.2cb479aa15":"* FROM","aura-tech-middles.1c255b91e7":"WHERE","aura-tech-middles.2164bde64d":"ORDER BY","aura-tech-middles.82dd2cdf36":"Block","aura-tech-middles.271973aefe":"xMidYMid meet","core-extras.96d330537a":"Base IR","core-extras.bee831a169":"Substrate","core-extras.61a0822826":"Apps on Core","core-extras.15438cc098":"not supported","core-extras.ad565d9d01":"Feature","core-extras.0155bf03e5":"Segment legend","core-extras.8b7110078e":"Algorithm groups by data type","core-extras.25ab4276a6":"Scrollable capability matrix","kera-b-asset.f97c480441":"Build certificate","kera-b-asset.74c70e83a9":"addressed","kera-b-asset.22f8f5ecc3":"identity by content","kera-b-asset.2827efb084":"graph hash","kera-b-asset.73efba54ac":"node count","kera-b-asset.87bcfbb151":"declared effects","kera-b-asset.e87e846a2b":"exports","kera-b-asset.f5e4814953":"approved plans","kera-b-asset.dde2d174a7":"one changed node rekeys only its affected ancestry","kera-b-asset.6bddc96786":"the artefact is inspectable","kera-b-asset.20cfe8fa86":"before it is executable","kera-b-asset.f4803cfafc":"model.keg","kera-b-asset.b192e7faea":"affected ancestry","kera-b-asset.47156feb2e":"changed node","kera-b-asset.6bb2bf4b4b":"rekeyed","kera-b-asset.11a434ae48":"unchanged, identity kept","kera-b-asset.5d2b90a4c4":"sealed","kera-b-asset.95c04d945d":"content types","kera-b-asset.e851b910d1":"toolchain","kera-b-asset.2f2afa2d7c":"target plan","kera-b-asset.67c48841e8":"approved and pinned","kera-b-broad-bench.65eec5b311":"Operation map","kera-b-broad-bench.53861851a1":"honest","kera-b-broad-bench.8e7f031701":"wins and parity","kera-b-broad-bench.ababc1589c":"modest single-digit gains on some bitwise paths","kera-b-broad-bench.76445c8888":"clear medium gains on additions and activations","kera-b-broad-bench.6aad2ced77":"strong large gains on several matrix and vector paths","kera-b-broad-bench.7f1700f4aa":"level parity cells stay in view, not deleted","kera-b-broad-bench.cf1e25eb23":"unrelated operation families","kera-b-broad-bench.b1382f21f1":"neutral cells stay on the map","kera-b-broad-bench.1910fc39f0":"bitwise","kera-b-broad-bench.9913b746d0":"additions","kera-b-broad-bench.9afd89eb88":"activations","kera-b-broad-bench.72bdf2267c":"vector maths","kera-b-broad-bench.d15695348c":"matrix paths","kera-b-broad-bench.89f6229a11":"small","kera-b-broad-bench.20af418657":"medium","kera-b-broad-bench.5296d5cced":"large","kera-b-broad-bench.e35064c4a7":"band legend","kera-b-close.9e3c1d591d":"Evidence base","kera-b-close.100ec4462d":"evidence","kera-b-close.d6fa024673":"the business band","kera-b-close.4e306c16e8":"content-addressed graph","kera-b-close.6c7b5aa685":"custom JIT","kera-b-close.b4abc3fba1":"no LLVM centre","kera-b-close.bee075373f":"benchmark harness","kera-b-close.d55b905b16":"target-specific plans","kera-b-close.19f0c7e744":"bring the code already optimised","kera-b-close.aeca9cf8b9":"what becomes possible when meaning survives","kera-b-close.f76b5196b3":"the evidence, in one band","kera-b-compiler-tax.1a0b4466b0":"Semantic ledger","kera-b-compiler-tax.f096faa634":"lowered","kera-b-compiler-tax.0f98f33370":"ten facts in, three out","kera-b-compiler-tax.961a2157ea":"a matrix multiplication enters with ten known facts","kera-b-compiler-tax.622278635a":"each conventional lowering stage drops several cards","kera-b-compiler-tax.5f20f7eb31":"the Kera lane retains every card","kera-b-compiler-tax.937e59b151":"loops, pointers, arithmetic remain","kera-b-compiler-tax.925d913e85":"the meaning has already gone","kera-b-compiler-tax.19c2173bd9":"operation matmul","kera-b-compiler-tax.3d878661c3":"Q16.16 inputs","kera-b-compiler-tax.39ec9629c4":"shape 512x512","kera-b-compiler-tax.03287dce1d":"row-major layout","kera-b-compiler-tax.f3266ee839":"accuracy contract","kera-b-compiler-tax.b67c6fe021":"pure effect","kera-b-compiler-tax.39e98cba2f":"device region","kera-b-compiler-tax.9408245670":"fusion candidate","kera-b-compiler-tax.67ba446843":"tile hint","kera-b-compiler-tax.fb1a4a9f3b":"reduction axis","kera-b-compiler-tax.5062a63a99":"conventional","kera-b-compiler-tax.d5f412e831":"Kera","kera-b-compiler-tax.3c45c4ff87":"typed IR","kera-b-compiler-tax.27d4c58d54":"LLVM IR","kera-b-compiler-tax.7817c52b25":"machine","kera-b-compiler-tax.29560f4f08":"ten kept","kera-b-compiler-tax.e973463ad8":"three kept","kera-b-core-boundary.a36f7c719b":"Core boundary","kera-b-core-boundary.94d5cab6f5":"split","kera-b-core-boundary.c6187a973a":"Native and on Kera","kera-b-core-boundary.64e25677ba":"Core Native runs on Rust-native execution","kera-b-core-boundary.2b84aa2490":"Core on Kera reveals graph and compiler layers","kera-b-core-boundary.7c6c36fe1e":"the Native lane is not made to look broken","kera-b-core-boundary.fb29360100":"Core owns AI","kera-b-core-boundary.d11e0dac41":"Kera owns computation","kera-b-core-boundary.68836c550e":"Core","kera-b-core-boundary.b14e0fee60":"Core Native","kera-b-core-boundary.5bd7bdd9b6":"Core on Kera","kera-b-core-boundary.fb90a11e35":"Rust-native execution","kera-b-core-boundary.0e9de4489d":"graph layer","kera-b-core-boundary.4f98764559":"compiler layer","kera-b-core-boundary.1b220bd030":"both lanes healthy","kera-b-core-boundary.3246d9cb0f":"Operation kernels","kera-b-core-boundary.ce5ecbbe49":"Native dispatch","kera-b-core-boundary.2270cfaf8d":"Serving","kera-b-core-boundary.73664268f4":"Semantic graph","kera-b-core-boundary.47a222732e":"Whole-graph planner","kera-b-core-boundary.0dbb3d000f":"Direct emit","kera-b-core-boundary.2b8a5898ca":"Target runtime","kera-b-core-boundary.fad0aa71a0":"complete AI machine","kera-b-determinism.06d1e9b0c2":"Planning lanes","kera-b-determinism.f4d06ebbbc":"contracted","kera-b-determinism.0dde78e885":"strict, seeded, creative","kera-b-determinism.36f3cdb23b":"strict yields a stable hash","kera-b-determinism.580037974e":"seeded yields one hash per seed","kera-b-determinism.d00475d316":"creative yields a distribution","kera-b-determinism.08c4c0cd04":"determinism before emit","kera-b-determinism.d14aee9a61":"not bolted on afterwards","kera-b-determinism.41eaab877c":"strict","kera-b-determinism.9ad3dc4c49":"seeded","kera-b-determinism.df0b6c410f":"creative","kera-b-determinism.36751333ac":"one stable hash","kera-b-determinism.57e908bc7f":"one hash per seed","kera-b-determinism.40ddc71464":"a distribution","kera-b-determinism.92713d4709":"seed","kera-b-determinism.807f3dfc66":"chosen before emit","kera-b-determinism.5a3931973a":"plan contract","kera-b-determinism.18ca194aa0":"arithmetic","kera-b-determinism.428ac48133":"ordering","kera-b-determinism.b43cc86e50":"reduction","kera-b-determinism.86e8628e95":"scheduling","kera-b-distribution.40427b2f6c":"Distributed graph","kera-b-distribution.71a4dfeb01":"partitioned","kera-b-distribution.8de4e2bf20":"ring all-reduce","kera-b-distribution.95560431a3":"the graph is partitioned across four nodes","kera-b-distribution.fe6f32a769":"a ring all-reduce connects them","kera-b-distribution.c83c5e4a5d":"one node fails and restores from checkpoint","kera-b-distribution.0f988213f6":"the graph identity does not change","kera-b-distribution.473750f60a":"scale changes the plan","kera-b-distribution.1b2a43df7f":"it does not erase the programme","kera-b-distribution.439d3cf188":"node 1","kera-b-distribution.2112318fa1":"node 2","kera-b-distribution.66d45e923f":"node 3","kera-b-distribution.d17cf66672":"node 4","kera-b-distribution.5f5f8758f5":"failed","kera-b-distribution.98ad765b8a":"restored from checkpoint","kera-b-distribution.2f4e868ab3":"graph identity unchanged","kera-b-distribution.88faac11da":"partition","kera-b-distribution.7f57971b3f":"all-reduce","kera-b-distribution.8b60e9d739":"recovery","kera-b-distribution.84bd2b0362":"graph identity","kera-b-effects.71066ac592":"Effect boundaries","kera-b-effects.18cd42d86d":"gated","kera-b-effects.84e0542d83":"declared surface","kera-b-effects.663592445a":"a pure calculation core","kera-b-effects.56599b6bb6":"effect gates surround it","kera-b-effects.566e5ac608":"an undeclared network edge is blocked during planning","kera-b-effects.ca08403ba5":"nothing hides below a library","kera-b-effects.b8e371e84c":"the surface is approved before it runs","kera-b-effects.cd43804ec9":"pure core","kera-b-effects.a1f13b3bc2":"files","kera-b-effects.c112e88173":"network","kera-b-effects.728190e74d":"devices","kera-b-effects.b01d01d841":"stored data","kera-b-effects.0baff051a0":"declared","kera-b-effects.df88b84d81":"blocked","kera-b-effects.32ce9a3a4a":"checked during planning","kera-b-european.77201a8d49":"Shared boundaries","kera-b-european.2fbc9f0c9f":"posture","kera-b-european.3297d44b54":"operator controls","kera-b-european.1f300b9430":"Dweve-operated service boundary","kera-b-european.f86d095f61":"customer-controlled","kera-b-european.53354e1327":"air-gapped","kera-b-european.4cb472e7df":"each boundary carries explicit capability and operator controls","kera-b-european.8e1eb95c49":"control below the service layer","kera-b-european.557bd29aa2":"built in Europe","kera-b-european.d85bc3cdeb":"one graph","kera-b-european.825367fe0f":"capability set","kera-b-european.b4197b664a":"No direct Kera access in managed Fabric","kera-b-european.d34de16aee":"The same semantic graph is emitted inside whichever boundary you choose.","kera-b-graph-plan.6c249b5199":"Planning view","kera-b-graph-plan.80e61027a7":"planned","kera-b-graph-plan.436b07330c":"work removed","kera-b-graph-plan.00dad1e83b":"the raw graph runs each pass separately","kera-b-graph-plan.1a50b0bffd":"three intermediates removed, two regions fused, one value kept on device","kera-b-graph-plan.6de719ca8c":"a savings rail counts launches, allocations, transfers, and bytes removed","kera-b-graph-plan.0d9db1ed4f":"not a shorter instruction stream","kera-b-graph-plan.f023d0f4cd":"work that never has to exist","kera-b-graph-plan.5ee6ebe229":"raw graph","kera-b-graph-plan.5b08cad7e5":"planned graph","kera-b-graph-plan.4928016aa1":"launches","kera-b-graph-plan.8ea14a80a0":"allocations","kera-b-graph-plan.f060b62b91":"transfers","kera-b-graph-plan.bfc3d8ebd1":"bytes moved","kera-b-graph-plan.e64fa1d1fa":"fused region","kera-b-graph-plan.69992f1747":"removed","kera-b-graph-plan.7d3b8e5199":"kept on device","kera-b-graph-plan.ce03a80127":"intermediate","kera-b-headline-bench.dd5614a067":"Benchmark towers","kera-b-headline-bench.2280127c38":"operation-specific","kera-b-headline-bench.c8aa37d49d":"published with the harness","kera-b-headline-bench.5490337de8":"vector logarithm","kera-b-headline-bench.7fe27285ff":"matrix multiplication","kera-b-headline-bench.32d60758c5":"vector exponential","kera-b-headline-bench.bc27c37274":"vector tanh","kera-b-headline-bench.a8608fb146":"binary dot product","kera-b-headline-bench.7c3d7b5aef":"each tower carries a publish-with-harness seal, no invented hardware","kera-b-headline-bench.654165a28b":"operation and shape specific","kera-b-headline-bench.4899c7a1d5":"the baseline is not the ceiling","kera-b-headline-bench.9a0924fc89":"LLVM baseline","kera-b-headline-bench.9d9c0e6f52":"Kera lead","kera-b-headline-bench.5296d5cced":"large","kera-b-headline-bench.20af418657":"medium","kera-b-headline-bench.0a1784bfd3":"modest","kera-b-headline-bench.b8c83489e9":"qualitative, no fixed number","kera-b-headline-bench.8cf0839c32":"baseline is not the ceiling","kera-b-hero.e1dd48620c":"Direct route","kera-b-hero.bc175d397c":"retained","kera-b-hero.1593a101ec":"graph to machine","kera-b-hero.abf0197063":"Conventional lane","kera-b-hero.6d58c9b823":"operation labels fall away at each IR stage","kera-b-hero.ab4dc95c08":"Kera lane","kera-b-hero.59b1f9bb94":"labels survive to target-specific machine code","kera-b-hero.7ceff13d3c":"both paths are optimised","kera-b-hero.52e878b00c":"only one still knows the operation","kera-b-hero.828d338a9b":"source","kera-b-hero.2697456472":"typed AST","kera-b-hero.9c45db2698":"generic IR","kera-b-hero.27d4c58d54":"LLVM IR","kera-b-hero.f973434496":"machine code","kera-b-hero.29a184b65c":"graph","kera-b-hero.bed97175b0":"plan","kera-b-hero.2e96e89125":"emit","kera-b-hero.c88d5c8185":"log kept","kera-b-hero.52718563ec":"log lost","kera-b-hero.ef926f2249":"operation label at each stage","kera-b-licence.e911fc011c":"Agreement rings","kera-b-licence.bd91cf7186":"licensed","kera-b-licence.a42cfbcc4d":"companions outside","kera-b-licence.455d8b2ce4":"runtime rights","kera-b-licence.3873951ef2":"support and escrow","kera-b-licence.cd3d98f77c":"source and transfer","kera-b-licence.c9152822d6":"open companion projects sit outside the commercial boundary","kera-b-licence.02b775d449":"the deepest path is licensed","kera-b-licence.72a283c425":"responsibility is contractual","kera-b-licence.3ccd56a930":"Kera graph","kera-b-licence.5ba2c895f6":"commercial boundary","kera-b-licence.3f8fe9ab88":"open companion crates","kera-b-licence.b860e3cf6c":"separate Apache 2.0 projects","kera-b-licence.1dd735263a":"inside the boundary","kera-b-movement.5cfaff45b4":"Value movement","kera-b-movement.c6dda4f283":"owned","kera-b-movement.0b34c48e88":"an ownership token follows","kera-b-movement.728fbdcfe4":"the conventional lane copies across six memory spaces","kera-b-movement.24800e1a4d":"the Kera plan keeps it in two","kera-b-movement.7a06da081d":"an ownership token follows every move","kera-b-movement.d1589923cd":"a removed transfer is faster","kera-b-movement.96f832e6a6":"an illegal transfer is rejected","kera-b-movement.cff4c28e03":"conventional lane","kera-b-movement.a4fe9b7d60":"Kera plan","kera-b-movement.ec7e36ec8e":"host RAM","kera-b-movement.cdc203d6a2":"L2 cache","kera-b-movement.033f3a6022":"staging buffer","kera-b-movement.44afa23dac":"device HBM","kera-b-movement.96005d847c":"peer device","kera-b-movement.c8e445a3b3":"remote node","kera-b-movement.f84e2e2dad":"copy","kera-b-movement.579233b2c4":"owner","kera-b-movement.6e970962bc":"spaces crossed","kera-b-movement.cf51f41279":"copies removed","kera-b-movement.2405c11aa5":"ownership token","kera-b-one-chain.25f2389ba6":"Ownership chain","kera-b-one-chain.c6dda4f283":"owned","kera-b-one-chain.2c93278b5e":"external edge drawn","kera-b-one-chain.592b55e943":"a conventional multi-owner chain","kera-b-one-chain.8b64563b06":"the Kera one-owner graph-to-machine chain","kera-b-one-chain.e1421d3ef7":"the external driver boundary stays at the edge","kera-b-one-chain.9b1aa0c24f":"no generic compiler in the centre","kera-b-one-chain.d055fce23b":"Dweve owns the path","kera-b-one-chain.1d2176455e":"multi-owner chain","kera-b-one-chain.f3308165f8":"one-owner chain","kera-b-one-chain.3a8aea960f":"language frontend","kera-b-one-chain.a230d4a668":"LLVM","kera-b-one-chain.fcdc9b06b4":"vendor backend","kera-b-one-chain.fdda0c46f9":"driver","kera-b-one-chain.1bbe39f6af":"Dweve","kera-b-one-chain.81bbb36f63":"external driver","kera-b-one-chain.a71c7a3bf4":"external boundary","kera-b-one-chain.c74bb33279":"owners","kera-b-one-chain.cbf8a89045":"handoffs","kera-b-one-chain.cd9412079a":"external edge","kera-b-operation-kept.7fc7df93e0":"Open graph node","kera-b-operation-kept.bda4b1c3ce":"typed","kera-b-operation-kept.5490337de8":"vector logarithm","kera-b-operation-kept.89f23b757c":"operation identity","kera-b-operation-kept.f978be8c13":"Q16.16 type","kera-b-operation-kept.561d6cea98":"shape range","kera-b-operation-kept.f3266ee839":"accuracy contract","kera-b-operation-kept.b67c6fe021":"pure effect","kera-b-operation-kept.08e909df94":"memory region","kera-b-operation-kept.530fb56a28":"candidate emit strategies","kera-b-operation-kept.3597058511":"adjacent fusion opportunity","kera-b-operation-kept.400565f394":"the node still knows what it is","kera-b-operation-kept.31a9fa0ab7":"the planner reads every field","kera-b-operation-kept.110e4595c0":"vlog.q16_16","kera-b-operation-kept.028bb9f8fc":"Q16.16","kera-b-operation-kept.d793050058":"1 to 1e6","kera-b-operation-kept.5829b9ee06":"1 ulp bound","kera-b-operation-kept.afe003f117":"pure","kera-b-operation-kept.f3a929b336":"device","kera-b-operation-kept.49338082a1":"three strategies","kera-b-operation-kept.37a17aada7":"add adjacent","kera-b-operation-kept.592acef0e8":"graph node","kera-b-operation-kept.2591f02eba":"planner reads every field","kera-b-stack.b01706e604":"Dweve stack","kera-b-stack.e4e5f91807":"layered","kera-b-stack.70ab7c7007":"split Core lanes","kera-b-stack.d5f412e831":"Kera","kera-b-stack.9e0bd0c046":"Core Native and Core on Kera","kera-b-stack.831292b7ab":"Loom, Nexus, Spindle, Mesh","kera-b-stack.a010de5c61":"Fabric","kera-b-stack.fe5197e677":"properties propagate only through the lane actually licensed","kera-b-stack.bd84200bf2":"the direct path beneath Dweve","kera-b-stack.b196ef25a9":"included where the agreement requires it","kera-b-stack.b14e0fee60":"Core Native","kera-b-stack.5bd7bdd9b6":"Core on Kera","kera-b-stack.ca8127904f":"licensed lane","kera-b-stack.68836c550e":"Core","kera-b-stack.b982f78b9a":"user surface","kera-b-stack.fbdc4f23f9":"products","kera-b-stack.fad0aa71a0":"complete AI machine","kera-b-stack.efdc51f1b1":"direct computation","kera-b-stack.18f5777dbe":"brings the resulting system to people","kera-b-stack.ee865eaadb":"cognition, organisations, knowledge, compute","kera-b-stack.9acad64e74":"AI operations, training, inference, serving","kera-b-stack.ae10bcb7a5":"graph, planner, direct emit, runtime","kera-b-targets.bbd997781a":"Target plans","kera-b-targets.600f021001":"fanned","kera-b-targets.8d6aab053e":"same graph hash","kera-b-targets.15d1a50cbb":"CPU plan","kera-b-targets.9427def3f0":"GPU plan","kera-b-targets.d61de44366":"FPGA plan","kera-b-targets.8c7d3b50dd":"WebAssembly plan","kera-b-targets.125e4a24e6":"distributed plan","kera-b-targets.e93db8e874":"every plan links back to the same graph hash","kera-b-targets.8b1b2c8e37":"the target gets its own plan","kera-b-targets.b1cd1db39d":"the programme keeps its identity","kera-b-targets.2827efb084":"graph hash","kera-b-targets.a7f146f80d":"AVX-512 object","kera-b-targets.98eea40d70":"PTX kernel","kera-b-targets.21837c3f11":"bitstream","kera-b-targets.8e10c79a8e":"wasm module","kera-b-targets.e00fd7a84d":"shard plan","kera-c-close.75e4aedce4":"checked","kera-c-close.36a247b5b4":"What stays true","kera-c-close.100ec4462d":"evidence","kera-c-close.f123a39d1f":"the consumer band","kera-c-close.300286f8a6":"the job stays whole","kera-c-close.d37ede566b":"a plan made for the machine","kera-c-close.3958159663":"a clear identity","kera-c-close.296898b104":"declared abilities","kera-c-close.0193e423dd":"you use the product","kera-c-close.282ff2f4ae":"Kera shortens the path underneath","kera-c-close.2b424dff92":"kept true underneath","kera-c-close.b94fa12fd8":"nothing about the task is lost on the way","kera-c-close.0ebee22faf":"the machine receives work shaped for it","kera-c-close.65e4d792e0":"the exact job carries a fingerprint","kera-c-close.9c2aaf489c":"what the work may touch is stated","kera-c-different-machines.5e05dfc33e":"One job, four machines","kera-c-different-machines.80c656bf28":"fitted","kera-c-different-machines.8ebb878534":"a plan for each","kera-c-different-machines.e068381bbd":"laptop","kera-c-different-machines.f38edbd4e7":"graphics chip","kera-c-different-machines.ef98362b8a":"browser","kera-c-different-machines.d32519b8a9":"specialised hardware","kera-c-different-machines.965f74c477":"the same job card is fitted with a different plan for each","kera-c-different-machines.a0155e0dfd":"the plan changes","kera-c-different-machines.1309986996":"the job does not","kera-c-different-machines.f0845ffef0":"one job card","kera-c-different-machines.bed97175b0":"plan","kera-c-different-machines.f2feb3bb38":"small, careful steps","kera-c-different-machines.d053fbd7ee":"many steps at once","kera-c-different-machines.92e1e780ab":"safe, portable steps","kera-c-different-machines.a330cd4922":"shaped to the chip","kera-c-different-machines.0aa5c091a7":"fits the machine","kera-c-european.77201a8d49":"Job protection","kera-c-european.2fbc9f0c9f":"posture","kera-c-european.71c70d7ed0":"where licensed","kera-c-european.f040b08e8f":"Dweve-operated boundary","kera-c-european.fd412c3f7a":"organisation-controlled","kera-c-european.1b84995dfa":"isolated","kera-c-european.b7ea322a91":"sovereignty depends on the full setup, not geography alone","kera-c-european.70335a5664":"control below the visible app","kera-c-european.80383a4551":"the user sees the agreed Fabric capability above","kera-c-european.d85bc3cdeb":"the whole job","kera-c-european.5a1f79cac7":"managed Fabric on the public Dweve Mesh; no direct Kera access","kera-c-european.5ca8050751":"controlled by your organisation","kera-c-european.8ccb8fdb0f":"cut off from the network","kera-c-european.75a9fec445":"where the licence allows","kera-c-european.32a80ed6fa":"Fabric on the public Mesh within its contracted processing boundary","kera-c-european.8f2ed995f7":"your keys, your rules","kera-c-european.bce450a7d2":"no line to the outside","kera-c-faster.0e0566b96c":"Everyday speed","kera-c-faster.53861851a1":"honest","kera-c-faster.6347120b54":"labels kept small","kera-c-faster.4e7e49bafa":"some steps run much faster than the usual route","kera-c-faster.bd63056597":"some improvements are smaller","kera-c-faster.f17cca9b8f":"a few cases are currently similar in speed","kera-c-faster.cb8aea277e":"no single printed number","kera-c-faster.c88da79172":"the usual way is not the limit","kera-c-faster.fc9fac3439":"the usual route","kera-c-faster.cc2c85816d":"the Kera route","kera-c-faster.f9aeb5083b":"a heavy job","kera-c-faster.ecea06b6a9":"a medium job","kera-c-faster.6b853b874a":"a light job","kera-c-faster.850dbbb5aa":"another kind of job","kera-c-faster.75addd2353":"much faster","kera-c-faster.daf6b585b3":"faster","kera-c-faster.dad6b9ba69":"a little faster","kera-c-faster.4afd45201b":"about the same","kera-c-faster.cf28735b04":"a shorter bar means less waiting","kera-c-hero.15d4671f9b":"Direct route","kera-c-hero.24a1733ca8":"direct","kera-c-hero.6fb67f7c58":"one clear plan","kera-c-hero.a1838581b9":"one task takes a long zig-zag through translation boxes","kera-c-hero.3d743a29b9":"the Kera route stays one clear plan from job to machine","kera-c-hero.523d9e500b":"software should not take the long way around","kera-c-hero.9dbd5ffb5a":"the machine receives work made for it","kera-c-hero.3cbb992248":"the long way","kera-c-hero.f842290f84":"the direct route","kera-c-hero.d885eae3f1":"your task","kera-c-hero.e11523c5ff":"language","kera-c-hero.f0a787a9f1":"translate","kera-c-hero.1b1008a492":"generic form","kera-c-hero.c9c3b018eb":"tidy up","kera-c-hero.cd2e8cfa84":"prepare","kera-c-hero.7817c52b25":"machine","kera-c-hero.d85bc3cdeb":"the whole job","kera-c-hero.f7d51e2c76":"machine plan","kera-c-hero.e2c1e428f8":"seven stops","kera-c-hero.64e9b3be76":"two stops","kera-c-hero.6eeff298fc":"labels fall away at each stop","kera-c-identity.5c47f67a22":"Job card","kera-c-identity.74c70e83a9":"addressed","kera-c-identity.d1aada8a31":"a fingerprint","kera-c-identity.49b782d60c":"the job card carries its own fingerprint","kera-c-identity.8b7aa73401":"a changed step creates a new fingerprint","kera-c-identity.0c50adac10":"which machine plan was selected is recorded","kera-c-identity.34d99254e6":"no silent swap","kera-c-identity.9a33f31ac5":"checked, not guessed","kera-c-identity.ca4c6ec9e0":"job card","kera-c-identity.51de2b835b":"before","kera-c-identity.c96b55a818":"after a change","kera-c-identity.b5448ce070":"fingerprint","kera-c-identity.2354f290f3":"9f3a e21c","kera-c-identity.4cb7a3ecb7":"b74d 08a1","kera-c-identity.4197eb0cd8":"prepare","kera-c-identity.0e43727e13":"measure","kera-c-identity.815f979888":"combine","kera-c-identity.2cce4a92f4":"finish","kera-c-identity.1fd5e4cebf":"step changed","kera-c-identity.1d3de6f10b":"new fingerprint","kera-c-identity.5d2b90a4c4":"sealed","kera-c-less-work.a329360984":"Less coordination","kera-c-less-work.e6642a951d":"reduced","kera-c-less-work.6306d43d23":"fewer journeys","kera-c-less-work.331ac50d79":"parcels move through seven rooms the usual way","kera-c-less-work.034ea8bd07":"Kera keeps them in two","kera-c-less-work.a0a101a51e":"information stays close to where it is needed","kera-c-less-work.50aaac162f":"remove what was never needed","kera-c-less-work.3ec2510eb7":"fewer temporary results and trips","kera-c-less-work.92e79c83d2":"the usual way","kera-c-less-work.8ce603b33a":"the Kera plan","kera-c-less-work.968ae238c3":"one parcel","kera-c-less-work.daaad33627":"wait","kera-c-less-work.7615854452":"kept close","kera-c-less-work.98c4b8f6e2":"sort","kera-c-less-work.f84e2e2dad":"copy","kera-c-less-work.379d6ce99a":"move","kera-c-less-work.43c88f6f2c":"hold","kera-c-less-work.02743d145d":"copy again","kera-c-less-work.1e7018fe0e":"move again","kera-c-less-work.c3a71b1518":"deliver","kera-c-less-work.010a1cede3":"do the work","kera-c-may-touch.f0c252a725":"Who may act","kera-c-may-touch.0baff051a0":"declared","kera-c-may-touch.e6dbf84625":"abilities are explicit","kera-c-may-touch.a1f13b3bc2":"files","kera-c-may-touch.c112e88173":"network","kera-c-may-touch.728190e74d":"devices","kera-c-may-touch.f1348c6ca9":"stored information","kera-c-may-touch.d41bbb816b":"an offline system can refuse network access","kera-c-may-touch.02985dea2e":"no hidden new access","kera-c-may-touch.35250e2b91":"inside the operator's boundaries","kera-c-may-touch.f8cb3e6af9":"the work","kera-c-may-touch.c3de44d531":"allowed","kera-c-may-touch.a503bc1da2":"refused","kera-c-may-touch.efc3160175":"offline mode","kera-c-may-touch.3a35e38a56":"no hidden access appears later","kera-c-may-touch.1f00d107c6":"read what it is given","kera-c-may-touch.1b6dbb2cb8":"blocked when offline","kera-c-may-touch.3a1ea74d65":"only allowed devices","kera-c-may-touch.049f104fb1":"save results it may keep","kera-c-not-every-package.4abd7d5ebf":"Two clear lanes","kera-c-not-every-package.e4e5f91807":"layered","kera-c-not-every-package.4409a64d08":"Core, and Kera where licensed","kera-c-not-every-package.0af09d1918":"Fabric and the products sit above Core","kera-c-not-every-package.2d2bdfc665":"Core runs everywhere","kera-c-not-every-package.3155728b2f":"selected plans add Kera","kera-c-not-every-package.8d823dd9e8":"every product uses Core","kera-c-not-every-package.a3e531e495":"Kera is included where licensed","kera-c-not-every-package.a010de5c61":"Fabric","kera-c-not-every-package.2615ae91cc":"the products","kera-c-not-every-package.68836c550e":"Core","kera-c-not-every-package.c4e59adf4d":"runs everywhere","kera-c-not-every-package.71c70d7ed0":"where licensed","kera-c-not-every-package.9f34723102":"the deeper route, where licensed","kera-c-not-every-package.cc95a31a83":"in every plan","kera-c-not-every-package.898d74f66a":"the fast path in every product","kera-c-not-every-package.dfed9ea971":"no licence needed","kera-c-not-every-package.76d3eb7356":"on top of Core, where licensed","kera-c-owns-route.6e8b0bb182":"One accountable team","kera-c-owns-route.c6dda4f283":"owned","kera-c-owns-route.1593a101ec":"job to machine","kera-c-owns-route.e11523c5ff":"your work","kera-c-owns-route.29a184b65c":"kept whole","kera-c-owns-route.b3777d2fc9":"planned","kera-c-owns-route.f2e18ffc17":"run","kera-c-owns-route.1477f0cb08":"external hardware and operating systems sit at the edge","kera-c-owns-route.1b95a85c73":"not another company's road map","kera-c-owns-route.9010c58d3a":"Dweve improves the route itself","kera-c-owns-route.97785477db":"Dweve workshop","kera-c-owns-route.39a5e378fb":"one owner","kera-c-owns-route.2a9b53596e":"outside the workshop","kera-c-owns-route.608cb271bb":"hardware","kera-c-owns-route.2caa624224":"operating system","kera-c-owns-route.9a9e192204":"at the edge","kera-c-remembers-job.632dc3da86":"Recipe attached","kera-c-remembers-job.1e61fe1e47":"kept","kera-c-remembers-job.3098708ae5":"cake, not just movements","kera-c-remembers-job.f4fc28e215":"a recipe passed through people loses its purpose","kera-c-remembers-job.4e597a0e33":"in Kera the purpose stays attached to the steps","kera-c-remembers-job.64c3a554d0":"the kitchen can still make sensible choices","kera-c-remembers-job.870ebee82f":"not only a list of movements","kera-c-remembers-job.d16474cb3d":"a plan made for the whole job","kera-c-remembers-job.23185cd785":"bake a sponge cake","kera-c-remembers-job.5db210b6ed":"first cook","kera-c-remembers-job.9368ca09ac":"second cook","kera-c-remembers-job.60f74eb68c":"third cook","kera-c-remembers-job.b53dc1c60b":"cake, sponge, gentle heat","kera-c-remembers-job.9711d55621":"sponge, some heat","kera-c-remembers-job.1b6b2844e1":"mix, then heat","kera-c-remembers-job.0c11cbfec3":"purpose stays attached","kera-c-remembers-job.9c79c6568a":"purpose lost","kera-c-remembers-job.a9439e6f69":"purpose kept","kera-c-remembers-job.23949b59f2":"the Kera kitchen","kera-c-remembers-job.07827e8835":"passed hand to hand","kera-c-sides.b009a7c55d":"The direct route","kera-c-sides.da66e405ba":"what you gain","kera-c-sides.7ab1c4cd47":"One clear route","kera-c-sides.55dab176a9":"job to your machine","kera-c-sides.c07acdcaff":"The whole job stays together","kera-c-sides.de6d3e83ad":"nothing is chopped into loose pieces","kera-c-sides.1e61fe1e47":"kept","kera-c-sides.05bf49b00f":"Work made for your machine","kera-c-sides.31653051d4":"not a generic version fixed at the end","kera-c-sides.80c656bf28":"fitted","kera-c-sides.ff97d028f2":"Fewer layers in the way","kera-c-sides.194ee3916b":"less passing from hand to hand","kera-c-sides.276d53b771":"fewer","kera-c-sides.d9bed04ecb":"A clear record of what ran","kera-c-sides.f40eaf1cf3":"so it can be checked later","kera-c-sides.168cbb2ea5":"clear","kera-c-sides.d17f11e8ab":"Passed along","kera-c-sides.cde0725664":"the recipe test","kera-c-sides.7f8449245c":"Purpose kept","kera-c-sides.2f1593caf2":"better choices","kera-c-sides.d84ef3805c":"Handed down","kera-c-sides.6dc74366fc":"the purpose is lost on the way","kera-c-sides.97cd452004":"Kept together","kera-c-sides.d14f22884a":"the purpose stays attached","kera-c-sides.bd370d1b6f":"step","kera-c-sides.09dac35c2d":"step ","kera-c-sides.ea9d05935a":"step  ","kera-c-sides.bf88247bfc":"no idea why","kera-c-sides.47b45278ed":"still a cake","kera-c-sides.966ea2ce2a":"How much faster","kera-c-sides.f16c694f18":"from real tests","kera-c-sides.45f3f0e3a0":"Not every task wins","kera-c-sides.2d9bde97d7":"the usual way is not the limit","kera-c-sides.41151658e1":"Much","kera-c-sides.45c43192ee":"some heavy sums","kera-c-sides.f5676bb8ed":"several times quicker in tests","kera-c-sides.adc7ac2ae5":"Faster","kera-c-sides.cd3f3fae53":"many everyday steps","kera-c-sides.e25efa6427":"a clear lead in tests","kera-c-sides.c73bd54b40":"A little","kera-c-sides.c88120bc66":"some smaller jobs","kera-c-sides.c623a54e02":"a modest gain in tests","kera-c-sides.7c7f5d049f":"Level","kera-c-sides.437a3455c5":"a few cases","kera-c-sides.fc7160dcf8":"about the same for now","kera-c-sides.fdfdd75f5a":"Less work","kera-c-sides.55e2556348":"how the wait shrinks","kera-c-sides.e4f251b426":"Remove the work","kera-c-sides.404768f4ea":"not just speed it up","kera-c-sides.2840f5c2a2":"See what belongs together","kera-c-sides.db264c9ebd":"steps that fit are handled as one","kera-c-sides.6f8c6c2905":"Skip throwaway results","kera-c-sides.57017a106f":"no scratch work that is used once","kera-c-sides.10791dfbbf":"Keep things close","kera-c-sides.42d8d49ac4":"less moving data around the machine","kera-c-sides.510f8ad691":"Less waiting, less energy","kera-c-sides.9f41af8a5e":"fewer delays and lower power use","kera-c-sides.dc0ced92b7":"The same job","kera-c-sides.bdd35e2f4c":"a plan per machine","kera-c-sides.495fd6b633":"One job","kera-c-sides.24c3404875":"it does not quietly change","kera-c-sides.92ca930394":"Laptop chip","kera-c-sides.9fc3488e7e":"a steady, ordinary plan","kera-c-sides.d1b9c3ea69":"plan A","kera-c-sides.464d6ab7b0":"Graphics chip","kera-c-sides.31bd7dfa0b":"many small parts at once","kera-c-sides.fa32a71ed2":"plan B","kera-c-sides.03e4d01149":"In the browser","kera-c-sides.4ee4681a08":"a portable, sandboxed plan","kera-c-sides.7660d4086b":"plan C","kera-c-sides.90a6d3232a":"Special chip","kera-c-sides.79631ac10b":"a plan shaped to fit","kera-c-sides.67c66105a1":"plan D","kera-c-sides.1f0bfd026e":"Three ways to run","kera-c-sides.d98a5d318e":"chosen before it runs","kera-c-sides.67e15a1a6f":"You pick the contract","kera-c-sides.6ac548b2d6":"before the work runs","kera-c-sides.b3012de005":"Steady","kera-c-sides.725b5c759e":"the same supported result every time","kera-c-sides.45705488b9":"Repeatable","kera-c-sides.a72733bc81":"the same variation each time","kera-c-sides.75f527181b":"Free","kera-c-sides.10c19b3d22":"a fresh answer where that helps","kera-c-sides.5c82441a97":"The record","kera-c-sides.7f9f500159":"how a change shows","kera-c-sides.1e34a48722":"No silent swap","kera-c-sides.9a33f31ac5":"checked, not guessed","kera-c-sides.69fe31dc92":"Work is set","kera-c-sides.56ee117853":"the job gets its own fingerprint","kera-c-sides.d6c7e1b296":"Nothing changes","kera-c-sides.6c05a75bb8":"the fingerprint stays the same","kera-c-sides.7717cf1ac7":"One step edited","kera-c-sides.cff9ce9351":"the fingerprint changes at once","kera-c-sides.e6fc767359":"Easy to compare","kera-c-sides.fd7a06079d":"old and new sit side by side","kera-c-sides.56895dc6f9":"Nothing to read","kera-c-sides.17555e1784":"the product checks it for you","kera-c-sides.decba8e6b2":"What it may touch","kera-c-sides.503a927999":"set by the operator","kera-c-sides.c584bd0a7f":"Abilities are declared","kera-c-sides.e36a99f218":"no quiet new access","kera-c-sides.68247197ae":"Allowed here","kera-c-sides.87fb4da3b5":"Read files","kera-c-sides.236da26922":"Use a device","kera-c-sides.ed0e3e1020":"Save results","kera-c-sides.173ea9d0d3":"Held back","kera-c-sides.4d193e8c11":"The internet, offline","kera-c-sides.1ce1c15043":"Any hidden new access","kera-c-sides.81ba828cd8":"Can it reach the network?","kera-c-sides.116f010f43":"Only if the operator allows it","kera-c-sides.9dec9491ed":"Who owns the route","kera-c-sides.8267aed890":"under the surface","kera-c-sides.c89134a1b1":"You never touch this","kera-c-sides.d055fce23b":"Dweve owns the path","kera-c-sides.fd90fee787":"On someone else","kera-c-sides.7f836c2ac0":"waiting on their plans","kera-c-sides.9744531e71":"Another firm's schedule","kera-c-sides.e8e321b3af":"Fixes when they arrive","kera-c-sides.73e15aec12":"Little say in the route","kera-c-sides.3339f9af5e":"Built by Dweve","kera-c-sides.30f1c8dcfe":"improved directly","kera-c-sides.c2e6ed4af5":"The whole path in house","kera-c-sides.a3f04305ea":"A better route on its own timing","kera-c-sides.cb1284a96d":"One team to answer for it","kera-c-sides.8e36c2b2b9":"Not in every package","kera-c-sides.7ed44b64ba":"where it is included","kera-c-sides.71cefeea25":"You use the product","kera-c-sides.85547d18c3":"Kera sits underneath","kera-c-sides.1e009a2d36":"Every product","kera-c-sides.1d9c9446d7":"runs on Core, the main engine","kera-c-sides.699d60f454":"Core everywhere","kera-c-sides.a5d025f453":"its own fast path is always there","kera-c-sides.52d07f114c":"Kera in select plans","kera-c-sides.7b501b4206":"the deeper route, where licensed","kera-c-sides.f26eac6491":"Most people","kera-c-sides.b3524b6e6d":"never choose or set it up","kera-c-sides.6af74613cf":"Built in Europe","kera-c-sides.75a9fec445":"where the licence allows","kera-c-sides.14fd2c9857":"Made in the Netherlands","kera-c-sides.19efbe06f0":"control of the route","kera-c-sides.635d733c49":"European hosted","kera-c-sides.0463a31456":"run within Europe","kera-c-sides.867d2e6efc":"You control it","kera-c-sides.0c61d2c426":"your organisation holds the keys","kera-c-sides.28fdd72ec1":"Fully isolated","kera-c-sides.269589d789":"no outside connection needed","kera-c-sides.a44351bc63":"The route too","kera-c-sides.12504a8751":"not just the visible app","kera-c-sides.e8f29006ee":"Out of sight","kera-c-sides.f18cc0db38":"what stays true","kera-c-sides.2f3cd52ed4":"You use the product ","kera-c-sides.c857a94045":"the path is shorter","kera-c-sides.19ad825c80":"You use the app","kera-c-sides.2706e5bc26":"the friendly surface on top","kera-c-sides.96274ef852":"No Kera controls","kera-c-sides.a2a07dc89f":"nothing extra to learn","kera-c-sides.1c04125ae2":"The job stays whole","kera-c-sides.4caf5f3ebd":"kept together underneath","kera-c-sides.6da42e43b0":"The result arrives","kera-c-sides.12b7ab21af":"faster, with a clear record","kera-c-steady.3fd0afd8a9":"Steady work","kera-c-steady.3fe6938286":"chosen","kera-c-steady.a200afa9b8":"steady, seeded, varied","kera-c-steady.e20a594b9c":"a strict task gives the same pattern each time","kera-c-steady.37ce1e2703":"a seeded task repeats one variation","kera-c-steady.c6a6a552a3":"a creative task allows different patterns","kera-c-steady.07f1a82edd":"the product chooses the behaviour","kera-c-steady.a126d39402":"no accidental change on another machine","kera-c-steady.e872c7f207":"the task","kera-c-steady.df6ad19037":"run","kera-c-steady.41eaab877c":"strict","kera-c-steady.9ad3dc4c49":"seeded","kera-c-steady.df0b6c410f":"creative","kera-c-steady.b69c40227c":"same pattern every run","kera-c-steady.2abbf46fc1":"one variation, repeated","kera-c-steady.37ac45b3ba":"a new pattern each run","kera-c-steady.d98a5d318e":"chosen before it runs","kera-c-underneath.0c23ddb1a1":"Under the surface","kera-c-underneath.99d72c7fc3":"hidden","kera-c-underneath.de177cba87":"the plan below","kera-c-underneath.6a824918e6":"the app surface stays friendly and simple","kera-c-underneath.ea36124485":"a cutaway reveals the Kera plan and the machine work below","kera-c-underneath.142933e95c":"there are no Kera controls in ordinary use","kera-c-underneath.f4f347733d":"the direct path stays underneath","kera-c-underneath.7f0dd0f5ba":"you receive faster, steadier behaviour","kera-c-underneath.9dbbd8bd6e":"your app","kera-c-underneath.3559d7accf":"search","kera-c-underneath.7fb65d85c9":"get result","kera-c-underneath.c610874bb9":"cutaway","kera-c-underneath.3ccd56a930":"the whole job","kera-c-underneath.f7d51e2c76":"machine plan","kera-c-underneath.c0fc393d51":"what you see","kera-c-underneath.6dae32be92":"what runs below","kera-c-underneath.10c1e20acf":"group together","kera-c-underneath.1148d66c06":"keep close","kera-c-underneath.8b7e1710ed":"run it","kera-e-broad-bench.e08d613464":"Operation matrix","kera-e-broad-bench.53861851a1":"honest","kera-e-broad-bench.76739e032d":"wins, parity, pending","kera-e-broad-bench.9dd4c9deb1":"orange cells mark measured wins","kera-e-broad-bench.173ddca427":"grey cells mark parity","kera-e-broad-bench.3c9472d171":"outlined cells mark pending analysis","kera-e-broad-bench.4f78af49a1":"the wider operation set","kera-e-broad-bench.f4ed07b5e1":"neutral cases stay visible","kera-e-broad-bench.1d6feafbec":"elementwise","kera-e-broad-bench.700bb94783":"reductions","kera-e-broad-bench.583131ec1b":"matmul","kera-e-broad-bench.9afd89eb88":"activations","kera-e-broad-bench.b0237f8cc7":"binary ops","kera-e-broad-bench.89f6229a11":"small","kera-e-broad-bench.20af418657":"medium","kera-e-broad-bench.5296d5cced":"large","kera-e-broad-bench.c76ac2e9cd":"win","kera-e-broad-bench.61bdc38492":"parity","kera-e-broad-bench.e22586930a":"pending","kera-e-broad-bench.f3e956c179":"operation family","kera-e-close.9e3c1d591d":"What the claims stand on","kera-e-close.100ec4462d":"evidence","kera-e-close.4beed4ad6f":"the engineer band","kera-e-close.d3253f3d19":".keg identity","kera-e-close.ff21cf7d36":"planner diff","kera-e-close.9e5b3fc29f":"emitted path","kera-e-close.bee075373f":"benchmark harness","kera-e-close.2d23d2953b":"strict replay test","kera-e-close.e833a04b82":"benchmark the build you use","kera-e-close.3a1853c519":"inspect which facts produced the difference","kera-e-close.954373e0e6":"evidence the claims stand on","kera-e-close.c8c78ad28a":"verifiable","kera-e-close.007f635644":"9f3c1d.keg","kera-e-close.7e731fdd1d":"42 nodes changed","kera-e-close.7fa02f1c6a":"x86-64 / avx-512","kera-e-close.deb17e1028":"publish with the harness","kera-e-close.4027e78f60":"hash stable","kera-e-close.0000000001":"Evidence base","kera-e-commercial.c9de85cd5c":"The rights matrix","kera-e-commercial.2a2415c508":"proprietary","kera-e-commercial.6e6a190328":"packages outlined","kera-e-commercial.083e086b67":"runtime and targets","kera-e-commercial.5bdcd3c0d4":"support","kera-e-commercial.eaed708d40":"source escrow and delivery","kera-e-commercial.54a1377d30":"air-gapped and transfer","kera-e-commercial.1a03649678":"unknown package cells stay outlined until packaging is final","kera-e-commercial.455d8b2ce4":"runtime rights","kera-e-commercial.d0c418fd4a":"are not source rights","kera-e-commercial.582681c2ea":"package","kera-e-commercial.04489a12bb":"use","kera-e-commercial.e2ebc20582":"modify","kera-e-commercial.034bb6aa84":"redistribute","kera-e-commercial.79bddc575f":"source access","kera-e-commercial.fc8a86cd0e":"granted","kera-e-commercial.1604a818ef":"not granted","kera-e-commercial.600a6e4090":"pending packaging","kera-e-commercial.0000000002":"Commercial terms","kera-e-core.72b9bff935":"Core operation enters Kera","kera-e-core.f096faa634":"lowered","kera-e-core.c956c317db":"plan and emit","kera-e-core.8a3255dc6c":"a Core operation node enters the Kera plan","kera-e-core.8f16ffc1b5":"planning, fusion, and lowering follow","kera-e-core.92ffe5f0fc":"where Kera is absent, Core stays Rust-native","kera-e-core.c89f2ab2e0":"two products","kera-e-core.bf5650fa35":"two contracts","kera-e-core.4ae3948cf8":"Core operation","kera-e-core.5bd7bdd9b6":"Core on Kera","kera-e-core.13d8fc3824":"Core native","kera-e-core.bed97175b0":"plan","kera-e-core.81a5b34cb6":"fuse","kera-e-core.346e3ee198":"lower","kera-e-core.2e96e89125":"emit","kera-e-core.8606ad5275":"Rust codegen","kera-e-core.71c70d7ed0":"where licensed","kera-e-core.9b6a2aba1f":"where Kera is absent","kera-e-core.d6c92c08dc":"same operation","kera-e-core.0000000003":"Kera in Core","kera-e-determinism.70a942f634":"Strict, seeded, creative diff","kera-e-determinism.f4d06ebbbc":"contracted","kera-e-determinism.44b38f0387":"plan diff","kera-e-determinism.1c7c2d8fcd":"strict fixes arithmetic and ordering","kera-e-determinism.8744749ff1":"seeded repeats variation per seed","kera-e-determinism.4a9887f1e3":"creative allows intended variation","kera-e-determinism.b944313c5f":"strictness shapes the plan","kera-e-determinism.cdcf3a8aae":"not a seed after the fact","kera-e-determinism.41eaab877c":"strict","kera-e-determinism.9ad3dc4c49":"seeded","kera-e-determinism.df0b6c410f":"creative","kera-e-determinism.21471332c0":"three runs of one graph","kera-e-determinism.570032650f":"identical output hash","kera-e-determinism.57e908bc7f":"one hash per seed","kera-e-determinism.92acfcc1a9":"intended spread","kera-e-determinism.df6ad19037":"run","kera-e-determinism.0000000004":"Deterministic plans","kera-e-direct-emit.a87217b15c":"Direct output","kera-e-direct-emit.c6dda4f283":"owned","kera-e-direct-emit.fe70745e4a":"LLVM lane absent","kera-e-direct-emit.828d338a9b":"source","kera-e-direct-emit.d38b11c203":".keg","kera-e-direct-emit.bed97175b0":"plan","kera-e-direct-emit.1ca54c8597":"Kera codegen","kera-e-direct-emit.0e8a3ad980":"target","kera-e-direct-emit.8d69cbad97":"the LLVM lane is simply absent, not crossed out theatrically","kera-e-direct-emit.d698a4979c":"direct is ownership of the path","kera-e-direct-emit.2405b6a44e":"not the absence of a compiler","kera-e-direct-emit.ab4dc95c08":"Kera lane","kera-e-direct-emit.c91dbd9052":"LLVM lane","kera-e-direct-emit.2ae9971d90":"one owner, end to end","kera-e-direct-emit.65d123255a":"no stage here","kera-e-direct-emit.644ed63727":"Emission path","kera-e-direct-emit.1bbbcb2b58":"one owned lowering chain","kera-e-direct-emit.ca6d0e3aaa":"Stage","kera-e-direct-emit.c6fe330e04":"Artefact","kera-e-direct-emit.89ff31225c":"Owner","kera-e-direct-emit.b91eed4b7a":"Lower","kera-e-direct-emit.a2b0ce0bed":"Register alloc","kera-e-direct-emit.8598222918":"Select","kera-e-direct-emit.0a8adac9d6":"Schedule","kera-e-direct-emit.08afa6be84":"Emit","kera-e-direct-emit.d5f412e831":"Kera","kera-e-direct-emit.377814d3f1":"No LLVM IR stage sits in the centre. Every step keeps graph and operation semantics available.","kera-e-dispatch.08ff1e348f":"The dispatcher chooses","kera-e-dispatch.8204fbd54f":"recorded","kera-e-dispatch.284248abc0":"per region","kera-e-dispatch.7b423a4d0b":"AVX-512","kera-e-dispatch.5f305d0313":"NEON","kera-e-dispatch.349c3fb369":"scalar strict","kera-e-dispatch.9427def3f0":"GPU plan","kera-e-dispatch.8aee628c97":"the selected path is written to the execution record","kera-e-dispatch.96d38d5937":"no hidden fallback","kera-e-dispatch.96d8c525d6":"the real path is recorded","kera-e-dispatch.20a6af67ec":"host capability probe","kera-e-dispatch.a94a58406e":"region","kera-e-dispatch.ad89e90d45":"written to record","kera-e-dispatch.c9236d39ed":"conv region","kera-e-dispatch.57174212bd":"reduce region","kera-e-dispatch.c99cd38a0e":"elementwise region","kera-e-dispatch.7b231a50a4":"available","kera-e-dispatch.6792cfa1ea":"not present","kera-e-dispatch.be9b2e564d":"click a region","kera-e-dispatch.0000000005":"Work dispatch","kera-e-distributed.8441afbfb2":"Distributed graph, one recovery","kera-e-distributed.c575f3e383":"distributed","kera-e-distributed.291cc022fd":"checkpoint restore","kera-e-distributed.f907871e16":"the graph is partitioned across nodes","kera-e-distributed.1cee8f0009":"ring all-reduce connects the partitions","kera-e-distributed.c83c5e4a5d":"one node fails and restores from checkpoint","kera-e-distributed.3f153cb62b":"distribution is a plan","kera-e-distributed.7dd35631d5":"not a second product","kera-e-distributed.8de4e2bf20":"ring all-reduce","kera-e-distributed.dbc963b1be":"fail a node","kera-e-distributed.e08e84916f":"restore","kera-e-distributed.5c528ebc85":"checkpoint","kera-e-distributed.98ad765b8a":"restored from checkpoint","kera-e-distributed.de18ccfa15":"healthy","kera-e-distributed.88faac11da":"partition","kera-e-distributed.400a6486e9":"shard","kera-e-distributed.0000000006":"Distributed run","kera-e-effects.60e2871a7a":"Effect gates","kera-e-effects.ec734b6515":"verified","kera-e-effects.9fafce9074":"capability gates","kera-e-effects.03abf9280f":"pure nodes flow freely","kera-e-effects.8f49161c96":"effectful nodes pass through capability gates","kera-e-effects.801d0accfb":"an undeclared capability is rejected by the verifier","kera-e-effects.2c83cad38c":"pure and external stay distinct","kera-e-effects.8f97e0ed12":"ordering cannot be silently broken","kera-e-effects.55d3b33c35":"pure lane","kera-e-effects.c112e88173":"network","kera-e-effects.46b7ac31e2":"filesystem","kera-e-effects.f3a929b336":"device","kera-e-effects.b8a8c6b90b":"declared, ordered, admitted","kera-e-effects.3ac3efcafa":"capability not declared","kera-e-effects.6f389bc568":"admitted","kera-e-effects.df88b84d81":"blocked","kera-e-fusion.94b5459806":"Fusion view","kera-e-fusion.1f08a3216a":"fused","kera-e-fusion.3ef89ae8ee":"counters drop","kera-e-fusion.238b32d513":"separate regions with materialised intermediates","kera-e-fusion.92a9e26597":"one region, values retained locally","kera-e-fusion.5e9cdecd5f":"launch and byte counters fall","kera-e-fusion.55c5832fbe":"not only shorter instruction streams","kera-e-fusion.f263743706":"work that stops existing","kera-e-fusion.51de2b835b":"before","kera-e-fusion.405906c9d5":"after","kera-e-fusion.ce03a80127":"intermediate","kera-e-fusion.4928016aa1":"launches","kera-e-fusion.bfc3d8ebd1":"bytes moved","kera-e-fusion.69992f1747":"removed","kera-e-graph-programme.c463606c73":"Graph program","kera-e-graph-programme.6802cb5d70":"durable","kera-e-graph-programme.d4cf00b6e3":"retained to replay","kera-e-graph-programme.217d770b7e":"typed source","kera-e-graph-programme.b3eaaddbf4":".keg graph","kera-e-graph-programme.bed97175b0":"plan","kera-e-graph-programme.eb5d2f4a58":"JIT","kera-e-graph-programme.2e96e89125":"emit","kera-e-graph-programme.341d953e69":"replay","kera-e-graph-programme.c578d4ccc5":"the graph is retained across every later stage","kera-e-graph-programme.0b933f1116":"not a temporary optimiser view","kera-e-graph-programme.38cdc8d9ab":"the durable programme itself","kera-e-graph-programme.828d338a9b":"source","kera-e-graph-programme.7d9350ca93":"later stages","kera-e-graph-programme.78f293d4c6":"graph in view","kera-e-graph-programme.6f32a49e58":"typed, hashed, durable","kera-e-headline-bench.af1471a47a":"Benchmark bars","kera-e-headline-bench.6543f14e1a":"scoped","kera-e-headline-bench.09b8754927":"exact test-scope chips","kera-e-headline-bench.5490337de8":"vector logarithm","kera-e-headline-bench.c9e51c02ee":"Q16.16 and Q31.32 matmul","kera-e-headline-bench.32d60758c5":"vector exponential","kera-e-headline-bench.bc27c37274":"vector tanh","kera-e-headline-bench.a8608fb146":"binary dot product","kera-e-headline-bench.1b1d863b98":"each bar carries an exact test-scope chip, no invented hardware","kera-e-headline-bench.654165a28b":"operation and shape specific","kera-e-headline-bench.7348151412":"published with the envelope","kera-e-headline-bench.fcb60bc535":"operation","kera-e-headline-bench.0c69fbcc93":"measured lead","kera-e-headline-bench.999110ee02":"large lead","kera-e-headline-bench.1e94ffc3ae":"medium lead","kera-e-headline-bench.5e681519ff":"modest lead","kera-e-headline-bench.a88b25068f":"results differ by hardware, published with the harness","kera-e-headline-bench.7e1e18e9b2":"test scope","kera-e-hero.48a017825a":"Compiler flow","kera-e-hero.24a1733ca8":"direct","kera-e-hero.dbd4a4fefe":"the engineer TUI","kera-e-hero.53956cfaa6":"kera check","kera-e-hero.05fcad8b20":".keg inspect","kera-e-hero.e414739a3e":"kera plan","kera-e-hero.7f6cda6e63":"kera emit","kera-e-hero.d943249789":"kera bench","kera-e-hero.e08276254a":"selected ISA path","kera-e-hero.e96f33c192":"> kera emit vlog -t x86-64","kera-e-hero.1fde14efbd":"the graph is inspected at every step","kera-e-hero.a2f72009fd":"the selected ISA path is recorded","kera-e-hero.81b09e7085":"subcommands","kera-e-hero.c57bf37547":"emit trace","kera-e-hero.835f3b50e3":"selected","kera-e-isa.0432f7ce58":"One node, three disassemblies","kera-e-isa.9665ac3929":"emitted","kera-e-isa.889c7257c5":"different vector widths","kera-e-isa.5995c646b4":"x86-64 with AVX","kera-e-isa.4a8f14b720":"ARM64 with NEON","kera-e-isa.c7538ab365":"RISC-V scalar or vector","kera-e-isa.7c1da6f306":"each emit uses a different vector width","kera-e-isa.74db8819b5":"emit for the actual processor","kera-e-isa.68f9bd2a40":"honest about per-target support","kera-e-isa.bb9498680a":"one graph node","kera-e-isa.31b6189749":"q16_16 mul x1024","kera-e-isa.457d8a82d9":"512-bit lanes","kera-e-isa.3f279309b4":"128-bit lanes","kera-e-isa.fc8559d579":"VLEN, set at runtime","kera-e-isa.e8254c3717":"per-target support","kera-e-isa.73137381ed":"vector profile optional","kera-e-isa.0000000007":"Target instructions","kera-e-keg.395a421a16":"Change propagation","kera-e-keg.74c70e83a9":"addressed","kera-e-keg.81c065a618":"affected ancestry only","kera-e-keg.e7706add45":"a single node is edited","kera-e-keg.5ba765d88c":"new hashes propagate through the affected ancestry only","kera-e-keg.1727095c56":"unchanged subgraphs keep their identity","kera-e-keg.511bb88257":"change the node","kera-e-keg.8b5b1fd339":"change only its path","kera-e-keg.189d4c9cb9":"select a node to edit it","kera-e-keg.6bb2bf4b4b":"rekeyed","kera-e-keg.1e61fe1e47":"kept","kera-e-keg.4e306c16e8":"content-addressed graph","kera-e-ownership.7969455390":"Ownership transfer","kera-e-ownership.c6dda4f283":"owned","kera-e-ownership.7ad3021eb2":"spaces and aliases","kera-e-ownership.d250d286d2":"the token crosses host, device, and remote spaces","kera-e-ownership.57d258e56a":"an alias conflict is blocked","kera-e-ownership.ed01abd5c0":"the planner keeps the value where it belongs","kera-e-ownership.749dca00d3":"memory safety","kera-e-ownership.496414a575":"and performance are one problem","kera-e-ownership.86dd1cf451":"host","kera-e-ownership.f3a929b336":"device","kera-e-ownership.41ffe5457d":"remote","kera-e-ownership.44137dafb2":"owner token","kera-e-ownership.346e9d2ef4":"alias conflict","kera-e-ownership.5e142a4b65":"moved","kera-e-ownership.2c03439596":"held","kera-e-planner.ea5ef50385":"Plan inspector","kera-e-planner.9027cc5a2c":"global","kera-e-planner.e7bb1b6eea":"over one graph","kera-e-planner.48788620ce":"topological order","kera-e-planner.7843fc5bea":"placement","kera-e-planner.b612049ac9":"fusion groups","kera-e-planner.b727a735e7":"movement","kera-e-planner.442088cd90":"kernels","kera-e-planner.b9300593b4":"recovery points","kera-e-planner.8581eae5f5":"the planner has the entire graph in view","kera-e-planner.151f5d2923":"no local instruction window","kera-e-planner.14a68ac79d":"the whole computation planned","kera-e-planner.cbf953da42":"plan facet","kera-e-planner.37a5301a88":"result","kera-e-planner.e0f6f3f6d4":"one graph in view","kera-e-planner.3eb453b123":"select a facet","kera-e-regalloc.66f8f9a1ca":"Register allocation timeline","kera-e-regalloc.a9c382decf":"shaped","kera-e-regalloc.135732d710":"before and after","kera-e-regalloc.343f127f96":"generic live ranges without operation context","kera-e-regalloc.1b6865cede":"live ranges shaped by graph context","kera-e-regalloc.08d11f1fc2":"unrolling, vector width, and spills chosen from the operation","kera-e-regalloc.0d3b1634bb":"registers owned by Kera","kera-e-regalloc.914c6b4bb7":"a different optimisation architecture","kera-e-regalloc.8bed0947ae":"spill to stack","kera-e-regalloc.de84609f3a":"no spills","kera-e-regalloc.46a808cfd5":"generic","kera-e-regalloc.a6b993f2ce":"graph-shaped","kera-e-regalloc.15f74936ed":"live range","kera-e-regalloc.c97bf2544e":"spill","kera-e-regalloc.11e9ba26c9":"schedule","kera-e-regalloc.0000000008":"Register allocation","kera-e-targets.5ed66fe1ef":"Target fan-out","kera-e-targets.600f021001":"fanned","kera-e-targets.ae5d62972c":"emitted artefacts","kera-e-targets.ff221d4752":"CPU","kera-e-targets.a6a6318544":"GPU","kera-e-targets.cef7f9bd36":"FPGA","kera-e-targets.051061c35d":"WebAssembly","kera-e-targets.c575f3e383":"distributed","kera-e-targets.c5247a7f6e":"each target carries its own emitted artefact","kera-e-targets.8dcb777141":"one semantic graph","kera-e-targets.425cdfb8be":"different target plans","kera-e-targets.64058ac6d4":"graph 9f3c.keg","kera-e-targets.1079bd7a96":"emitted artefact","kera-e-targets.2f2afa2d7c":"target plan","kera-e-targets.0000000009":"Target output","kera-e-tooling.2920832c0a":"Terminal and graph inspector","kera-e-tooling.c0c1d635e0":"first-class","kera-e-tooling.47c057fef0":"no fake output","kera-e-tooling.c10c610c74":"check, build, inspect, plan, run, verify","kera-e-tooling.f3b9c4a50d":"the graph inspector shows types and effects","kera-e-tooling.02b4ea4be7":"no fabricated benchmark output is shown","kera-e-tooling.e0bf7c2424":"the graph is visible","kera-e-tooling.0beb179ae8":"not only after a failure","kera-e-tooling.46d551dae6":"terminal","kera-e-tooling.d56d985300":"check","kera-e-tooling.80754af91b":"build","kera-e-tooling.a1a2ae18fa":"inspect","kera-e-tooling.bed97175b0":"plan","kera-e-tooling.df6ad19037":"run","kera-e-tooling.86a4261d84":"verify","kera-e-tooling.470a307f65":"graph inspector","kera-e-tooling.d0a3e7f81a":"type","kera-e-tooling.5080fd62c2":"shape","kera-e-tooling.6ef9514c35":"memory space","kera-e-tooling.23f4d47c92":"effects","kera-e-tooling.1a7c89d6af":"selected node","kera-e-tooling.2977692084":"ok, 312 nodes typed","kera-e-tooling.000000000a":"Working tools","kera-e-types.1829e76a16":"Typed nodes","kera-e-types.8e8e1429fa":"planning-time","kera-e-types.19a8e29ab2":"types feed the planner","kera-e-types.31138da7de":"numerical type","kera-e-types.66e418d7bb":"shape and layout","kera-e-types.6ef9514c35":"memory space","kera-e-types.a94a58406e":"region","kera-e-types.23f4d47c92":"effects","kera-e-types.c5be5b3d86":"capability","kera-e-types.70491edded":"each field feeds a planner decision","kera-e-types.c639bba8c4":"not an untyped sea of instructions","kera-e-types.7bc275f055":"facts the planner still has","kera-e-types.2da0b68df8":"field","kera-e-types.f32b67c7e2":"value","kera-e-types.1b02192f71":"planner decision","kera-e-types.cff6f1efbf":"chooses the kernel and accuracy path","kera-e-types.03d876bc1a":"sizes the buffers and vector width","kera-e-types.a232ee16b5":"places the value on host or device","kera-e-types.6919cfa939":"scopes the lifetime and reuse","kera-e-types.0f05cc8080":"orders the effectful work","kera-e-types.428c0e00c4":"gates what the node may touch","kera-e-why-wins.25525dfcf8":"Causal breakdown, three operations","kera-e-why-wins.e0e0d1d28c":"profiled","kera-e-why-wins.dcbd083d36":"different causes","kera-e-why-wins.185154addc":"one win from algorithm choice","kera-e-why-wins.8f6d043d1d":"one from fusion and movement","kera-e-why-wins.fc07204ca8":"one from direct SIMD and shape","kera-e-why-wins.206613dfe0":"the common cause is retained semantic information","kera-e-why-wins.1fbfa6f50d":"no universal trick","kera-e-why-wins.8229cbe4e1":"profile the actual cause","kera-e-why-wins.f5d557e3e3":"vector log","kera-e-why-wins.10e7bfdefb":"matmul, Q16.16","kera-e-why-wins.1f462af238":"tanh, Q16.16","kera-e-why-wins.fcb60bc535":"operation","kera-e-why-wins.6f4cbd265c":"attributed cause","kera-e-why-wins.38f90a6c8e":"against the LLVM lane","kera-e-why-wins.83b8b0ac14":"algorithm choice","kera-e-why-wins.f7e6fdf149":"fusion","kera-e-why-wins.b727a735e7":"movement","kera-e-why-wins.703fda89e2":"direct SIMD","kera-e-why-wins.7f0f79a17a":"shape specialisation","kera-e-why-wins.999110ee02":"large lead","kera-e-why-wins.b643b42797":"clear lead","kera-e-why-wins.9cf92eba54":"shared root cause","kera-e-why-wins.000000000b":"Kera attributes","page-breadcrumb.c766e66518":"Breadcrumb","page-toc.7e439c353e":"On this page","product-kera.138bedd54d":"Explore the architecture","product-kera.356d5729f4":"Contact sales","product-kera.d4a74b503a":"Read the docs","product-kera.838991fdac":"Kera keeps operations, effects, ownership, and movement visible from the source graph to target execution. Read the architecture, inspect the graph IR, or bring us a production path that has already been optimised through LLVM.","product-kera.e23c24be52":"Direct computation. The graph stays the programme.","product-kera.90e40d5043":"Get started","product-kera.9aed4de64a":"11 dependency layers","product-kera.b040b4179b":"Architecture","product-kera.feaef7d9ff":"Ring allreduce, checkpoint recovery","product-kera.bb3d98dfee":"Distributed","product-kera.994daa5e05":"Verilog synthesis, resource estimation","product-kera.cef7f9bd36":"FPGA","product-kera.a67e701675":"CUDA/ROCm PTX generation","product-kera.a6a6318544":"GPU","product-kera.8a05b95acd":"x86-64 (SSE2/AVX2/AVX-512), ARM64 (NEON), RISC-V (Vector)","product-kera.eb5d2f4a58":"JIT","product-kera.66930b6707":"DAG, content-addressed (.keg)","product-kera.8d784dbff4":"IR","product-kera.1bad8779f2":"Rust 2021","product-kera.64abb3cf15":"Edition","product-kera.d5f412e831":"Kera","product-kera.b4dad06170":"Tech specs","product-kera.1b45e1fea0":"Kera is a statically typed systems language with a graph-native, content-addressed IR. It compiles programmes to .keg files, directed acyclic graphs of operations, and executes them across CPU, GPU, FPGA, and WASM. Kera uses custom code generation for x86-64, ARM64, and RISC-V rather than LLVM, with register allocation and SIMD kernel selection. Side effects are tracked, and Rust-style ownership spans host, device, pinned, and unified memory. The project is a Rust workspace with distributed execution, capability-based security, and LSP tooling.","product-kera.dae906110d":"Heterogeneous execution.","product-kera.505c8342c6":"Graph-native IR. Custom JIT.","product-kera.9d0c8700b0":"Product, Kera","product-kera.f9743247fa":"Read the documentation","product-kera.937d81c77c":"Bring the operation, shapes, target, flags, and determinism requirements you use in production. We will compare the emitted path and show where retaining the graph changes the result.","product-kera.492bc68b25":"One graph. Execution planned for the target.","product-kera.79073eaaf2":"The Netherlands","product-kera.44ab85a252":"Origin","product-kera.31da9908bc":"Custom JIT, no LLVM dependency","product-kera.6e2cc989da":"Code gen","product-kera.637caf6a44":"Content-addressed graph (.keg)","product-kera.4bfcb88fa9":"Bit-for-bit across platforms","product-kera.2956ef9ad6":"Determinism","product-kera.bca4782ae1":"x86-64, ARM64, RISC-V, CUDA, FPGA, WASM","product-kera.d35260a00f":"Targets","product-kera.e9921e9ad2":"Rust (edition 2021)","product-kera.89b86ab0e6":"Language","product-kera.b57dd9805c":"All rights reserved","product-kera.3229609e15":"License","product-kera.2f09460ea1":"Product sheet","product-kera.b5295d3a59":"Kera combines a graph-native systems language, a content-addressed IR, a compiler, a JIT, and a heterogeneous execution system. It keeps types, effects, ownership, dataflow, memory spaces, and execution policy visible while producing target-specific plans for supported CPU, GPU, FPGA, and WebAssembly paths. LLVM is not at the centre of the compilation chain.","product-kera.cca888c3d4":"Identical results.","product-kera.e8fbca4720":"One graph. A plan for each target.","product-kera.2d59bcb876":"Explore the docs","product-kera.847fa9baac":"Kera is priced separately for licensed deployments. Talk to us about the target portfolio, isolated operation, and any separately selected source, review, or technology-transfer rights.","product-kera.91e60f15eb":"The computation keeps its identity to the machine.","product-kera.824d76b124":"Learn more","product-kera.8eb355f726":"Dweve, The Netherlands","product-kera.eae192773b":"Made by","product-kera.64ae43e8fe":"Cost","product-kera.60c91404fd":"AI, robotics, finance, science, games","product-kera.10006a8df8":"Use in","product-kera.9650950575":"Native machine code via a custom JIT compiler","product-kera.2d2cb022bc":"Speed","product-kera.8521ad18f2":"Dweve AI inference and simulation workloads","product-kera.236656bf91":"Powers","product-kera.6abee42d2a":"Programming language for consistent, fast computation","product-kera.ca032b5844":"What it does","product-kera.fca77b7e3a":"At a glance","product-kera.e89c5a1fe5":"Request a demo","product-kera.14b9569c69":"Software often passes through so many translation layers that the computer no longer sees the job as a whole. Kera keeps the calculation organised as one graph, then prepares an execution plan for the machine doing the work. That can remove needless steps, reduce movement, and leave a clearer record of what actually ran.","product-kera.88256e8e62":"no matter whose kitchen.","product-kera.db592c9171":"A recipe that always tastes the same,","product-kera.fe0a091fdb":"Products","product-kera.68fca34159":"Dweve Kera, Direct Computation","product-kera.4ae0430100":"A systems language and compiler","product-kera.d37334219f":"for deterministic computation","product-kera.a0809c5e2d":"Dweve Kera is a graph-native systems language and compiler for deterministic computation on heterogeneous hardware. Its statically typed, content-addressed intermediate representation keeps the operation visible through planning, then emits execution for CPU, GPU, FPGA and WebAssembly. The graph remains the programme.","product-kera.978ed3e13d":"See the direct path","product-kera.90214883b6":"Talk to us","product-kera.e1dd48620c":"The direct path","product-kera.622a656538":"DIRECT","product-kera.e408a0f89e":"Compiler centre","product-kera.5e58e3443d":"no LLVM","product-kera.200fd551fc":"Graph IR","product-kera.c051c13738":"content-addressed .keg","product-kera.08afa6be84":"Emit","product-kera.6e93bc70b9":"target-specific native","product-kera.640d089c70":"planned, scoped","product-kera.cf1caaae2a":"Every run","product-kera.22ab08a0a5":"a graph identity","product-kera.528f9df395":"The generic compiler tax","product-kera.de41946a09":"Every lost fact","product-kera.c0059b89c3":"closes one more door","product-kera.8e10ecf68c":"A general-purpose compiler must serve every kind of software. Its breadth limits how deeply it can understand a specialised operation once a frontend has lowered it into loops, pointers, and generic arithmetic, and no later stage can restore what that lowering removed.","product-kera.69245647ac":"Operation identity, algorithms, packing intent, expected shapes, determinism, and memory ownership can scatter across tools before final optimisation. The cost is every useful choice that becomes impossible after the computation forgets what it was.","product-kera.fe6d1c39b6":"Lost meaning","product-kera.5dc7b8a3a9":"Tool split","product-kera.adaa813a07":"Early limits","product-kera.d55e402e23":"Facts lost in lowering","product-kera.c748b9c310":"a matrix multiplication, flattened","product-kera.f6eceac035":"Lost operation","product-kera.6eb3a1f240":"The matrix multiplication becomes anonymous loops.","product-kera.1d1bf58a5c":"Lost shape","product-kera.9f49db5cd4":"Expected tensor and vector shapes disappear.","product-kera.3114ae8cee":"Lost packing","product-kera.03504d1093":"Accumulator and packing intent are gone.","product-kera.d4f72fc918":"Lost ownership","product-kera.cdbff62c4e":"Host and device memory rules fall away.","product-kera.bea4fec4f5":"Lost neighbour context","product-kera.2cdd771bc0":"The relationship between operations is cut.","product-kera.678cdb8d3a":"the first advantage is not a faster instruction","product-kera.6698271d72":"it is remembering what the instructions are for","product-kera.e6751c5167":"Kera keeps those facts attached to the operation.","product-kera.247266e288":"Kera never forgets the operation","product-kera.8d2696558c":"The compiler knows","product-kera.33b7cf8959":"what it is compiling","product-kera.6a3b2800ca":"Kera represents computation as a typed graph. An operation stays an operation instead of becoming anonymous low-level code too early. Its inputs, outputs, shapes, effects, ownership, memory spaces, and execution policy remain attached to it.","product-kera.8d0201d104":"Retained context lets Kera choose from the operation itself, fuse related work across the graph, and plan movement from declared ownership. A generic chain must infer those facts from low-level patterns after they are lost, which is why the same source can compile to very different machine behaviour depending on how much meaning survived the journey.","product-kera.4a39131bf6":"Operation ID","product-kera.3a87c1396c":"Typed plan","product-kera.052e1fcf07":"Semantics first","product-kera.7fc7df93e0":"One graph node, opened","product-kera.f0ecb4f25c":"what the planner can still read","product-kera.fcb60bc535":"operation","product-kera.1db089a9f8":"identity","product-kera.579d66df53":"A vector logarithm stays a vector logarithm","product-kera.63eb44aa9d":"dtype","product-kera.31138da7de":"numerical type","product-kera.0299141f46":"The declared fixed-point profile is retained","product-kera.5080fd62c2":"shape","product-kera.e9dc3a9121":"tensor shape","product-kera.5468a8f218":"Expected sizes travel with the node","product-kera.23f4d47c92":"effects","product-kera.0baff051a0":"declared","product-kera.961bd97a97":"Pure or effectful is explicit","product-kera.a94a58406e":"region","product-kera.6ef9514c35":"memory space","product-kera.acdc0f94b3":"Where the value lives is known","product-kera.d61ceadbdb":"contract","product-kera.26de05a44d":"accuracy","product-kera.30261431be":"The approximation contract is attached","product-kera.4029766a0d":"implementation chosen from meaning","product-kera.f46205e60a":"not from a late loop pattern","product-kera.e2eb193037":"Retaining meaning matters only if Kera can turn it into a different plan.","product-kera.1b5e497f45":"Whole-graph planning","product-kera.ed45a544dd":"Plan the whole graph","product-kera.3696d3f4ee":"not a local repair","product-kera.5b10c8bd24":"A conventional compiler often optimises after the programme has been separated into layers, each owned by a different tool. It optimises the local representation it receives. Kera can plan the computation as a whole graph before it emits.","product-kera.32b49f1685":"That wider view lets Kera fuse operations, remove intermediates and transfers, keep data in one memory space, and select target-specific kernels. Kera can also prevent unnecessary work from existing in the first place.","product-kera.8d1233c7c3":"Whole graph","product-kera.7db5bc8052":"Work removed","product-kera.890336e28d":"Plan first","product-kera.7fe1a9c798":"From graph to emitted code","product-kera.cef52c3fd7":"five planning stages","product-kera.18ca87afec":"Inspect","product-kera.602beaafc9":"Read the typed graph and its contracts.","product-kera.c32a0147f2":"Place","product-kera.6ccc9db67c":"Assign operations to targets and regions.","product-kera.cdc25e51f3":"Fuse","product-kera.0bcd11a6bd":"Merge compatible operations, drop intermediates.","product-kera.76cdb95072":"Move","product-kera.3db82b424e":"Plan or eliminate data movement.","product-kera.e5af55375b":"Generate target-specific native execution.","product-kera.31d980a769":"the architecture claim","product-kera.7087671d61":"needs evidence on real operations","product-kera.c46e262eb3":"The architecture claim needs evidence on real operations.","product-kera.20f72479b9":"The LLVM ceiling is not the machine ceiling","product-kera.e14468e9e0":"Optimised LLVM sets","product-kera.9c072cb83b":"a baseline, not a limit","product-kera.41047d2c30":"Kera does not claim that every programme beats every generic compiler. It shows something more useful. On current internal tests, the Kera emit path can exceed an already optimised generic path by a wide margin on several operations, while the claim stays specific to the operation and its tested shapes.","product-kera.a2fdc6a544":"The largest current leads appear on vector logarithm, large matrix multiplication, and several vector maths functions, where retained graph meaning enables a better emit path. Every published figure includes its hardware, compiler, flags, and harness because results differ across machines.","product-kera.5182b88001":"Scoped tests","product-kera.ca9e3d8b20":"Full harness","product-kera.6b8b5e254f":"Baseline","product-kera.7d83b83196":"Where the leads are largest","product-kera.f87153790e":"current internal operations","product-kera.e762186a25":"Vector logarithm","product-kera.a636e6cea2":"A large lead across the tested fixed-point profiles.","product-kera.f236c7e88a":"Matrix multiplication","product-kera.71bb8aaa6b":"The largest lead, at 512 by 512 and above.","product-kera.bdde93ee43":"Vector exponential","product-kera.60f7c42cc9":"Several times faster across the tested fixed-point profiles.","product-kera.98a3457df7":"Vector tanh","product-kera.e97d6f4fa9":"A clear lead across the tested fixed-point profiles.","product-kera.f85d624735":"Binary dot product","product-kera.7b5d2320b5":"A strong lead across tested sizes.","product-kera.952b2e6142":"the large wins","product-kera.cd1adf7039":"are not the whole result","product-kera.62b6079d52":"The large wins are not the whole result.","product-kera.e13c31b303":"Breadth, not one benchmark trick","product-kera.f053d4add6":"Gains across","product-kera.33150bca26":"different operations","product-kera.0ed727ea7e":"The headline operations are not the whole story. Current tests show smaller but real improvements across binary and fixed-point matrix multiplication, ReLU, vector addition, sigmoid, binary reductions, and bitwise operations. Some cases remain near parity.","product-kera.31906eaf09":"Those neutral and parity cases stay visible in the benchmark report rather than being removed from it. Breadth across unrelated families is the point. A gain that repeats across many operation kinds is evidence of an architecture, not of a single favourable kernel.","product-kera.38b58daf0b":"Broad tests","product-kera.b14a6bbf97":"Parity shown","product-kera.f35b5e842b":"Architecture","product-kera.20a46061af":"The gain spectrum","product-kera.984bac67c1":"parity through the largest leads","product-kera.73fe3c6ca7":"Parity","product-kera.1d6382fe58":"Some shapes are level and stay on the report.","product-kera.254c159afb":"Modest","product-kera.020471204d":"Small single-digit gains on some bitwise paths.","product-kera.d404968ea9":"Medium","product-kera.c497dc0158":"Clear gains on additions and activations.","product-kera.738fd1d245":"Large","product-kera.6be3c8a5a3":"Strong gains on several matrix and vector paths.","product-kera.03d0bc8836":"Dramatic","product-kera.ca06cff3f4":"The headline maths and matrix leads.","product-kera.2da030c982":"speed comes from more","product-kera.c7dcd4eddd":"than instruction selection","product-kera.448051d54a":"Speed comes from more than instruction selection.","product-kera.4c914c72b2":"The generic build is already fully optimised","product-kera.1a3fbbc9ba":"Fair comparisons need","product-kera.b078c211ff":"Vectorisation is enabled, the target CPU is enabled, and vendor maths libraries are linked.","product-kera.3af32b3838":"The profile-guided path has been checked, and Kera still leads on the tested operation.","product-kera.094ca86d10":"Already optimised, still behind","product-kera.9e5925a350":"Vectorisation enabled","product-kera.7b75b509ab":"Target CPU enabled","product-kera.d57f62ff72":"Vendor maths linked","product-kera.dc76599785":"Profile-guided path checked","product-kera.5463218f40":"The missing optimisation was not another flag. It was the operation meaning the generic path no longer had.","product-kera.78362929d4":"Data movement is part of the programme","product-kera.48ce413830":"Plan memory traffic","product-kera.49bfe80e05":"and move less","product-kera.b29431d418":"Modern performance is often limited more by moving data than by calculating with it. Yet movement between host, pinned, device, unified, remote, and persistent memory is frequently managed through interfaces outside the language ownership system.","product-kera.5c0698e7e8":"Kera makes memory spaces and ownership explicit. The graph states where data lives, which operation owns it, which may change it, and when ownership transfers. The planner can remove movement, expose it, or reject an illegal transfer before execution.","product-kera.a275d67c18":"Ownership","product-kera.22ccddf906":"Transfers","product-kera.a6d6dcf48f":"Blocked","product-kera.73db554330":"One value across memory spaces","product-kera.7075ec4b7a":"six crossings become two","product-kera.ddfe163345":"01","product-kera.3960ec4ca5":"Host","product-kera.78e695d59c":"The value begins in host memory.","product-kera.414768af9d":"wide","product-kera.bcac9d1d8e":"02","product-kera.a5a74a6df0":"Device","product-kera.941990f155":"A conventional lane copies it across.","product-kera.3ea6c91e24":"03","product-kera.9cbe42aaff":"Planned","product-kera.de342fb6ac":"Kera keeps it on device where it belongs.","product-kera.f235f22d8e":"mid","product-kera.798f861ee7":"04","product-kera.b62ff5ccd1":"Owned","product-kera.e0651a5ecc":"An ownership token follows every move.","product-kera.8def4372cd":"few","product-kera.ddaa3abe0f":"movement is safe to optimise","product-kera.10d308d5d4":"because effects are explicit too","product-kera.430d23154b":"Data movement is safe to optimise because side effects are explicit too.","product-kera.66ccfd9104":"Effects are visible before execution","product-kera.f258c5aecd":"Every effect","product-kera.d3da033d48":"declared in advance","product-kera.e07956a040":"A programme that appears to calculate may also read a file, contact a network, modify persistent state, or invoke a device. In conventional systems those effects can hide several library layers below the code under review, so a reader cannot tell from the source what the programme will touch.","product-kera.9c3a353a67":"Kera tracks effects in the language and graph, while capabilities define what a deployment permits. An isolated system can reject network access, and a regulated programme can inspect the declared effects before execution rather than after an incident. The gate is a deployment decision, not a code review.","product-kera.ab71cb0430":"Typed effects","product-kera.b51f9a73dd":"Access limits","product-kera.0fe35a921c":"Pre-run review","product-kera.90828e0785":"The effect surface","product-kera.4d26776376":"declared, then enforced","product-kera.b075a99f17":"Pure","product-kera.0f9ef12c3e":"Calculation with no external action.","product-kera.bf31c52c32":"safe","product-kera.2c3cafa4db":"File","product-kera.f4130e994c":"Declared file access, nothing hidden.","product-kera.53ebc572b4":"Network","product-kera.c3ed557280":"An undeclared edge is blocked in planning.","product-kera.18cd42d86d":"gated","product-kera.13bcc5c25b":"Mutation","product-kera.877a1b3b5f":"Changes to persistent state are explicit.","product-kera.a45c2264b8":"explicit","product-kera.2e601650ba":"Device interaction is a declared effect.","product-kera.9260ffcb7f":"Persistent","product-kera.7d5d457d77":"Durable state is part of the surface.","product-kera.4c54cc4d8b":"tracked","product-kera.4fc58ff80c":"a graph that states what it does","product-kera.939a18de54":"can become an asset with an identity","product-kera.21c3471458":"A graph that states what it does can become an asset with an identity.","product-kera.4f59b86c8e":"The graph becomes the computational asset","product-kera.57b599c37d":"A computation","product-kera.1c5f1db260":"with an identity","product-kera.0288e2814c":"Source code identifies what a developer wrote. It does not always identify the complete computation that ran. Kera compiles programmes into content-addressed .keg graphs, and every node receives an identity derived from its content.","product-kera.2afb7bc51d":"Change a node and its identity changes; leave it alone and the identity stays stable. An organisation can identify the graph it reviewed and deployed, isolate a changed subgraph, and connect a controlled run to its exact artefact.","product-kera.77ecc5595d":"Content addressed","product-kera.2cf84c8e01":"Stable identity","product-kera.dc36e2a41a":"Approval trail","product-kera.f97c480441":"The .keg certificate","product-kera.f9bfc7e47d":"what identity records","product-kera.2346ad27d7":"hash","product-kera.84bd2b0362":"graph identity","product-kera.4254052a6c":"Derived from the content of every node","product-kera.004550065a":"nodes","product-kera.b16b210913":"typed operations","product-kera.a53b9c91c4":"Each with its own stable identity","product-kera.84e0542d83":"declared surface","product-kera.34feedbf98":"The external boundaries recorded","product-kera.e87e846a2b":"exports","product-kera.e63ff62479":"public results","product-kera.ada74cfa03":"The outputs an approval can pin","product-kera.c37acdb82b":"one changed node","product-kera.ea3db1640e":"rekeys only its affected ancestry","product-kera.924afc4cc6":"One identity can still produce a plan shaped for each machine.","product-kera.4dee2983be":"One graph, target-specific execution","product-kera.52838d6f5f":"Plans for every target","product-kera.541cc63e8b":"from one programme","product-kera.8202b7f362":"Different machines should not be forced to execute identical instruction sequences. A CPU, GPU, FPGA target, browser runtime, and distributed cluster have different strengths. Kera separates the identity of the computation from the plan used to execute it.","product-kera.5ad45c1ed9":"The same graph can produce native CPU plans, GPU plans for a device, supported FPGA synthesis paths, portable WebAssembly, or distributed plans with partitions and recovery. Execution changes for each machine while support remains explicit.","product-kera.dee3912d5d":"One graph","product-kera.9b79c3a893":"Target plans","product-kera.cfcd8f93f7":"Stated support","product-kera.62847baef3":"Per-target support","product-kera.d95681eec7":"coverage differs by feature","product-kera.ff221d4752":"CPU","product-kera.b8979bbf1a":"Target-specific native instructions and SIMD paths.","product-kera.6887bf97d7":"Plans shaped around the target execution model.","product-kera.5cc240eecc":"Synthesis artefacts on supported paths.","product-kera.051061c35d":"WebAssembly","product-kera.ca899cd8ae":"Portable sandbox and browser execution.","product-kera.81698cb581":"Partitions, collectives, checkpoints, recovery.","product-kera.4a724470a2":"target-specific code","product-kera.4cc617b55e":"does not require target-specific answers","product-kera.3faed3ed23":"Target-specific code does not require accidental target-specific answers.","product-kera.c249c9008d":"Determinism is planned","product-kera.81001e94d7":"Choose the determinism first","product-kera.ff3c044246":"because a seed arrives too late","product-kera.8a285aa17e":"Determinism is often treated as a debug mode that disables optimisation. Kera treats execution policy as part of the graph and plan contract, so the planner knows the required contract and its exact scope before it emits execution, and strict work does not have to give up its plan to stay reproducible.","product-kera.d4911c4054":"Strict mode selects deterministic arithmetic, ordering, scheduling, and code-generation paths. Seeded mode repeats controlled variation; creative mode permits it. Guarantees stay scoped to tested operations, backends, and plans.","product-kera.ca6a8f733a":"Plan policy","product-kera.c97ace1424":"Guarantees","product-kera.530581d19a":"Reproducible","product-kera.d799294b1e":"Three execution contracts","product-kera.eedc432e74":"one graph, three plan lanes","product-kera.47ed8fde8f":"Strict","product-kera.299ba29343":"Stable arithmetic and ordering yield a stable hash.","product-kera.4fbacc2fa0":"stable","product-kera.51095bb5db":"Seeded","product-kera.3fcf3919df":"Controlled variation repeats with the same seed.","product-kera.50aff7939a":"repeatable","product-kera.20ccbc66c1":"Creative","product-kera.b0221b15de":"Intended variation yields a distribution.","product-kera.75b4d7d721":"varied","product-kera.690252d07c":"the same planning model","product-kera.053ed984c6":"extends when the graph leaves one machine","product-kera.90cc808938":"The same planning model extends when the graph leaves one machine.","product-kera.66e9900297":"Distribution without programme loss","product-kera.496dbfcee5":"Scale the plan","product-kera.82f58bd609":"not the ambiguity","product-kera.e55ca5b79f":"Distributed programmes often become collections of services, queues, schedulers, workers, and checkpoint systems, until the original computation disappears into infrastructure. Kera can represent distribution as an execution plan over one graph, so the thing being scaled is still the programme rather than the plumbing around it.","product-kera.4ff6088053":"Partitions, collective operations, network effects, checkpoints, and recovery stay tied to the graph. A node can fail without turning the programme into unidentified processes. Scale changes the plan; it does not erase the programme, and the identity that comes back after recovery is the identity that went in.","product-kera.08c69f28ef":"One graph","product-kera.1a88e0fc2c":"Explicit collectives","product-kera.fdc6703e67":"Identity retained","product-kera.71dce2b4fc":"The distributed plan","product-kera.ec327aa94d":"five stages over one graph","product-kera.943df06a52":"Partition","product-kera.dde6898b7c":"Split the graph across nodes.","product-kera.cbb4cc4982":"Transfer","product-kera.b3761c5ae5":"Declared movement between partitions.","product-kera.d8e97c28f7":"Collective","product-kera.c3ca4ed1b5":"Explicit ring all-reduce and exchange.","product-kera.5cb9afc059":"Checkpoint","product-kera.8d0732fba5":"Recovery state tied to the graph.","product-kera.4addbf1673":"Recover","product-kera.70946e489d":"A failed node restores without changing identity.","product-kera.d85bc3cdeb":"one graph","product-kera.518f938ebd":"deserves one accountable compiler chain","product-kera.9423c6c2bb":"One graph deserves one accountable compiler chain.","product-kera.00ba602f0b":"One compiler chain under one owner","product-kera.7938644440":"No generic compiler","product-kera.63a205997f":"in the centre","product-kera.15954976c5":"Kera does not depend on LLVM at its centre. Dweve owns the language, type system, effect model, graph IR, planner, lowering, register allocation, SIMD selection, JIT, device paths, and runtime semantics across the full supported target surface.","product-kera.daa2d1b7a3":"Operating systems, drivers, firmware, and hardware sit outside Kera. The central chain that defines a programme and its execution belongs to one product and team, so strategic customers can negotiate support around the system itself rather than around a set of separately owned parts.","product-kera.86adbe0b9e":"Owned chain","product-kera.5d0e5b6012":"Clear boundary","product-kera.f47a0df232":"Accountable","product-kera.7d0964330a":"Source to execution","product-kera.a82b73d395":"one owner across the chain","product-kera.6da13addb0":"Source","product-kera.5dba98c8ce":"The graph-native language.","product-kera.9a7405ebce":"Graph","product-kera.0c715b50bf":"The content-addressed .keg IR.","product-kera.ae2f98a099":"Plan","product-kera.8457faca87":"Whole-graph planning and placement.","product-kera.c6dcbd318c":"Kera lowering, register allocation, and codegen.","product-kera.6ea36ce8d4":"Execute","product-kera.fc89b1dac9":"The Kera runtime on the target.","product-kera.d11e0dac41":"Kera owns computation","product-kera.f9be503991":"Core owns the complete AI machine","product-kera.432cb35720":"Kera owns computation. Core owns AI. The boundary must stay sharp.","product-kera.18d1819895":"Kera and Core are different products","product-kera.fefa0bd607":"Computation below,","product-kera.eb92d987fd":"the AI machine above","product-kera.07f4a51429":"Core supplies the complete AI machine. It carries the AI and machine-learning algorithms, operations, representations, training methods, inference system, kernels, dispatch, and serving infrastructure used by Dweve products.","product-kera.6adbf6b5c9":"Kera supplies the deeper path: graph-native language, content-addressed IR, whole-graph planning, owned lowering, and a runtime for the supported targets. It is the layer that decides how a computation reaches the machine, not what the computation is for. Where a package includes it, Core operations can be routed through that path without the products above changing.","product-kera.4982b3db65":"AI layer","product-kera.992205d999":"Compute layer","product-kera.2c59ac441b":"Selected path","product-kera.4f2d5cda45":"Core Native versus Core on Kera","product-kera.e07fdb34c7":"two lanes beneath Core","product-kera.b14e0fee60":"Core Native","product-kera.77a36926b3":"the complete AI machine on Rust-native execution","product-kera.b416d2b35e":"AI operations and representations","product-kera.a866dd9a20":"training, inference, serving","product-kera.56adaaabdc":"kernels and dispatch","product-kera.1307de22b6":"included with Core","product-kera.ff12047a09":"broad and complete on its own","product-kera.5bd7bdd9b6":"Core on Kera","product-kera.cb772a19ca":"the same AI machine on the direct path","product-kera.0006a09fcf":"operations become graph nodes","product-kera.b701bb777a":"whole-graph planning and fusion","product-kera.c06b9c3ebb":"target-specific direct emit","product-kera.fcb80b35b0":"selected strategic licensing","product-kera.7df9de8fc1":"the deeper execution foundation","product-kera.33193264dc":"direct computation is strategic","product-kera.395a36df67":"because the path itself is strategic","product-kera.f443e90223":"Direct computation is commercially significant because the path is strategic.","product-kera.913a763c67":"Commercial because the path matters","product-kera.11fbe7f73e":"The deepest path","product-kera.8dc7185c2f":"is licensed","product-kera.05d9e213ee":"Kera is a proprietary Dweve product. It is not included in every Core licence and it is not presented as open source. Organisations purchasing the deepest execution path need a party accountable for that path.","product-kera.c70146ec52":"The target portfolio defines supported machines and delivery. Support, escrow, review, operational source, isolated commissioning, operator-held keys, and technology transfer are separate rights unless agreed.","product-kera.0b0db435a5":"Proprietary","product-kera.b15fec0012":"Agreement","product-kera.ccc963aa3d":"Owner","product-kera.63fb347dde":"What an agreement can cover","product-kera.c516aef713":"no invented packages or prices","product-kera.c4740e4ca2":"Runtime","product-kera.eeb037e093":"Rights to run Kera on agreed targets.","product-kera.f32d5a3b17":"Support","product-kera.7a440d92be":"Support and indemnification terms.","product-kera.b333d65133":"Escrow","product-kera.14b2baee19":"Source escrow where separately selected.","product-kera.830be5e950":"Source review or delivery only where expressly contracted.","product-kera.9b6a2f8838":"Technology transfer and custom target work.","product-kera.fb8996a122":"the path is European by origin","product-kera.33d298de2a":"and controllable by deployment","product-kera.4ceed20869":"The path is European by origin and controllable by deployment.","product-kera.f322daecf6":"European computational control","product-kera.f905ca9bea":"Control reaches below","product-kera.f4075b16fd":"the cloud layer","product-kera.bd43f64fbe":"Kera is designed and built in the Netherlands. Direct Kera operation belongs to an eligible licensed customer-controlled or fully isolated deployment, according to the agreement and target portfolio.","product-kera.2a0a5aacb9":"Sovereignty is not only about source location or server geography. It depends on control of the language, IR, compiler, runtime, target road map, semantics, operator, drivers, configuration, and supply chain.","product-kera.cddd3908ac":"Dutch origin","product-kera.9aa4efaeff":"EU licence","product-kera.cc5882cdc3":"Semantic control","product-kera.f1df794cc2":"What a posture controls","product-kera.c19e6c5f24":"configuration, not geography alone","product-kera.0f21717994":"Region","product-kera.aa3e978fa1":"Where the deployment is hosted.","product-kera.7843fc5bea":"placement","product-kera.e5651c683f":"Keys","product-kera.95470a276b":"Operator-held keys where agreed.","product-kera.fe96dd3975":"operator","product-kera.355d259f17":"Outbound effects","product-kera.fb7d3f805c":"Which external boundaries are permitted.","product-kera.72b6facb06":"Target allow-list","product-kera.0ea446f15b":"Which targets a deployment may use.","product-kera.6543f14e1a":"scoped","product-kera.545782292b":"Operator access","product-kera.6c6ae4ac83":"Who can act on the running system.","product-kera.547ff52d6c":"controlled","product-kera.c0b700d1ec":"Kera is the deepest lane","product-kera.5704594f12":"not the whole Dweve stack","product-kera.c25147caed":"Kera is the deepest lane, not the whole Dweve stack.","product-kera.a5541608ff":"Kera in the Dweve system","product-kera.19f4cca33f":"beneath every product above it","product-kera.dbc53d50f3":"Kera is the deepest licensed computational foundation in the stack. It executes computation beneath the products above it, it is included only where the agreement requires it, and the products above do not change shape depending on whether it is present.","product-kera.20129cc874":"Core supplies AI, Loom composes specialists, and Nexus coordinates tools, rules, people, and AI. Spindle preserves knowledge, Mesh distributes work, and Fabric serves it. Kera does none of those things; it is the computational path those layers can stand on.","product-kera.8c3b7ad87f":"Foundation","product-kera.6ab1333147":"Licensed scope","product-kera.cc3ad49e5c":"Under the products","product-kera.b2e5154f65":"The direct path in the stack","product-kera.9375e727c5":"from Kera up to Fabric","product-kera.60ecfc0d27":"Direct graph-to-machine computation.","product-kera.68836c550e":"Core","product-kera.8cdde04eea":"With Kera","product-kera.8309fcbe88":"Core operations become graph nodes and regions Kera can plan, fuse, lower, and emit","product-kera.56d5a5605b":"Without Kera","product-kera.acaa562115":"Core falls back to its Rust-native execution path","product-kera.6aa18a0d30":"Two contracts","product-kera.022252b985":"The products do not collapse, each owns a distinct layer","product-kera.de8011f844":"The complete AI machine above it.","product-kera.69697ca450":"Loom, Nexus, Spindle, Mesh compose on Core.","product-kera.a010de5c61":"Fabric","product-kera.6d315b6a9e":"The user surface at the top.","product-kera.aa442d4a07":"every deployment that receives Kera","product-kera.6b0a2b47d2":"gains a direct graph-to-machine path","product-kera.a8754b9738":"Bring the operation your strongest generic path already optimised.","product-kera.1cf3641b7a":"Bring the operation","product-kera.90e55be97c":"Bring the production operation, its real shapes, the actual frontend, the strongest generic flags, the target machine, the accuracy requirements, and the deterministic contract. Compare execution, movement, emitted code, graph, and result. The question is no longer whether a custom compiler can catch a generic one. It is what becomes possible when the compiler never forgets the computation.","product-kera.f6443a40b3":"Bring your operation","product-kera.9e3c1d591d":"What the claims stand on","product-kera.29a184b65c":"graph","product-kera.2b8a8fe488":"A computation with a stable identity","product-kera.2d2794fd3e":"custom emit path","product-kera.f865970e42":"Kera lowering with no generic compiler centre","product-kera.3a9055585a":"plans","product-kera.045e25a289":"target-specific execution","product-kera.89588b51b8":"One graph, many honest target plans","product-kera.0a4ca4ce7e":"harness","product-kera.0571d03553":"reproducible evidence","product-kera.e13183fd7d":"Every figure travels with its full envelope","product-kera.ea717892a4":"The compiler knows","product-kera.0513cea9a7":"Kera is a graph-native systems language and compiler for deterministic computation. Its planner keeps programme meaning visible until direct target emit: a vector logarithm is still a vector logarithm. The emitter chooses code because it still knows the operation, not because it recognised a loop pattern too late.","product-kera.d58c64b171":"Inspect a .keg graph","product-kera.161480a2d3":"Read the architecture","product-kera.1069afd867":"Types and effects","product-kera.94431bd564":"survive to emit","product-kera.a45e4a56cd":"Emit path","product-kera.58065ab442":"Kera codegen, no LLVM centre","product-kera.2f4d393f85":"per feature, stated","product-kera.72bfd01f33":"planned into the graph","product-kera.abd497a3a4":"The graph is the programme","product-kera.3408c02bc4":"Durable graph IR","product-kera.31e7d69af5":"not a temporary view","product-kera.c366718c09":"Kera does not wrap a graph around an ordinary instruction stream as a passing optimisation view. The graph is the durable programme representation. Source is checked into a typed, effect-tracked, ownership-aware, content-addressed .keg graph.","product-kera.be52cbe6ba":"Planning, fusion, placement, movement, lowering, target emission, partitioning, and replay all derive from that graph. The programme stays semantically rich until Kera emits its target plan, retaining information that generic lowering may already have discarded.","product-kera.2c7ec6fc75":"Graph programme","product-kera.b75cf5fa72":"Derived plans","product-kera.7d7d68b67c":"Until emit","product-kera.c64e24a9b9":"From source to replay","product-kera.6c08c9199d":"the graph is retained throughout","product-kera.79ad3e32ea":"Checked into a typed .keg graph.","product-kera.92af7ebb2c":"Planning derives from the graph.","product-kera.a382513d37":"Compilation keeps graph context.","product-kera.0c32087c5a":"Target code from the same graph.","product-kera.c0f85d6679":"Replay","product-kera.22f4deffea":"Reconstructed from the graph.","product-kera.3f71544975":"the graph can only be durable","product-kera.d171d7cd2e":"if identity is structural","product-kera.d64e752fff":"The graph can only be durable if identity is structural.","product-kera.206b4f4905":"Content-addressed .keg","product-kera.0b3961cacb":"Content gives identity","product-kera.2a1d839b27":"so a change cannot hide","product-kera.e9eeb552e9":"A .keg file is a content-addressed graph artefact. Each node is identified from the content it represents, and the complete graph captures types, dependencies, regions, exports, effects, and target-relevant metadata.","product-kera.8a1eb202a3":"Content addressing gives the programme a stable identity. Unchanged nodes keep it, changed nodes receive another, and graph diffs isolate change. Caches and records refer to the exact artefact.","product-kera.4acea90893":"BLAKE3 identity","product-kera.1f94152262":"Computation cache","product-kera.cc760bb063":"Readable","product-kera.75feac5ee8":"The .keg record","product-kera.bda28b1dac":"what content addressing pins","product-kera.eb646a38da":"content identity","product-kera.8e0a17a9ec":"Derived from node content, not position","product-kera.75a0ee1ba9":"diff","product-kera.f56972c915":"semantic change","product-kera.3bc7dbd397":"A graph diff isolates what moved","product-kera.b03592806e":"cache","product-kera.d14102b4f3":"keyed by content","product-kera.11026ce64c":"Shared subgraphs are recognised","product-kera.d145a2a905":"pin","product-kera.0a5542a134":"approved artefact","product-kera.90726e63ca":"The exact graph an approval names","product-kera.ac72fffcef":"identity preserves change","product-kera.62a032238a":"types preserve meaning","product-kera.407f1cde13":"Identity preserves change. Types preserve meaning.","product-kera.1b812ee011":"Types survive lowering","product-kera.c08639e2bd":"Types inform the plan","product-kera.04e31266eb":"not just the checker","product-kera.71119f01d6":"Kera's type system is not thrown away after frontend checking. Types participate in graph construction and planning. Numerical type, shape, region, memory-space ownership, effects, and capabilities remain relevant to lowering and emit.","product-kera.9a352b801f":"The planner does not optimise an untyped instruction stream after material facts have vanished. The same type system constrains legal execution and supplies optimisation context, so shape and layout remain known when lowering begins and the backend never has to guess them back.","product-kera.2330b78b77":"Types retained","product-kera.2564c394db":"Plan constraints","product-kera.3da54dc7ac":"Known shape","product-kera.fe56986284":"What the type carries","product-kera.ef9677eeb0":"facts the planner can use","product-kera.323823482b":"Numerical type","product-kera.4ed2e8c275":"The declared dtype travels with the value.","product-kera.277b5417df":"Shape and layout","product-kera.20ae845afb":"Expected sizes and packing are retained.","product-kera.b7374e4b69":"Memory space","product-kera.8b69626a46":"Ownership and region are part of the type.","product-kera.08ea84b95f":"Effects and capability","product-kera.84a4d2ce72":"What the value may do stays visible.","product-kera.e13e23cad0":"effects are not ordinary values","product-kera.a7ffb6cd27":"and cannot be optimised as if they were","product-kera.d10a7868d2":"Effects are not ordinary values and cannot be optimised as if they were.","product-kera.abc9d8cfba":"Effects are explicit","product-kera.ba6cff23fe":"Effect types keep","product-kera.ce1e9350d0":"pure work separate","product-kera.ce8cc03475":"Pure calculation and external action are different computational categories, and Kera makes that distinction explicit. Effects such as file access, network access, mutation, device interaction, persistent state, and external capability use are represented in the programme.","product-kera.4d9a9a846c":"The planner preserves effect order, the verifier rejects undeclared capabilities, and the runtime enforces the deployment set. Execution records show which external boundaries were crossed, so optimisation cannot silently treat an effectful operation as pure computation.","product-kera.e4a47d1ea3":"Effect edges","product-kera.7136d8c591":"Verified access","product-kera.5f0a6cdc86":"Ordered effects","product-kera.7ef889394c":"Effect categories","product-kera.876c9952c1":"each gated by capability","product-kera.c5b132c86e":"Calculation the planner may reorder.","product-kera.4ff88aaddb":"free","product-kera.6bc538fd02":"Declared access to the filesystem.","product-kera.71c4bbd6e4":"Undeclared use is rejected by the verifier.","product-kera.ec734b6515":"verified","product-kera.bc251506c6":"Persistent state change stays ordered.","product-kera.2f6d3eca5a":"ordered","product-kera.300de111dd":"Device interaction is an explicit effect.","product-kera.79fd1355be":"Capability","product-kera.7990c1505b":"Enforced against the deployment set.","product-kera.dc9720f398":"enforced","product-kera.b70b3c7fcd":"ownership gives Kera the same precision","product-kera.35e29a0d83":"over data movement","product-kera.23e2b9210e":"Ownership gives Kera the same precision over data movement.","product-kera.ec60281c0c":"Ownership across memory spaces","product-kera.ef888b2646":"Own the movement","product-kera.f4de5d106b":"across memory spaces","product-kera.e73dfa61ca":"Kera extends ownership beyond ordinary host memory. Values can have ownership and movement constraints across host, pinned, device, unified, remote, and persistent spaces. The graph records transfer and mutation relationships.","product-kera.f7f40d77e1":"The planner can remove transfers, merge regions, keep values on a device, or reject illegal aliasing under ownership rules. Memory safety and performance become one problem because every permitted transfer is explicit.","product-kera.cb12625190":"Cross-space","product-kera.5f89408b49":"Safety planning","product-kera.b9a1316267":"No aliasing","product-kera.d455d34e23":"One value crossing spaces","product-kera.d0b4b2e2a7":"the ownership token follows","product-kera.56dd613c9c":"The value is owned in host memory.","product-kera.a775f532a0":"Ownership transfers with the move.","product-kera.ae868d9a94":"Retained","product-kera.5f97cb9d88":"The planner keeps it on device.","product-kera.04259816ac":"Alias","product-kera.0e09a1404e":"An illegal alias is rejected.","product-kera.34b684506a":"with graph, effects, and ownership known","product-kera.1883b2f4e3":"planning can operate globally","product-kera.1ce3597123":"With graph, effects, and ownership known, planning can operate globally.","product-kera.1464117ba2":"Plan the whole graph","product-kera.a59ddfed8f":"before any code is emitted","product-kera.e777648161":"Kera plans before it emits. The plan can include topological order, target placement, graph partitioning, fusion groups, memory allocation, ownership transfer, host-device movement, parallel regions, and synchronisation.","product-kera.4b5297ab26":"The plan also selects kernels, deterministic ordering, checkpoint boundaries, distributed collectives, and recovery points. With the whole graph available, each choice stays inspectable rather than confined to a local instruction window.","product-kera.4745932340":"Graph-wide plan","product-kera.83d3eac589":"Plan first","product-kera.93c9ec6a2e":"Full context","product-kera.2bb71c3a9e":"Plan dimensions","product-kera.524c2e3cdf":"over one whole graph","product-kera.1d75774c0f":"Order","product-kera.3a3d3d7206":"Topological order and synchronisation.","product-kera.cc657a8f8b":"Target placement and partitioning.","product-kera.dc25e1c633":"Fusion groups across the graph.","product-kera.b97d763e2d":"Allocation and host-device movement.","product-kera.9790f53365":"Checkpoints and recovery points.","product-kera.be8f9784b5":"the first large win","product-kera.96218f8b2c":"is often deleting work","product-kera.f2e22c6961":"The first large win is often deleting work.","product-kera.d345a9e175":"Fusion removes work","product-kera.8674ae9921":"Fuse whole regions","product-kera.762c13905b":"and remove transfers","product-kera.2f55511f43":"Instruction-level optimisation makes an existing programme cheaper. Graph fusion can prevent parts of the programme from existing as separate work at all.","product-kera.55ce9108b5":"Kera can fuse operations, remove intermediates, retain values locally, and collapse traversals. That means fewer kernels and allocations within the graph's rules.","product-kera.c0af40b6d1":"Less work","product-kera.0bb92c8fb6":"Less data","product-kera.822f34aac5":"Semantics","product-kera.94b5459806":"Before and after fusion","product-kera.4836606075":"what the counters drop","product-kera.7ff078f264":"regions","product-kera.689e604972":"execution groups","product-kera.daab369559":"Compatible operations become one region","product-kera.80a3773590":"intermediates","product-kera.8cd6092979":"materialisation","product-kera.abfe38af38":"Values that never need writing out","product-kera.442088cd90":"kernels","product-kera.4928016aa1":"launches","product-kera.ba6f3a2898":"Fewer launches and synchronisation points","product-kera.daf529a731":"bytes","product-kera.5e142a4b65":"moved","product-kera.0c99af8ac7":"Reduced transfer boundaries","product-kera.b1a338c85c":"after planning","product-kera.5ce53f6029":"comes Kera's own lowering path","product-kera.f80c6e0d31":"After planning comes Kera's own lowering path.","product-kera.4019987b4c":"Direct emit, accurately defined","product-kera.b67374d6bd":"One owned lowering path","product-kera.db665307c6":"and no borrowed backend","product-kera.85440c25e8":"Kera owns the path from the planned graph to target code. There is no LLVM IR stage at the centre. The Kera compiler and JIT perform their own lowering, register allocation, instruction selection, SIMD path selection, kernel emission, and runtime integration for the supported targets.","product-kera.28e4b02c78":"The path still contains transformations, but they remain inside one system with access to graph and operation semantics. Direct emit means ownership of lowering, not the absence of a compiler, and every supported target still receives the planning and code generation it requires.","product-kera.53b1764cda":"Owned lowering","product-kera.3cb8589170":"Compiler path","product-kera.02d122e93a":"Semantic context","product-kera.0b2fa634f2":"Source to target","product-kera.6b77561814":"the LLVM lane is simply absent","product-kera.d38b11c203":".keg","product-kera.d624b457a4":"The content-addressed graph.","product-kera.52fd9fdf0e":"Whole-graph planning.","product-kera.897b3ac98d":"Codegen","product-kera.065fd908b6":"Kera lowering and register allocation.","product-kera.61ad50a9b9":"Target","product-kera.74b731ebef":"Native execution on the machine.","product-kera.7df9ae681e":"now compare the emitted result","product-kera.4a47337db4":"against an optimised generic path","product-kera.faf7147953":"Now compare the emitted result against an optimised generic path.","product-kera.cb2a448b30":"Benchmark: the dramatic wins","product-kera.311cffce5c":"The tuned baseline is a floor","product-kera.ca40fab5d3":"not a ceiling","product-kera.e5ae663d6c":"Current internal benchmarks compare the Kera emit path against optimised LLVM output for the same operation family and tested shapes. The largest measured leads appear on vector logarithm, on large Q16.16 and Q31.32 matrix multiplication from 512 by 512 upwards, on vector exponential, on vector tanh, and on binary dot product.","product-kera.7f696073fb":"Results depend on hardware, so each published figure must include the exact hardware, operating system, Kera revision, LLVM and frontend versions, optimisation flags, input distribution, warm-up policy, sample count, confidence interval, and complete source harness. The evidence, environment, method, and test conditions must be reproducible.","product-kera.cab6ab9bb7":"Matched work","product-kera.e388d6d792":"Tested shapes","product-kera.9d5dfa2143":"Evidence envelope","product-kera.030c9397c4":"The headline operations","product-kera.70835ad83d":"leads with tested scope","product-kera.c9e51c02ee":"Q16.16 and Q31.32 matmul","product-kera.15694861d5":"The largest lead from 512 by 512 upwards.","product-kera.f69dea5549":"Several times faster across the tested fixed-point profiles.","product-kera.3c47fec89b":"A strong lead across tested binary sizes.","product-kera.e9342df898":"a compiler architecture must win","product-kera.7ca2cd0a2a":"across more than one favourite kernel","product-kera.36245332a6":"A compiler architecture must win across more than one favourite kernel.","product-kera.35c6bb6bf1":"Benchmark: the broad wins and parity cases","product-kera.e31ad7bf8b":"The wider benchmark set","product-kera.2641ef7d88":"keeps parity visible","product-kera.7ebe760a6f":"Beyond the headline operations, current tests show smaller gains across bipolar and unipolar binary matrix multiplication. They also cover fixed-point matrix multiplication outside the largest-win path, ReLU, vector addition, sigmoid, binary reduction, binary AND, OR, NOT, XNOR, and popcount.","product-kera.f51d5ecebe":"Some tested shapes remain at parity or do not yet show a Kera lead, and the benchmark report keeps them visible. Its matrix by operation family and size shows the measured wins, parity cases, pending analysis, and current gaps together instead of selecting only favourable results.","product-kera.f3bdcdf5df":"Wider set","product-kera.14d0c84aac":"Parity shown","product-kera.0d8dfc7019":"Pending","product-kera.e57b07bd62":"Outcome by operation family","product-kera.14f7aa4972":"wins, parity, and pending","product-kera.ed159417d7":"Binary matmul","product-kera.84e3e4a095":"Bipolar and unipolar gains on tested sizes.","product-kera.fb009f2f55":"Activations","product-kera.30c1f89a00":"ReLU and sigmoid gains on tested ranges.","product-kera.0661c73016":"Vector addition","product-kera.b86e160a14":"Gains from medium to large sizes.","product-kera.3f687d3e29":"Bitwise","product-kera.3dc0eb779e":"AND, OR, NOT, XNOR, and popcount gains.","product-kera.6443b29df2":"Parity and pending","product-kera.9d24d4f6f3":"Neutral and unanalysed cells kept visible.","product-kera.2be95dd8dd":"the next question","product-kera.953b1810b3":"is why each operation wins","product-kera.fc52ae4a08":"The next question is why each operation wins.","product-kera.9b2e7796ce":"LLVM is not slow","product-kera.75d03a95cc":"Keep the graph whole","product-kera.ebd495b476":"The original operation is gone, the graph neighbours are gone, and ownership is gone.","product-kera.ef588011ec":"The packing contract is only partially encoded, and device movement lives outside the IR entirely.","product-kera.93460af1f2":"Two optimiser inputs","product-kera.7a98090861":"Original operation gone","product-kera.62aeede54d":"Graph neighbours gone","product-kera.ee3994aad0":"Ownership gone","product-kera.a92e82fbed":"Movement outside the IR","product-kera.47928ce3e2":"Kera does not beat LLVM by being a better LLVM pass. It enters emit with information LLVM was never given.","product-kera.de51b73e21":"Why the wins differ","product-kera.30f8ae0c05":"There is no universal trick","product-kera.2b5a697072":"so name the cause","product-kera.be49e96379":"The benchmark wins do not come from one universal trick. Different operation families expose different advantages, and the cause should be profiled rather than assumed.","product-kera.463d88f718":"The cause may be operation-aware algorithms, graph fusion, less materialisation, SIMD emit, or specialised kernels. Each claim needs profiling; all use retained information.","product-kera.37db1bb6dc":"Actual causes","product-kera.1f942c9e7d":"Profile first","product-kera.0775c54065":"Architecture","product-kera.e9b55af5af":"Causes by operation","product-kera.aa77c1dada":"different wins, different reasons","product-kera.543e5ce006":"Algorithm choice","product-kera.7c3d4ea5a0":"A better algorithm valid for the operation.","product-kera.42327255f1":"Fusion and movement","product-kera.ca35daa370":"Fewer intermediates and transfers.","product-kera.9aba2e41f3":"Direct SIMD","product-kera.606f77e7cf":"Target-specific emission and register use.","product-kera.f11fedb225":"Approximation","product-kera.aa0e158d1d":"A specialised path under an accuracy contract.","product-kera.0fea4dee51":"Shape specialisation","product-kera.15afa90399":"Kernels shaped to the exact size.","product-kera.443a065273":"those causes become concrete","product-kera.027e948bf2":"in the ISA emitter","product-kera.1ff35060a0":"Those causes become concrete in the ISA emitter.","product-kera.f80a0cba69":"Target-specific ISA code generation","product-kera.22308eace5":"Emit for the processor","product-kera.ec23c49605":"that will actually run it","product-kera.98e9bb7472":"Kera does not call a backend supported merely because generic native code can run there. The target model includes architecture and instruction-set capabilities, and code is emitted for the processor it will run on rather than for the family it belongs to.","product-kera.c6b7fb3f96":"CPU emit covers supported x86-64, ARM64, and RISC-V paths with available SIMD. GPU, FPGA, and WebAssembly plans follow their own execution models. Capability differences stay explicit rather than treating generic native code as support.","product-kera.41c602b00a":"Target model","product-kera.6a1c6b4282":"SIMD selection","product-kera.604b638ddf":"Stated support","product-kera.6c50c2526a":"Targets and capability","product-kera.563c80339d":"coverage is per feature","product-kera.a32491d370":"x86-64","product-kera.7e1dc8f564":"SIMD instruction sets selected where available.","product-kera.bb16ce026b":"ARM64","product-kera.aa5a5de732":"Native code generation on supported paths.","product-kera.6c2f38c24f":"RISC-V","product-kera.53f8c4c321":"Supported CPU code generation.","product-kera.c0d75ce4e1":"CUDA and ROCm where supported.","product-kera.10aa757a0f":"FPGA and WASM","product-kera.b88dd8a9c4":"Synthesis artefacts and portable sandbox graphs.","product-kera.db063d422e":"instruction selection is only useful","product-kera.bc869a0a74":"if registers and schedule are owned too","product-kera.53cbc0ca4a":"Instruction selection is only useful if registers and schedule are owned too.","product-kera.82742bc0ea":"Register allocation and scheduling","product-kera.48e905df1f":"Backend decisions","product-kera.380d2dd5d1":"keep the semantics","product-kera.9c58518246":"Kera owns register allocation and machine scheduling for its supported native targets. That matters because register decisions can use graph and operation context that would otherwise be lost before backend code generation, and a schedule chosen with that context can hold the fusion the planner asked for.","product-kera.186affc3c4":"The emitter shapes live ranges, unrolling, vector width, instruction choice, and reductions for the actual operation and target. This is not merely source compiled without a generic backend; it is an architecture in which the backend still knows what it schedules, so a spill or a widened vector is a decision about a named operation.","product-kera.014fdcdbfc":"Owned registers","product-kera.efd12e0063":"Shaped ranges","product-kera.3e0df664fd":"Semantic backend","product-kera.3062a4767b":"Live ranges, shaped","product-kera.915fb83cec":"before and after semantic planning","product-kera.d1222178ef":"Pressure","product-kera.e01a86b84e":"Register pressure read from the operation.","product-kera.32f2049c29":"Vector width","product-kera.425125b40f":"Chosen for the target and shape.","product-kera.799b496b24":"Reduction","product-kera.74dda0c6c5":"Structure fixed for the contract.","product-kera.ec6a237d2a":"Spills","product-kera.3ab262b099":"Minimised with graph context.","product-kera.aa8d388fbb":"static code","product-kera.6b80ae4816":"still needs honest runtime selection","product-kera.268b3d930c":"Static code still needs honest runtime selection.","product-kera.64967db762":"Runtime dispatch","product-kera.31f5f32af3":"Dispatch names the path","product-kera.ee8c419d37":"that actually ran","product-kera.3358d6f51b":"A compiled workload may still encounter different processors and feature sets at runtime. Kera can select an execution path according to the target, policy, and available capabilities.","product-kera.dd668b5e99":"Dispatch accounts for ISA support, vector width, devices, policy, graph shape, kernels, and memory. The execution record names the path, exposing hidden fallbacks.","product-kera.474268fd71":"Runtime routing","product-kera.8314e8b123":"Recorded path","product-kera.efd0c38262":"No fallback","product-kera.3f2b1af841":"Dispatch inputs","product-kera.23e076ce15":"what selects the path","product-kera.d7f8ed3471":"ISA support","product-kera.4c1024a2dc":"AVX-512, NEON, or a scalar strict path.","product-kera.59dc310530":"isa","product-kera.f907096e62":"Availability of a GPU plan.","product-kera.f3a929b336":"device","product-kera.bb9cf14180":"Policy","product-kera.9da57dd7c6":"Deterministic and numerical requirements.","product-kera.9f00fad98b":"policy","product-kera.ea5c1a20b7":"Shape","product-kera.a14dc7fb43":"Graph shape and kernel availability.","product-kera.435abda706":"heterogeneous targets remain one graph","product-kera.6fcf2ab839":"not one implementation","product-kera.04bfe0c6c1":"Heterogeneous targets remain one graph, not one implementation.","product-kera.d376e1cf42":"CPU, GPU, FPGA, and WASM","product-kera.261bc2bff7":"One semantic graph","product-kera.52fad316f3":"and a plan for every target","product-kera.282f3978c0":"CPU, GPU, FPGA, WebAssembly, and distributed execution should not require unrelated programme definitions. Kera separates graph identity from target plan.","product-kera.e10041a477":"One graph produces plans while retaining operations, effects, ownership, and dependencies. Target code differs; semantics do not. Each feature records unshipped capability clearly.","product-kera.6654fb8af9":"One graph","product-kera.46c9a42fa2":"No semantic fork","product-kera.f237e35935":"Feature coverage","product-kera.225ad42790":"Target plans from one graph","product-kera.cac6d6efd0":"emitted artefacts differ","product-kera.c383f9d818":"Native code with target SIMD paths.","product-kera.799751e6f2":"CUDA and ROCm execution plans.","product-kera.88c8a7191b":"Portable sandbox and browser graphs.","product-kera.a1d8f8c639":"Partitioned plans with collectives.","product-kera.174a744a59":"target variation","product-kera.1df88e2d1c":"must stay compatible with the execution contract","product-kera.9bea7d6c43":"Target variation must remain compatible with the requested execution contract.","product-kera.f55248d824":"Plan for determinism","product-kera.626cb74a01":"a seed comes too late","product-kera.58e3a6a78c":"Strict determinism cannot be guaranteed by setting a seed after the execution architecture has already introduced uncontrolled variation. Kera plans determinism into supported paths.","product-kera.284ae25175":"A deterministic plan can fix arithmetic, ordering, reductions, scheduling, device behaviour, versions, and effects. Other modes allow variation. The plan names its contract and scope.","product-kera.5c54a239a4":"Strictness","product-kera.441c7182c1":"Reductions","product-kera.627d92d2f5":"Three plan contracts","product-kera.0dde78e885":"strict, seeded, creative","product-kera.cda3c0cbf4":"Exact arithmetic and stable ordering.","product-kera.74bbf41772":"Controlled variation, repeatable per seed.","product-kera.ea176f65ae":"Intended variation where useful.","product-kera.10092298bc":"the graph and plan model","product-kera.1bfdc3a5b8":"extends across nodes","product-kera.4356987900":"The graph and plan model extends across nodes.","product-kera.ca36591fe7":"Distributed execution","product-kera.6824776a78":"Plan the distribution","product-kera.8a256e41cf":"partition and recover","product-kera.c8be46afd1":"Kera represents partitioning, ring all-reduce, communication, checkpoints, and recovery in the execution plan. The graph remains the programme being distributed.","product-kera.be47f3444a":"Local and distributed execution stay in one semantic system. Communication is an effect, identity stays intact, and a failed node recovers from its checkpoint within the programme.","product-kera.dec8a66d10":"One system","product-kera.52068e255f":"Network effect","product-kera.b74e4ac6b6":"Recovery identity","product-kera.99e02efdee":"stages over one graph","product-kera.fcfe7264a8":"Ring all-reduce and communication.","product-kera.25f77a0efe":"A node restores without a new identity.","product-kera.9cfdad27c6":"developers must be able to inspect","product-kera.81443fd0d5":"the artefact driving all of this","product-kera.9181481f27":"Developers must be able to inspect the artefact driving all of this.","product-kera.8bfafb0658":"Tooling around .keg","product-kera.2f7228a98f":"Every tool addresses","product-kera.abe63494e8":"the same graph","product-kera.2f51abe63e":"Kera tooling can inspect and operate on the graph as a first-class artefact. The developer surface includes source checking, building, .keg inspection, target planning, JIT execution, graph hashing, type and effect inspection, target emission, and execution verification.","product-kera.da1aa0f57c":"The language server and editor expose the same semantic facts the compiler uses. The graph is not an internal detail revealed after failure; it is a first-class object a developer can read, hash, plan, verify, compare, and trace throughout the toolchain.","product-kera.5954c8f22b":"Graph tooling","product-kera.788e0802ec":"Semantic facts","product-kera.6687d5c1f6":"Inspect first","product-kera.41021103e5":"Commands and artefacts","product-kera.ceaeee5493":"the developer surface","product-kera.45e5f3f72e":"Commands","product-kera.e43410f4f7":"the Kera developer surface","product-kera.25298f1752":"check and build","product-kera.38bcdeb9f8":"inspect the .keg graph","product-kera.86bb11a970":"plan and JIT run","product-kera.ed988f8ae6":"hash and verify","product-kera.fb12809720":"operate on the graph directly","product-kera.629b09f337":"Artefacts","product-kera.6e9ebf52cb":"what the tooling exposes","product-kera.ffe9efb401":"the content-addressed graph","product-kera.58a93763b3":"types and effects","product-kera.5bd139bb65":"the target plan","product-kera.a20ae41895":"the execution record","product-kera.c4f9d5510a":"the same facts the compiler uses","product-kera.aef346b47c":"the largest production user is Core","product-kera.275738699f":"but they remain separate products","product-kera.4689244f88":"The largest production user of Kera is Core, but they remain separate products.","product-kera.bfc17a6a8c":"Kera beneath Core","product-kera.6feaae586e":"Computation underneath","product-kera.306135779f":"and the AI machine above","product-kera.ce86994282":"Core supplies Kera with the complete AI and machine-learning operation universe used throughout Dweve. Core operations become graph nodes and regions that Kera can plan, fuse, lower, and emit.","product-kera.d4bdce5956":"Without Kera, Core uses native Rust. Selected packages add Kera's graph and execution foundation. Core owns AI operations, training, inference, and serving; Kera owns planning and execution.","product-kera.6aa9c36142":"Graph nodes","product-kera.9238d0f153":"Products","product-kera.0a3ea60c4f":"Terms","product-kera.f0b13264bf":"Core operation to Kera plan","product-kera.4d0b3ee5b1":"two products, one lowering","product-kera.9df97b29a0":"the complete AI machine","product-kera.c6bc202654":"training and inference","product-kera.4a9a974d41":"kernels and serving","product-kera.0b8b2dc901":"Rust-native where Kera is absent","product-kera.764fe5c4eb":"owns what the AI is","product-kera.1b0d6de078":"the direct computational path","product-kera.9f80adbad9":"operations as graph nodes","product-kera.d3be955589":"planning and fusion","product-kera.40064088b4":"direct target emit","product-kera.914b009acc":"heterogeneous execution","product-kera.627619943e":"owns how it becomes execution","product-kera.38f929de17":"access to the path","product-kera.732ab99438":"must be described as precisely as the path","product-kera.aa71619249":"Access to the path must be described as precisely as the path itself.","product-kera.1a1ccc8e73":"Commercial and source boundary","product-kera.8eaec5060a":"Running it is not","product-kera.5ee4ec22ee":"the same as reading it","product-kera.7ede81c8a4":"Kera is proprietary and commercially licensed. The public page must distinguish documented architecture from customer access rights. A licence may include different combinations of runtime use, target access, and deployment rights.","product-kera.58e0b96df2":"Support, source escrow, review, operational source, isolated commissioning, technology transfer, and custom target work are separately scoped unless agreed. Companion crates remain Apache 2.0; not every Core licence includes Kera, and the ones that do state which target portfolio they cover.","product-kera.37278a9dbd":"Proprietary","product-kera.4d439b3165":"Defined rights","product-kera.b677e3a6f2":"Separate terms","product-kera.c9e4bfa71e":"Licence dimensions","product-kera.2c10139776":"unknown packages stay outlined","product-kera.0a2bcea902":"Runtime and targets","product-kera.61d21bbe05":"Rights to run on agreed targets.","product-kera.c358538bbf":"Escrow, review, or delivery where agreed.","product-kera.f2d6c6fe8a":"Air-gapped and transfer","product-kera.112293f287":"Isolated operation and technology transfer.","product-kera.23f712c054":"Custom targets","product-kera.d2066dc01a":"New target work under agreement.","product-kera.89d0bc06de":"the close is verification","product-kera.966f4a6346":"not a sales adjective","product-kera.2a21299981":"The close is verification, not a sales adjective.","product-kera.4fb1fc20db":"Benchmark the compiler","product-kera.a9843e2c0b":"Bring production LLVM, real flags, real shapes, the real accuracy contract, and the target that matters. Publish both harnesses and raw results. Then inspect which semantic facts produced the difference. The claim is not that custom code generation is automatically better. It is that retaining semantic information and owning the emit path creates opportunities a generic compiler cannot reconstruct.","product-kera.fde9637178":"Benchmark against your build","product-kera.7734cefff5":"content identity","product-kera.0ff95f2116":"BLAKE3 node identities, inspectable before execution","product-kera.bed97175b0":"plan","product-kera.ff21cf7d36":"planner diff","product-kera.098e72b11a":"Fusion, placement, and movement over one graph","product-kera.2e96e89125":"emit","product-kera.4ff7d96042":"owned path","product-kera.73fe00a0bf":"Kera lowering with no LLVM in the centre","product-kera.341d953e69":"replay","product-kera.17e5547f1a":"strict test","product-kera.bdb739f036":"Scoped deterministic guarantees under test","product-kera.481058320b":"Dweve Kera, the direct path underneath","product-kera.272a94f63f":"Straight to the machine,","product-kera.602fd36a0b":"not the long way around","product-kera.b52b000c7e":"Dweve Kera is the systems language and compiler for deterministic computation in selected product execution paths. Most programmes pass through many layers before a computer does the work, and each layer can lose track of what the task was. Kera keeps the work as one clear plan that fits the machine doing the job.","product-kera.dc8298b58a":"See the direct route","product-kera.b009a7c55d":"The direct route","product-kera.900ded66f3":"The job","product-kera.a27ebee1ef":"kept as one clear plan","product-kera.3ab65ee84b":"The machine","product-kera.f11df07546":"gets work made for it","product-kera.d5cb3036bd":"The route","product-kera.9f85cfd453":"fewer hidden layers","product-kera.ba04f0dff5":"The result","product-kera.07d3ec6ec3":"faster and steadier","product-kera.8b0dd6470a":"It remembers what the job is","product-kera.38102f3002":"Keep the purpose","product-kera.4d315edeea":"with every step","product-kera.c8aa28abbc":"Imagine asking someone to bake a cake, then passing the instruction through several people. By the time it reaches the kitchen, the final person has a list of movements but no longer knows they are meant to make a cake. They can follow the list, but they cannot make the same sensible choices as someone who still understands the job.","product-kera.183fb81a80":"Kera keeps the purpose attached. A calculation remains identifiable, and the relationship between its steps stays visible. The computer receives a plan for the complete job, so it can make choices that fit the work instead of following tiny instructions without context. It still knows what the whole task is meant to achieve.","product-kera.c3c7b209a9":"Purpose held","product-kera.d718de5182":"Linked steps","product-kera.d6cb91addc":"Whole plan","product-kera.9815c5a111":"From task to machine","product-kera.d1af98313f":"the purpose travels the whole way","product-kera.7bb0ddf922":"Task","product-kera.801094e71f":"What you actually want done.","product-kera.1926edbfd7":"The job kept as one clear picture.","product-kera.826819699d":"A version made for the machine.","product-kera.65bb1b78be":"Machine","product-kera.024d83cf95":"Work it can do well.","product-kera.e1eaebb5a3":"understanding the job","product-kera.e7b6550723":"allows a better route","product-kera.27dfe5b1f1":"Understanding the job allows a better route.","product-kera.c42f45c328":"That can make software much faster","product-kera.178989fa80":"Faster than the usual","product-kera.46faf89aa4":"optimised route","product-kera.a83e0f7b74":"Because Kera still understands the work, it can sometimes choose a much better way to perform it. In current internal tests, several basic calculations run several times faster than versions already prepared by a strong general purpose tool.","product-kera.010db4d216":"Some tested calculations have run more than ten times faster; others show smaller gains or remain near parity. Exact results depend on the machine, so one headline number would mislead. The usual route is no longer the final limit.","product-kera.72afec6994":"Faster cases","product-kera.10d4669792":"Wide gains","product-kera.cce6d8867e":"Tested limits","product-kera.966ea2ce2a":"How much faster","product-kera.1015ddc361":"honest, everyday comparisons","product-kera.9b3be86461":"Some maths steps","product-kera.9fd966430a":"Can run more than ten times faster.","product-kera.cd36a295f3":"Some big calculations","product-kera.cebdb8bb9d":"Among the largest improvements.","product-kera.b81f607331":"Many common operations","product-kera.26c1cbbc64":"Run clearly faster on tested sizes.","product-kera.f9081cfa62":"A few cases","product-kera.f180693447":"Are currently similar in speed.","product-kera.3060dc5856":"speed often comes from doing less work","product-kera.aaecacf8e3":"not rushing every step","product-kera.0d00644efc":"Speed often comes from doing less work, not rushing every step.","product-kera.d75afe90b2":"Less work means less waiting","product-kera.7dd522ab2a":"Remove what","product-kera.40fd6053c6":"was never needed","product-kera.e0a13c0749":"A faster programme does not always come from making each instruction slightly quicker. Sometimes the best improvement is removing work the computer never needed to do.","product-kera.3a2053bd07":"Kera joins related steps, avoids temporary results, and keeps information close to the processor. Removing needless work reduces delays, memory use, and data movement, and the saving grows on the machines where movement costs most.","product-kera.ec68ad75f2":"Fewer intermediates","product-kera.4d3b4aeb03":"Less movement","product-kera.57ee8b775a":"Lower energy","product-kera.c084b75397":"Fewer journeys through memory","product-kera.7613add8a7":"seven rooms become two","product-kera.6ce7e76d31":"Seven rooms","product-kera.04cca0bd90":"The usual route carries parcels through many.","product-kera.7b2b1c351a":"Two rooms","product-kera.7363a6a4cc":"Kera keeps them close together.","product-kera.108017c058":"Fewer trips","product-kera.f56f2c5408":"Temporary results are avoided.","product-kera.19ede6bdb0":"Less waiting","product-kera.d3c31816fa":"Fewer delays and less memory used.","product-kera.466f6535b8":"the best route","product-kera.01a0f5a116":"depends on the machine available","product-kera.dce3c876c3":"The best route depends on the machine available.","product-kera.cc9d052a9f":"The same work can fit different machines","product-kera.626a985048":"One job","product-kera.f4041ac8dc":"and a plan for each machine","product-kera.d390e3301b":"A laptop processor, a graphics processor, a browser, a specialised chip, and a large computing system do not work in the same way. Kera does not force them to run identical instructions.","product-kera.682242073e":"Kera keeps one description of the work and prepares a plan for the available machine. The plan changes, but the job does not. Dweve can support more hardware without rebuilding the product's foundations.","product-kera.dc0d0e012d":"One job","product-kera.5e6d42681a":"Per machine","product-kera.309a280a30":"Plan fitted","product-kera.ec2774e1d8":"One job, four machines","product-kera.f827184114":"the plan fits each one","product-kera.ed91cd89f3":"Laptop","product-kera.7a3d93292a":"A plan for an everyday processor.","product-kera.ca49ca4bb6":"cpu","product-kera.464d6ab7b0":"Graphics chip","product-kera.a6e248f3ec":"A plan shaped for a GPU.","product-kera.7786424bea":"gpu","product-kera.54a2cf5e63":"Browser","product-kera.5e2f5464c3":"A portable plan for the web.","product-kera.ca84d1343b":"web","product-kera.6f9c4dce2e":"Data centre","product-kera.d8c8e7e25b":"A plan spread across many machines.","product-kera.60020d1b19":"scale","product-kera.b433fc7d89":"changing machines","product-kera.7598fbdae4":"should not make the result change by accident","product-kera.7d08ee7b6e":"Changing machines should not make the result change accidentally.","product-kera.3f2cf7d0d9":"Steady when steadiness matters","product-kera.30f26e69fa":"Choose the behaviour","product-kera.f683d4d219":"strict or creative","product-kera.e5a01965b6":"Some software should be creative. Some should make controlled variations for testing. Some should give the same supported result every time. Kera lets the product choose the right contract before the work runs.","product-kera.132e2ba356":"A strict path controls execution where the operation and machine support it. A seeded path repeats variation; a creative path allows useful change. Moving the work need not alter its behaviour by accident.","product-kera.78d4498d96":"Chosen mode","product-kera.d06a21856e":"No drift","product-kera.0caa127bae":"Three ways to behave","product-kera.fd1c5fec09":"the product picks the contract","product-kera.4a3b161613":"The same supported result every time.","product-kera.0c69e7aaeb":"steady","product-kera.45705488b9":"Repeatable","product-kera.e88b89fadf":"The same variation on request.","product-kera.9ad3dc4c49":"seeded","product-kera.17d40b122c":"Different answers where that helps.","product-kera.3744dd219b":"the programme","product-kera.6b0aa272d5":"also keeps a record of what it really was","product-kera.b040f21755":"The programme also keeps a record of what it really was.","product-kera.47dc8675e6":"The work has an identity","product-kera.1854e60717":"Change the programme","product-kera.838d2c3e34":"and its identity changes","product-kera.de834097f3":"Kera keeps the work as a sealed record, which gives it its own identity. If the work changes, the identity changes. If it stays the same, the identity stays stable.","product-kera.1b8f8ccb4c":"Dweve records the computation and machine plan, then sees whether a version changed. You need not read it; the record replaces guesswork with evidence.","product-kera.5d916b38b9":"Identity","product-kera.fabf782851":"No swap","product-kera.03fd7786d5":"Checked","product-kera.5c47f67a22":"The sealed job card","product-kera.12a1c8cda8":"a fingerprint for the work","product-kera.5d2b90a4c4":"sealed","product-kera.6127aafac8":"the job card","product-kera.7b48136bc5":"The exact computation that ran","product-kera.6d0d5876e6":"print","product-kera.d1aada8a31":"a fingerprint","product-kera.9569a4fb58":"Derived from the work itself","product-kera.9ef793516f":"machine choice","product-kera.d3d9a43e6e":"Which plan was selected is recorded","product-kera.c2a6b03f19":"new","product-kera.7ab768e0a8":"on any change","product-kera.14a9c20048":"A changed step creates a new print","product-kera.ca4f41de0a":"a clear programme","product-kera.e1150c936f":"can also state what it may touch","product-kera.cd0c7bad46":"A clear programme can also state what it may touch.","product-kera.44b37ce7bf":"It knows what the programme may touch","product-kera.99d48f204d":"What may it touch","product-kera.5d7436ddf2":"is declared before use","product-kera.9b333524e6":"Software can read files, use the network, change stored information, or send work to another device. Kera makes those abilities explicit, so a setup can restrict which abilities are available.","product-kera.9afb9c4714":"A system meant to work without outside connections can reject network access. A hidden library cannot quietly add new access, so the software stays within the boundaries its operator selected.","product-kera.9a7e6247bd":"Access","product-kera.b73aa18729":"Operator","product-kera.d1307b0ff8":"Visible access","product-kera.cf4ba0ec70":"Permission keys","product-kera.f6a94ed778":"around the work","product-kera.6ce6c512ea":"Files","product-kera.5bd515d2fb":"Declared access, nothing hidden.","product-kera.61c1876e82":"Can be refused when offline is required.","product-kera.df485c8713":"Devices","product-kera.b739702025":"Sending work out is an explicit ability.","product-kera.5a5e50060f":"Stored information","product-kera.ff0de4c225":"Changes to saved data are declared.","product-kera.4d3e36c33d":"Dweve can enforce this","product-kera.aeb1679215":"because it owns the compiler route","product-kera.b3af266fc1":"Dweve can enforce this because it owns the route underneath.","product-kera.a9317cd2cb":"Dweve owns the route underneath","product-kera.5b6ffcbcf0":"Own the route","product-kera.b478cfeaf9":"beneath the product","product-kera.52f9ceea32":"Kera does not rely on an outside tool to turn its work into something the machine runs. Dweve built the whole route itself, from the way the work is described to the way it is planned, prepared, and run on the supported machines, and can therefore change any part of it directly.","product-kera.4f984301e9":"You do not interact with those parts. Their value is that Dweve can improve the route from programme to processor instead of waiting for another company. Hardware and operating systems remain external, but the central path belongs to Dweve.","product-kera.9137233a67":"Dweve-built","product-kera.935e7ff4d0":"Direct path","product-kera.200501a9e9":"External edge","product-kera.6e8b0bb182":"One accountable workshop","product-kera.52e7b924ba":"from graph to machine","product-kera.d558d64b01":"The way the work is written.","product-kera.6b5c355a51":"The clear picture of the job.","product-kera.341a20e237":"Compiler","product-kera.1a82e7a27c":"Kera prepares the machine plan.","product-kera.3e78a83bcd":"External hardware sits at the edge.","product-kera.899827e9d8":"Kera is deep infrastructure","product-kera.c3554ba1b9":"and is not included everywhere","product-kera.ae8b1ab067":"Kera is deep infrastructure and is not included everywhere.","product-kera.a39081f578":"The app looks simple","product-kera.5c8e5c3be2":"One simple screen","product-kera.05e39ece46":"One piece comes from one company, another piece from a second, and the part that prepares the work from a third.","product-kera.fe4f2af82a":"The processor path comes from another supplier again, and the cloud from another after that.","product-kera.648433f9b6":"Five suppliers, one screen","product-kera.450567c91f":"Model from one company","product-kera.7bfe518686":"Framework from another","product-kera.f91b7cec97":"Another piece from a third party","product-kera.30c3906a08":"Processor and cloud from others","product-kera.d2df0e8ac0":"You owned the screen. Nobody owned the whole route underneath it.","product-kera.c16d295b52":"Kera is not in every package","product-kera.7d455eab77":"Deep infrastructure","product-kera.7d5a041f16":"is not in every package","product-kera.3bcb3017f2":"Every Dweve product runs on Core, the complete AI machine, and Core has its own fast path. Kera is the deeper system underneath, included in selected strategic licence packages.","product-kera.7bb8eb97e5":"Most people never choose or set up Kera directly. They use the product above it. Where Kera is included, its origin and control matter, but the visible product stays the same to use.","product-kera.cd0ce82619":"Core foundation","product-kera.2b20417df0":"Selected Kera","product-kera.bd7d4ca8a2":"No setup","product-kera.4409a64d08":"Core, and Kera where licensed","product-kera.e1da14eca6":"two lanes underneath","product-kera.40c0ddadac":"runs every Dweve product","product-kera.32ad8b3b6d":"its own native execution","product-kera.e015d59764":"always present","product-kera.5ba4f5a71c":"what you use above it","product-kera.596455491d":"in every package","product-kera.1e077ac18d":"the deeper direct path","product-kera.82104d8748":"selected strategic packages","product-kera.8af37eefc2":"the graph and compiler system","product-kera.166e9d72ba":"chosen for the deployment","product-kera.ae13578208":"never configured by users","product-kera.50f778a85c":"where it is licensed","product-kera.9229ab733f":"where Kera is used","product-kera.53e96f04d6":"its origin and deployment control matter","product-kera.31b68c1c36":"Where Kera is used, where it is built and who controls it matter.","product-kera.6af74613cf":"Built in Europe","product-kera.12b7e713a3":"The route underneath","product-kera.e6e1cc1fa6":"is European too","product-kera.518d95433a":"Kera is designed and built in the Netherlands. Direct Kera operation is licensed for customer-controlled connected, private-site, or fully isolated environments according to the agreement and target requirements.","product-kera.7ab808263a":"Dweve controls more than the application: it owns the route that turns it into machine behaviour. Sovereignty still depends on the full setup, not geography alone, while you see the product above.","product-kera.6ecb662812":"Dutch-built","product-kera.147a7d669b":"Underlying control","product-kera.8ab9f88b10":"Full setup","product-kera.89fe04cefd":"Three deployment boundaries","product-kera.75a9fec445":"where the licence allows","product-kera.ea722c81af":"European","product-kera.48242bd9c1":"Hosted inside the EU.","product-kera.442dd009d6":"Organisation-controlled","product-kera.d47d0f6bcc":"On the customer's own systems.","product-kera.2f0d4f153f":"on-premises","product-kera.64a176e362":"Isolated","product-kera.95c28312fc":"No outside connections at all.","product-kera.53354e1327":"air-gapped","product-kera.93a4d08a95":"the user","product-kera.e03972b2d5":"still sees only the product above","product-kera.b33611fddd":"The user still sees only the product above.","product-kera.9e61d09ef0":"You never have to see it","product-kera.df967ed69e":"stays underneath","product-kera.48a96bef09":"In ordinary use there are no Kera controls to find. The product chooses how the work is kept together, the plan, the machine, and the behaviour it needs, and you receive faster and steadier results.","product-kera.a64138bd53":"The whole job stays intact, the machine receives work designed for it, and the result can arrive through fewer hidden layers with a clear record of what ran. Kera shortens that path while staying out of sight.","product-kera.e67b3c1b82":"No controls","product-kera.7ff387d7f7":"Product choice","product-kera.95f0f4c17a":"Hidden layer","product-kera.0c23ddb1a1":"A friendly surface, a cutaway","product-kera.598fc3a179":"the graph and plan below","product-kera.cda05ca6d8":"Surface","product-kera.f3477f2745":"The app you actually use.","product-kera.6bcfc93dba":"The clear job kept underneath.","product-kera.9fe2620fe3":"The version made for the machine.","product-kera.5faa59d4bc":"Result","product-kera.c48a98c3c5":"Faster, steadier, and recorded.","product-kera.0193e423dd":"you use the product","product-kera.282ff2f4ae":"Kera shortens the path underneath","product-kera.f226d62623":"You use the product","product-kera.b76eac5fb8":"The whole job stays intact, the machine receives work designed for it, and Dweve owns more of the route from programme to result. Kera stays out of sight. The result can arrive faster, with fewer hidden layers and a clearer record of what actually ran.","product-kera.c8fe7ed389":"See what runs underneath","product-kera.36a247b5b4":"What stays true underneath","product-kera.2a9079f503":"meaning","product-kera.300286f8a6":"the job stays whole","product-kera.710296c4f7":"The purpose stays attached to the work","product-kera.c1acd38549":"made for the machine","product-kera.afcce7478f":"A target-specific plan, not a generic one","product-kera.563f07347e":"a clear fingerprint","product-kera.b1542ce883":"The exact computation can be recorded","product-kera.9523ccbcc4":"limits","product-kera.296898b104":"declared abilities","product-kera.706159d26d":"What the programme may touch is explicit","product-kera.c69102ccdd":"Two routes","product-kera.2172b0b889":"The short route","product-kera.ddaf6b0d00":"keeps the meaning","product-kera.30d1fd8ef0":"Most stacks translate a model several times before it runs, and every translation loses intent. Kera compiles the graph you wrote straight to the machine, so the thing that runs is the thing you meant, and the knowledge your team built stays attached to it.","product-kera.090db241c8":"no translation chain","product-kera.3fcc91b84e":"what runs is what you meant","product-kera.558ef7275b":"The terminal","product-kera.8e3e8a1a4c":"One command","product-kera.33bd08fe49":"from graph to machine","product-kera.e541d3e745":"One command takes the typed, content-addressed graph and emits target-specific native execution. The trace names the plan it chose, the target it compiled for, and the artefact it produced, so the whole path from source to silicon stays inspectable.","product-kera.73e18e855f":"graph in, native out","product-kera.324fe32f78":"the path stays inspectable","product-kera.a8923ad572":"Fewer steps","product-kera.1c46cf6f18":"and the same answer sooner","product-kera.a1e0753208":"Your computer does the work in far fewer steps, so answers arrive sooner and nothing of your question gets lost along the way. You never see this layer, and that is the point: it simply makes everything above it quicker and steadier.","product-kera.1e7960b1e5":"fewer steps","product-kera.abb1b81713":"steadier answers","product-kera.75246b5a6d":"Generic route","product-kera.23a1a69ce9":"Meaning is lowered away stage by stage until only generic code is left.","product-kera.3e1543b1c9":"Direct route","product-kera.d0743aea0b":"The typed graph stays identifiable from the source through to emitted code.","product-kera.59bd1ff6f9":"What it costs","product-kera.14464bc3be":"Lost facts return as extra instructions, movement, and runtime layers.","product-kera.791236e2aa":"What it keeps","product-kera.f3efaf1459":"Retained meaning becomes a plan shaped for the machine in front of it.","product-kera.6666416dbe":"generic against direct","product-kera.8f31a3f15a":"Compile path","product-kera.1593a101ec":"graph to machine","product-kera.7fec3a0a45":"Types and effects verified.","product-kera.d397eeddd8":"Content-addressed graph built.","product-kera.585204eac4":"Target plan selected.","product-kera.f882e9957c":"Native object, no LLVM centre.","product-kera.000000000d":"Instead of asking separate tools to rediscover the same task, Kera keeps the operation, shapes, ownership, and target choices together. That gives engineers one path to inspect when performance, behaviour, or accountability must be checked.","product-kera.000000000e":"The visible commands are stages of one inspected route, not hand-offs to unrelated compiler layers. Every stage preserves graph identity, target choice, and the evidence needed to reproduce the execution, review the selected plan, or trace the emitted artefact.","product-kera.000000000f":"Kera keeps the complete job together while preparing work for the machine underneath. The product gets a shorter route to an answer, while you do not have to understand, choose, or operate any of the machinery that makes that route possible.","product-kera.0000000101":"Kera keeps operation identity, type, effects, ownership, and movement attached from graph to target. The route can therefore be planned and reviewed as one accountable computation before machine code exists. Nothing has to be rediscovered downstream, because nothing was discarded upstream, and the typed graph stays identifiable from the source through to the emitted code.","product-kera.0000000102":"A general-purpose compiler gains breadth by accepting lowered, generic code. Once specialised facts have disappeared, later stages cannot use them to choose a better algorithm, layout, or movement plan. The matrix multiplication has become anonymous loops, the expected shapes are gone, the packing intent is gone, and the relationship between neighbouring operations has been cut.","product-kera.0000000103":"A Kera node carries the operation and the contracts that make it specific. Later compiler decisions work from declared meaning instead of trying to recover it from a pattern of instructions, which is why the operation can still be named when the plan is reviewed.","product-kera.0000000104":"The planner sees the complete graph before target code is fixed. It can decide placement, fusion, movement, ordering, and recovery together instead of repairing each concern in isolation. It reads the typed graph and its contracts, assigns operations to targets and regions, merges what is compatible, and plans or eliminates the movement between them.","product-kera.0000000105":"The headline results compare named operations and shapes with an already optimised LLVM path. They show where retained graph meaning changed the tested result, not that one compiler wins every workload.","product-kera.0000000106":"The wider matrix includes unrelated numerical, activation, vector, and bitwise work, as well as parity. That breadth helps separate an architectural advantage from one favourable kernel, and the neutral cases stay in the report rather than being dropped from it.","product-kera.0000000107":"Ownership makes every legal move between host, device, remote, and persistent memory visible to the planner. Kera can remove a transfer, retain a value, or reject an illegal alias before movement becomes runtime overhead.","product-kera.0000000108":"File, network, mutation, device, and persistent-state effects remain explicit graph facts. Teams can review, gate, and order those boundaries before execution instead of discovering them in a dependency at runtime.","product-kera.0000000109":"The content-addressed graph gives the computation a durable structural identity. Approval, deployment, caching, replay, and later investigation can all refer to the same identified asset.","product-kera.0000000110":"One graph can produce different target plans without becoming several programmes. The emitted artefact changes with the machine, while the typed operations and declared dependencies retain one identity. Native CPU instructions, device plans, supported synthesis artefacts, portable sandbox execution, and distributed partitions are all plans over that same graph.","product-kera.0000000111":"Execution policy is chosen before Kera plans and emits the path. Strict work fixes the supported contract, while seeded or creative variation remains an explicit input rather than hidden arithmetic drift. Guarantees stay scoped to the operations, backends, and plans that were tested.","product-kera.0000000112":"Partitions, communication, collectives, checkpoints, and recovery belong to the execution plan. Scaling across nodes therefore changes how one graph runs without erasing which computation is being recovered. A failed node restores from recovery state tied to the graph, so it returns as the same programme rather than as an unidentified process.","product-kera.0000000113":"Kera owns the central path from semantic graph through planning, lowering, emit, and runtime dispatch. External assemblers, drivers, firmware, and hardware remain visible edges rather than unnamed parts of the product claim.","product-kera.0000000114":"Core defines the complete AI operation and model system. Kera is a separate execution foundation that selected Core workloads can use when graph-wide planning and direct target emission are required.","product-kera.0000000115":"Kera is proprietary infrastructure, so deployment and runtime rights are set by agreement. Target coverage, isolated operation, review access, source rights, and transfer rights stay explicit rather than implied.","product-kera.0000000116":"Computational control reaches below the location of a server. It includes who owns the language, graph format, planner, compiler, runtime, target road map, and the policies that govern execution. It also covers where a deployment is hosted, who holds the keys, which external boundaries are permitted, and who may act on the running system.","product-kera.0000000117":"Kera sits beneath the products that need direct computation, but it keeps its own product boundary. The layer above defines the work; Kera plans and emits the selected computational path. Core remains the complete AI machine above it, and the products that compose on Core are unaffected by which computational path was chosen underneath.","product-kera.0000000118":"The command line exposes one continuous route from checked graph to emitted artefact. Each stage names the graph, plan, target, and output needed to inspect or reproduce what happened.","product-kera.0000000119":"The .keg graph is the durable programme representation, not a temporary optimiser view. Planning, JIT compilation, target emit, distribution, and replay all derive from that same semantic object.","product-kera.0000000120":"Every node identity is derived from represented content rather than filename or graph position. A change rekeys only affected ancestry, while unchanged subgraphs keep their identity for comparison, caching, and approval. An unchanged subgraph therefore does not have to be recompiled, and a changed one cannot present itself as the artefact that was reviewed.","product-kera.0000000121":"Numerical type, shape, layout, memory space, region, effects, and capability remain available during planning. These facts constrain legal execution and guide target choices at the same time, so the planner never has to infer them from an instruction pattern. Lowering begins with shape and layout still known rather than reconstructed.","product-kera.0000000122":"Pure calculation and external action occupy different graph categories. The verifier can refuse an undeclared capability, and the planner cannot silently reorder an effect as though it were pure.","product-kera.0000000123":"Ownership follows a value across host, pinned, device, unified, remote, and persistent memory. The same rules that prevent illegal aliases also tell the planner where movement can be removed or retained, which is why safety analysis and movement planning are one pass rather than two.","product-kera.0000000124":"Planning begins while the complete graph and its contracts are still visible. Order, placement, fusion, memory, synchronisation, collectives, and recovery can therefore be decided as one system rather than as a sequence of local repairs made after the information they needed has gone. The plan is fixed before a single instruction is chosen.","product-kera.0000000125":"Fusion can prevent intermediate values, launches, transfers, and synchronisation points from existing at all. Kera applies it where graph semantics permit, rather than making every region larger by default, because a fused region that breaks a declared contract is not an optimisation.","product-kera.0000000126":"Kera owns graph lowering, instruction selection, register allocation, scheduling, SIMD selection, target emit, JIT, and dispatch. The compiler stays semantic-aware without pretending that assemblers, drivers, firmware, or hardware disappear. Those remain visible edges of the system, named rather than folded into the claim. The path still contains transformations, but they stay inside one chain with one owner, so a change to instruction selection and a change to the planner are made by the same team against the same graph.","product-kera.0000000127":"Every measured comparison is tied to an operation, shape range, hardware profile, and toolchain setup. The reproducibility package travels with the claim so a strong result remains inspectable rather than universalised. A figure without its harness, flags, and machine is not a result anyone can check, and a result on one shape range is not a claim about every shape range. The harness is published beside the number so the comparison can be run again.","product-kera.0000000128":"The broader matrix keeps gains, parity, and pending coverage in the same view. That makes it possible to judge how widely the architecture travels without hiding neutral cases behind the headline, and a pending row is stated as pending rather than left out.","product-kera.0000000129":"Different operations improve for different reasons, including fusion, vectorisation, packing, movement, and target-specific maths. The benchmark must identify the observed cause instead of crediting one universal trick, because a cause that cannot be named cannot be relied on for the next operation.","product-kera.0000000130":"Kera emits for the capability profile of the processor or device that will run the work. CPU plans can select supported x86-64, ARM64, or RISC-V paths instead of stopping at a generic target label.","product-kera.0000000131":"Register allocation, live-range shaping, and scheduling still know which operation they are serving. Backend decisions can therefore preserve the graph plan instead of optimising an anonymous instruction stream alone, which is where a generic chain loses the fusion and movement decisions made earlier.","product-kera.0000000132":"Runtime dispatch selects a supported path for the actual machine, policy, and workload shape. The execution record names that path, so a hidden fallback cannot silently become the result under review. Where a machine cannot serve the requested plan, the substitution is stated rather than absorbed, and the recorded path is the one a later comparison is measured against. Dispatch accounts for instruction-set support, vector width, devices, policy, and graph shape together.","product-kera.0000000133":"One typed graph can emit native CPU code, PTX, AMDGCN, SPIR-V, Metal, WebAssembly, FPGA artefacts, or a distributed plan where supported. Coverage is declared per graph feature and target rather than assumed from the target name, so an unsupported combination is stated instead of silently degraded.","product-kera.0000000134":"Pure deterministic execution is planned into supported operation, numerical, target, and plan combinations. The same complete state produces bit-identical output without using a seed to disguise uncontrolled arithmetic variation.","product-kera.0000000135":"Partitioning, communication, collectives, checkpoints, and recovery remain attached to the graph plan. Kera defines the semantic distributed computation, while Mesh owns authorised placement and infrastructure coordination.","product-kera.0000000136":"Check, build, inspect, plan, emit, run, and verify all address the same .keg graph. The tools expose the semantic facts the compiler uses instead of presenting a separate debugging model.","product-kera.0000000137":"Core owns algorithms, models, training, inference, numerical families, and serving. Kera owns the graph, compiler, runtime, and target path that selected Core operations can use as a separate foundation. The boundary is deliberate: the layer above decides what the work means, the layer below decides how the machine performs it, and neither absorbs the other. Without Kera, Core runs its own native path, and selected packages add the graph route underneath it.","product-kera.0000000138":"Kera is proprietary even when its architecture can be described publicly. Runtime use, target coverage, source review, source access, and technology-transfer rights remain separate commercial terms. Describing how a system works is not the same as granting the right to run it, and neither is the same as granting the right to read it. Each of those is agreed in its own clause, and the companion crates around the system keep their own open licence regardless of what the core agreement says.","product-kera.0000000139":"Kera keeps the whole job together while the product prepares it for the machine underneath. You see the product outcome, not another layer of controls or technical choices. The same description can be planned for a laptop processor, a graphics processor or a browser without the job itself changing, and the plan that was used stays in the record, so a later reader can still see what actually ran.","product-kera.0000000140":"The purpose of the job stays attached to its steps instead of fading into disconnected movements. That gives the system enough context to make choices for the task as a whole.","product-kera.0000000141":"Kera is measured against an already optimised route, and the result depends on the named work. Some tested cases improve sharply, others improve modestly, and parity remains part of the evidence.","product-kera.0000000142":"A shorter route can come from removing temporary results, transfers, and repeated passes before they happen. The machine finishes sooner because there is less work to perform, not only because each step runs faster. Joining related steps also keeps information close to the processor, so fewer temporary results have to be written out and read back, and less movement means less waiting and lower energy use on the same hardware.","product-kera.0000000143":"The same described job can receive a plan suited to each supported machine. The machine form changes, but the identity and promise of the work do not quietly change with it. Because the description is kept rather than rebuilt for each machine, support for new hardware can be added without disturbing the product above it, and a result that arrives from a different machine is still a result for the same job.","product-kera.0000000144":"The product chooses the required behaviour before the work runs. Supported strict work is repeatable without a seed, while randomness remains available when the job deliberately asks for it.","product-kera.0000000145":"The work receives an identity derived from what it contains. If the programme changes, that identity changes too, making a silent swap visible in the record. An unchanged programme keeps the same identity, and a changed one cannot quietly keep the old one. That identity sits beside the machine plan that was chosen, which is what lets a later check confirm that the version you were told about is the version that ran.","product-kera.0000000146":"Files, networks, devices, stored information, and other external abilities must be declared. The operator can see and limit what a programme may touch before it begins.","product-kera.0000000147":"Dweve owns the central route that turns the graph into supported machine execution. Hardware, drivers, firmware, and operating systems still sit at the edge and remain visible dependencies.","product-kera.0000000148":"Kera appears only in products and licence packages that need its deeper execution path. The product above it stays straightforward to use, with no compiler setup handed to the customer. Where it is included, that deeper path is licensed rather than open, because an organisation buying it needs a party accountable for it.","product-kera.0000000149":"Dweve builds the compiler and execution route in the Netherlands. That extends European control below the application while keeping hardware, drivers, supply chain, and operator choices visible at the edge.","product-kera.0000000150":"Kera stays beneath everyday use while the product chooses the machine plan and execution behaviour. The technical layer remains inspectable for the people responsible for it without becoming another interface for everyone else. Nothing about the machine, the plan or the behaviour is handed to you as a setting to choose. The people responsible for a deployment can still open the record and read the graph, the plan and the machine that ran it.","product-kera.0000000201":"a strong baseline","product-kera.0000000202":"Current test","product-kera.0000000203":"The stated target vector path was enabled.","product-kera.0000000204":"The target CPU configuration was applied.","product-kera.0000000205":"The available vendor maths library was linked.","product-kera.0000000206":"The profile-guided variant was included in the check.","product-kera.0000000207":"Verified","product-kera.0000000208":"Why it matters","product-kera.0000000209":"Results remain specific to the tested operation, shape, hardware, and harness.","product-kera.0000000210":"all the way to emit","product-kera.0000000211":"What reaches emit","product-kera.0000000212":"Semantic input","product-kera.0000000213":"Generic path","product-kera.0000000214":"Kera path","product-kera.0000000215":"The emit stage receives lowered code rather than the original operation.","product-kera.0000000216":"The local view no longer contains the graph relationship.","product-kera.0000000217":"Typed operation retained","product-kera.0000000218":"The operation, shape, and effects remain available to the planner and emitter.","product-kera.0000000219":"Ownership and movement","product-kera.0000000220":"The graph records the information needed to plan legal movement.","product-kera.0000000221":"Lost","product-kera.0000000222":"Retained","product-kera.0000000223":"The distinction is the information available to the emit path, not a claim that generic compilation is slow.","product-kera.0000000224":"Fragmented","product-kera.0000000225":"Separate owner","product-kera.0000000226":"Each layer can be supplied and changed independently.","product-kera.0000000227":"No shared route","product-kera.0000000228":"The screen can be owned while the full execution route has no single owner.","product-kera.0000000229":"above a fragmented route","product-kera.0000000300":"Chapter checkpoint","product-kera.0000000301":"PATH HELD","product-kera.0000000302":"Held","product-kera.0000000303":"What carries forward","product-kera.0000000304":"One graph contract","product-kera.0000000305":"The next chapter starts from the same identified computation.","product-kera.0000000310":"Meaning stays attached","product-kera.0000000311":"from graph to plan","product-kera.0000000312":"A typed node retains the operation, shape, effects, ownership, and numerical contract that make the work specific.","product-kera.0000000313":"The planner receives that semantic object intact, so later choices begin with declared meaning rather than recovered patterns.","product-kera.0000000314":"Movement is evidence","product-kera.0000000315":"before execution begins","product-kera.0000000316":"Declared ownership makes transfers and memory placement part of the plan instead of a cost hidden between tools.","product-kera.0000000317":"Explicit effects and graph identity turn that plan into something a team can review before running and trace afterwards.","product-kera.0000000318":"One graph, many targets","product-kera.0000000319":"without losing identity","product-kera.0000000320":"Target plans may change the emitted machine form, but they continue to name the same typed computational asset.","product-kera.0000000321":"Deterministic policy and distributed recovery stay attached to the plan, so scale does not create an unidentified programme.","product-kera.0000000322":"Ownership reaches","product-kera.0000000323":"from code to contract","product-kera.0000000324":"One owned compiler chain creates a clear technical boundary between Kera, Core, and the systems that remain at the edge.","product-kera.0000000325":"The commercial agreement carries that boundary into deployment rights, target scope, review access, and accountability.","product-kera.0000000326":"The graph stays durable","product-kera.0000000327":"change stays local","product-kera.0000000328":"The command path, planner, emitter, and replay tools all address the same content-addressed .keg programme.","product-kera.0000000329":"When one node changes, affected ancestry rekeys while untouched subgraphs retain the identity used by caches and approvals.","product-kera.0000000330":"Facts stay enforceable","product-kera.0000000331":"through every boundary","product-kera.0000000332":"Types keep shapes, layouts, memory spaces, and capabilities available when the planner needs to make a legal choice.","product-kera.0000000333":"Effects and ownership turn those facts into gates over external action, aliasing, movement, and placement.","product-kera.0000000334":"Plan the whole graph","product-kera.0000000335":"then remove and emit","product-kera.0000000336":"Whole-graph planning decides which regions belong together before local code generation fixes the execution shape.","product-kera.0000000337":"Fusion can delete materialisation and movement, after which Kera emits the remaining work through its owned compiler path.","product-kera.0000000338":"Target code stays exact","product-kera.0000000339":"down to register choice","product-kera.0000000340":"The target capability profile guides instruction selection instead of leaving the final machine path implicit.","product-kera.0000000341":"Register allocation and scheduling still have the operation context needed to carry the selected plan into emitted code.","product-kera.0000000342":"Name the selected path","product-kera.0000000343":"plan determinism with it","product-kera.0000000344":"Runtime dispatch records the supported target artefact, machine profile, policy, and workload shape that actually ran.","product-kera.0000000345":"Deterministic obligations are fixed in that plan before emit, not added afterwards as a seed or best-effort replay mode.","product-kera.0000000346":"One graph in every tool","product-kera.0000000347":"one contract at the edge","product-kera.0000000348":"Distributed planning and developer tooling expose the same graph identity, partitions, effects, and target facts.","product-kera.0000000349":"Product boundaries remain visible too: Core owns AI work, Kera owns Direct Computation, and infrastructure stays at the edge.","product-kera.0000000350":"Keep the job together","product-kera.0000000351":"the route gets shorter","product-kera.0000000352":"When the purpose stays attached to the steps, the system can prepare the whole job instead of treating each movement alone.","product-kera.0000000353":"That can remove work from the route and improve named cases without pretending that every task changes by the same amount.","product-kera.0000000354":"One job changes shape","product-kera.0000000355":"not its promise","product-kera.0000000356":"Each supported machine can receive a plan fitted to its capabilities while the described job keeps one identity.","product-kera.0000000357":"The product also chooses whether the result must be strictly repeatable or whether the task deliberately asks for variation.","product-kera.0000000358":"Meaning survives","product-kera.0000000359":"all the way to proof","product-kera.0000000360":"The final evidence joins the semantic graph to the target-specific plan and the build that ran.","product-kera.0000000361":"That gives procurement and engineering one chain to inspect instead of a performance story they must simply trust.","product-kera.0000000362":"Claims end","product-kera.0000000363":"in inspectable evidence","product-kera.0000000364":"The .keg identity, planner diff, emitted path, and replay test show which facts produced a build.","product-kera.0000000365":"Publish the result with its harness and the claim can be checked on the hardware that matters.","product-kera.0000000366":"The job stays whole","product-kera.0000000367":"on the shorter route","product-kera.0000000368":"The same task reaches a machine-specific plan without surrendering its identity or declared limits.","product-kera.0000000369":"You see the product; Kera keeps the work recognisable and accountable underneath.","product-kera.0000000370":"Related products","product-kera.0000000371":"See Dweve Core","product-kera.0000000372":"See Dweve Mesh","product-kera.58e16f23ea":"not one generic path","product-kera.968afd8562":"See the whole graph","product-kera.bd5302381a":"OWNED","product-kera.a02b4a56b0":"Graph programme","product-kera.b793513413":"A durable .keg graph, not a temporary view","product-kera.b90a8b39c5":"Owned lowering for x86-64, ARM64, RISC-V","product-kera.2dfbd50843":"Strict, seeded, or creative, chosen first","product-kera.b6903f7948":"The model changes underneath, the work does not.","product-kera.c8d6ec8b39":"you actually ship","product-kera.094e27cf92":"Read the emit path","product-kera.1ada512d64":"The chain","product-kera.dd19f98875":"Front","product-kera.ce325a12a3":"Typed graph IR with declared effects","product-kera.ec0846c2cb":"Place, fuse, move, and order before emit","product-kera.b52b36b726":"Back","product-kera.f67e87773e":"Owned code generation per target ISA","product-kera.95797c04c5":"Publish both harnesses and the raw results.","product-kera.f75b896620":"the path underneath gets shorter","product-kera.5cf8744d5c":"Underneath","product-kera.1ba3456507":"HIDDEN","product-kera.93ead3a4bb":"Fewer steps","product-kera.a2c77eb02f":"The job keeps its purpose the whole way","product-kera.254c34d067":"Per machine","product-kera.fd440af5b2":"One job, a plan for each machine","product-kera.171ca0385a":"Behaviour","product-kera.2a7a49c2a6":"Strict or creative, chosen before the run","product-kera.8da2257e6a":"No controls to find, and nothing to set up.","product-kera.0367ceda55":"Dweve Kera, Direct Computation","section_st_a2_split-spec-sheet.7c9a7c0610":"Detail","section_st_a6_split-scenario-triad.f75fd3a884":"No runtime deps","section_st_a6_split-scenario-triad.143ac4ef35":"Single binary","section_st_a6_split-scenario-triad.c61f134d87":"Three surfaces","section_st_a6_split-scenario-triad.215475056e":"WHERE IT RUNS","section_st_a6_split-scenario-triad.a794a586f0":"Sealed-room ready","section_st_a6_split-scenario-triad.42d52c32ea":"Local model","section_st_a6_split-scenario-triad.fe6168e59f":"No network","section_st_a6_split-scenario-triad.7d93f83c3e":"Volume-mounted code","section_st_a6_split-scenario-triad.bee0cb05f8":"Kubernetes","section_st_a6_split-scenario-triad.9f1141549f":"Docker","section_st_a6_split-scenario-triad.5315129cfe":"macOS, Linux, Windows","section_st_a6_split-scenario-triad.a89193f674":"No install","section_st_a6_split-scenario-triad.f600b9e709":"One binary","section_st_a7_split-connector-grid.4e6822a6d4":"Hot-reload","section_st_a7_split-connector-grid.19e35f0609":"Set in TOML","section_st_a7_split-connector-grid.d9de50b343":"Caller-driven inventory","section_st_a7_split-connector-grid.8be1bb51b7":"CONNECTORS","section_st_a8_split-scaling-profile.7e0861e04c":"Tunable in TOML","section_st_a8_split-scaling-profile.56d6732417":"Per-project ceiling","section_st_a8_split-scaling-profile.27a454915b":"Active dots reflect concurrent agents per tier.","section_st_a8_split-scaling-profile.0ea215ea0d":"BACKGROUND","section_st_a8_split-scaling-profile.9fc6fb7e03":"TEAMS","section_st_a8_split-scaling-profile.018d2cd1a5":"PARALLEL","section_st_a8_split-scaling-profile.16623c5d4a":"CHAINS","section_st_a8_split-scaling-profile.0fb79c96ed":"Solo → Team → Network","section_st_a8_split-scaling-profile.068f6b3ecc":"TEAM SCALE","section_st_a8_split-scaling-profile.53ebc572b4":"Network","section_st_a8_split-scaling-profile.218887269a":"Team","section_st_a8_split-scaling-profile.9fc93acaa4":"Solo","section_st_a9_split-time-lost-donut.7c9a7c0610":"Detail","section_st_b5_request-lifecycle.47e364232a":"audit #4521","section_st_b5_request-lifecycle.4d3535f846":"patch · session.rs","section_st_b5_request-lifecycle.6c2519cd62":"Tool execution","section_st_b5_request-lifecycle.f6d1c823ab":"session #128 · 14:02","section_st_b5_request-lifecycle.636de0d0c3":"> \"fix this bug\"","section_st_b5_request-lifecycle.0208131a7d":"User request","section_st_b7_audit-chain.9239506454":"0d4e · 8f2c · 51a9 · 73be","section_st_b7_audit-chain.a383df4adb":"a015 · 7c93 · 3e6f · d28b","section_st_b7_audit-chain.efd3faebc5":"9e1b · 22a7 · 8d50 · 6b3c","section_st_b7_audit-chain.4df252b458":"4f2a · b7d1 · 1c83 · e0a4","section_st_b8_defense-stack.eee0f04cba":"YOUR CODEBASE","section_st_b8_defense-stack.89b6e2a784":"DEFENCE IN DEPTH","section_st_c2_dual-loop-flow.9d29573ea6":"tool / step","section_st_c2_dual-loop-flow.08ab1ac55a":"plan / replan","section_st_c5_integration-spoke.55d0677ac3":"All connectors funnel through the same audit + permission layer.","section_st_c5_integration-spoke.c29eb7e425":"Local agent","section_st_c5_integration-spoke.14afd82a7f":"AURA","section_st_c5_integration-spoke.ed0afbab5a":"GitLab CI","section_st_c5_integration-spoke.39540900bb":"GitHub Actions","section_st_c5_integration-spoke.a2feefe9af":"Jenkins","section_st_c5_integration-spoke.ab4115a7b2":"External tools","section_st_c5_integration-spoke.70c123381f":"JSON-RPC 2.0","section_st_c5_integration-spoke.dc99d54d99":"Local","section_st_c5_integration-spoke.6466df1d3d":"Mistral","section_st_c5_integration-spoke.a19ee5a9fd":"OpenAI","section_st_c5_integration-spoke.b780a23b53":"Anthropic","section_st_f1_cta-dark.90e40d5043":"Get started","toc-rail.f5cbdf6bfb":"Contents"}