REAL SILICON · DESIGNED IN-HOUSE · VERIFIABLE

Not an app.
An inference engine
with its own hardware.

Most AI products are a thin wrapper around someone else's stack, running on someone else's silicon. SiloLM stands on the best open-source foundation there is — llama.cpp — and underneath it we build what almost nobody else does: our own accelerator, designed, verified and programmed in-house.

SEE THE ROADMAP ▸ SEE THE PROOF
SiloLM Accelerator engineering drawing — exploded view, parts list and dimensions
SL-ACC-001 — first-generation development platform. Real, physical hardware you can hold in your hand.
// WHAT WE'VE BUILT

Open where open is best.
Owned where owning matters.

01

A first-class llama.cpp backend

We didn't reinvent tokenizers, samplers or model formats. SiloLM is a native ggml backend inside a llama.cpp fork: the scheduler hands our accelerator the workload that dominates all LLM inference, and everything else stays on the CPU — exactly where it belongs.

02

Every ggml format, handled

Our runtime accepts every ggml weight format — Q4, Q5, Q8, K-quants, IQ, MXFP4 and more — handles broadcasting, permuted views and strided tensors, and falls back to CPU transparently when the accelerator isn't connected.

03

A parallel compute core

Designed in-house down to the lowest level of the hardware, and verified bit-for-bit against a mathematical reference model. The heaviest compute in inference runs on silicon that is entirely ours.

04

Memory & compression pipeline

A proprietary on-chip memory and compression pipeline keeps model data close to the arithmetic and makes every byte of bandwidth do real work. How it does that is the part we don't publish.

05

Wire protocol & host runtime

A wire protocol and host runtime map workloads of any shape onto the hardware and integrate seamlessly with the engine above — invisible to the models running on top.

06

Efficiency as the core metric

Joules per token drives every design decision, from how model data lives on the chip to a dataflow where every byte of bandwidth does real work.

V E R I F I E D O N H A R D W A R E

Correctness isn't our opinion.
It's a test suite.

The SiloLM backend passes llama.cpp's own backend conformance suite on the physical hardware — across every weight type, shape, broadcast and edge case. You can verify us with the tools you already trust.

1,133 / 1,133conformance tests passed
27,897operations in one validation session
1.8 GBof model data, zero errors
5×10⁻⁴NMSE vs. double-precision reference
⌁ THE HONEST LIMITATION The bottleneck is the wire, not the engine This first generation talks to the host over a USB-serial link that tops out at kilobytes per second. It was never meant to be fast — it was meant to prove the architecture: the compute, the data pipeline, the runtime, the integration. It did, completely.
⌁ THE ANSWER The wire is exactly what the next generation replaces The same proven architecture moves to a far more powerful hardware generation with the two things speed actually requires: a wider, faster core and memory where whole models stay resident.
// WHAT'S NEXT

The performance generation.

Thirty tokens per second is faster than people read — from a device drawing less power than a laptop charger, with the model living entirely in the accelerator's own memory. Load once, generate forever.

Current generation Next generation
Compute core first-generation core @ 27 MHz 16× wider, @ 200+ MHz
Model memory one weight tile at a time (on-chip) 1 GB DDR3 — whole models stay resident
Host link USB-serial, ~30 KB/s readout PCIe 3.0 ×4, ~3.5 GB/s (~10,000×)
Sustained compute ~0.1 GFLOPS 40–64 GFLOPS
Decode, 135M-class model minutes per token ~30 tokens/second
Energy per token link-dominated ~0.25 J projected

After that comes the road we designed for from day one: dedicated silicon. The core was architected from the start to make that jump — a first custom chip is within reach of a small company's budget, not a moonshot — and it buys another order of magnitude in energy per token.

// WHY THIS APPROACH WINS

An honest engine, real silicon,
a roadmap you can audit.

Open where open is best llama.cpp gives us every model, every format, every community improvement — and our backend passes its tests.
Owned where owning matters The compute, the memory hierarchy and the silicon roadmap are ours — not GPU-market conditions.
Private by physics Your model and your prompts live on a device on your desk. Nothing leaves it.
Efficiency as the core metric Joules per token drives every design decision, down to how model data lives on the chip.

T H E F U T U R E I S L O C A L

Open. Modular.
Your AI. Your hardware.

JOIN THE WAITLIST▸

Next-generation figures are engineering projections derived from the validated current-generation architecture; current-generation results are measured on hardware.