Kera | Deterministic Systems Language and Compiler

Choose the audience that matches your question

The page contains three selectable readings of the same subject.

Coding agent and operator assistance. Demo metrics are illustrative.

Terminal, search, lint, test, git, and more.

Remembers your codebase and team context.

Specialised agents collaborate across concerns.

Review diffs, request changes, final sign-off.

Replay any session bit-for-bit when something needs review.

Autonomous agents that write code and keep receipts

to handle network timeouts, 5xx responses, and idempotent-safe conditions. Pure helper, fully unit-tested.

one changed node rekeys only its affected ancestry

modest single-digit gains on some bitwise paths

clear medium gains on additions and activations

strong large gains on several matrix and vector paths

level parity cells stay in view, not deleted

what becomes possible when meaning survives

a matrix multiplication enters with ten known facts

each conventional lowering stage drops several cards

Core Native runs on Rust-native execution

Core on Kera reveals graph and compiler layers

the Native lane is not made to look broken

the graph is partitioned across four nodes

one node fails and restores from checkpoint

an undeclared network edge is blocked during planning

each boundary carries explicit capability and operator controls

Kera capabilities through Fabric on the Dweve managed service; direct Kera operation requires a licence

The same semantic graph is emitted inside whichever boundary you choose.

three intermediates removed, two regions fused, one value kept on device

a savings rail counts launches, allocations, transfers, and bytes removed

each tower carries a publish-with-harness seal, no invented hardware

operation labels fall away at each IR stage

labels survive to target-specific machine code

open companion projects sit outside the commercial boundary

the conventional lane copies across six memory spaces

the Kera one-owner graph-to-machine chain

the external driver boundary stays at the edge

properties propagate only through the lane actually licensed

included where the agreement requires it

cognition, organisations, knowledge, compute

AI operations, training, inference, serving

every plan links back to the same graph hash

nothing about the task is lost on the way

the same job card is fitted with a different plan for each

sovereignty depends on the full setup, not geography alone

the user sees the agreed Fabric capability above

Fabric on the public Mesh within its contracted processing boundary

some steps run much faster than the usual route

a few cases are currently similar in speed

one task takes a long zig-zag through translation boxes

the Kera route stays one clear plan from job to machine

software should not take the long way around

the job card carries its own fingerprint

a changed step creates a new fingerprint

which machine plan was selected is recorded

parcels move through seven rooms the usual way

information stays close to where it is needed

an offline system can refuse network access

external hardware and operating systems sit at the edge

a recipe passed through people loses its purpose

in Kera the purpose stays attached to the steps

the kitchen can still make sensible choices

a strict task gives the same pattern each time

a creative task allows different patterns

the app surface stays friendly and simple

a cutaway reveals the Kera plan and the machine work below

there are no Kera controls in ordinary use

inspect which facts produced the difference

unknown package cells stay outlined until packaging is final

a Core operation node enters the Kera plan

where Kera is absent, Core stays Rust-native

the LLVM lane is simply absent, not crossed out theatrically

No LLVM IR stage sits in the centre. Every step keeps graph and operation semantics available.

the selected path is written to the execution record

effectful nodes pass through capability gates

an undeclared capability is rejected by the verifier

separate regions with materialised intermediates

the graph is retained across every later stage

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

results differ by hardware, published with the harness

new hashes propagate through the affected ancestry only

the token crosses host, device, and remote spaces

the planner keeps the value where it belongs

the planner has the entire graph in view

generic live ranges without operation context

unrolling, vector width, and spills chosen from the operation

each target carries its own emitted artefact

check, build, inspect, plan, run, verify

the graph inspector shows types and effects

the common cause is retained semantic information

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.

Direct computation. The graph stays the programme.

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

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.

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.

One graph. Execution planned for the target.

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.

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.

The computation keeps its identity to the machine.

Native machine code via a custom JIT compiler

Dweve AI inference and simulation workloads

Programming language for consistent, fast computation

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.

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.

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.

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.

The matrix multiplication becomes anonymous loops.

Expected tensor and vector shapes disappear.

Accumulator and packing intent are gone.

The relationship between operations is cut.

the first advantage is not a faster instruction

it is remembering what the instructions are for

Kera keeps those facts attached to the operation.

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.

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.

A vector logarithm stays a vector logarithm

The declared fixed-point profile is retained

Retaining meaning matters only if Kera can turn it into a different plan.

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.

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.