The Helix stack, racing NVIDIA's.
HIVE is a GPU inference engine built entirely on the Helix toolchain: the compiler emits the kernels, the driver runs them, and nothing else is in the stack — no CUDA toolkit, no cuBLAS, no cuDNN, no TensorRT, no PyTorch. Every published result is token-gated against an independent oracle, measured in interleaved rounds on one machine, and the losses are printed beside the wins.
An engine with a two-line stack.
Compiler → PTX → driver. That's the whole dependency graph, and every layer of it is the same auditable toolchain that rebuilds from 299 bytes.
Independent by construction
Every kernel HIVE runs was emitted by kovc, the Helix compiler. There is no NVIDIA toolkit on the machine, no vendor math library in the process, and the demo build proves this live: its receipt panel lists the shared libraries actually mapped into the running engine — the driver, and nothing else.
Verified the same way as everything else here
Results are token-gated: an independent reference implementation must agree with the engine's output, or the run is discarded rather than published. Identity batteries re-check this across prompts, and the same compiler-emitted PTX produces token-identical output across three GPU generations — sm_86, sm_89, sm_90 — with no per-architecture source.
Measured like an experiment, not a brochure
Same-round interleaved medians, both engines alternating on one machine, gate counts reported. Single-run numbers and non-interleaved comparisons are not used. Withdrawn results are removed, not footnoted.
Wins and losses, on the same page.
Dated, measured medians from the full engine. A table showing only the wins would misrepresent where the engine stands — so this one doesn't.
H100 SXM5 · Qwen3-1.7B · vs TensorRT-LLM 1.2.1 (W4A16-AWQ, CUDA graphs on)
| Batch | HIVE | TensorRT-LLM | Result | Label | Date |
|---|---|---|---|---|---|
| B = 1 | 594.8 tok/s | 494.6 tok/s | HIVE 1.20× | certified lane | 2026-07-30 |
| B = 4 | 1765.2 tok/s | 1562.6 tok/s | HIVE 1.13× | adjudication open | 2026-07-30 |
| B = 8 | 2891.7 tok/s | 2705.7 tok/s | HIVE 1.07× | adjudication open | 2026-07-30 |
| B = 16 | 3764.9 tok/s | 4555.1 tok/s | TensorRT-LLM 1.21× | — | 2026-07-30 |
| B = 32 | 4227.8 tok/s | 8312.5 tok/s | TensorRT-LLM 1.97× | — | 2026-07-30 |
| B = 64 | ≈4.7k tok/s | ≈14.7k tok/s | TensorRT-LLM 3.1× | — | 2026-08-02 |
| TTFT @512 | 17.5 ms | 6.23 ms | TensorRT-LLM 2.8× | — | 2026-07-30 |
On the labels: B=1 is the certified lane — its correctness adjudication is complete and clean. B=4 and B=8 come from a faster lane whose adjudication has one case still open, so they are reported with that stated rather than presented as settled.
The moving edge — reported as research, not yet as record
Measured 2026-08-02, same pod, token-identical output at every point: a tensor-core decode lane raised HIVE's B=64 to ≈7.3k tok/s (narrowing the gap to ≈2.0×), and a tensor-core prefill lane brought TTFT to 14.7 ms (≈2.4×). Both are pre-certification research lanes; they enter the table above only when their certification completes — and if it fails, they won't.
RTX 3070 Laptop · 8 GB · sm_86
| Rival | Axis | Result | Date |
|---|---|---|---|
| vLLM · Qwen3-4B · both engines int4 | Prefill @1024 | HIVE 1.49× | 2026-07-24 |
| vLLM · equal int4 | Decode | HIVE 1.3–1.8× | 2026-07-21 |
| vLLM · 8B capacity | Qwen3-8B int4 in 8 GB | HIVE runs it with full CUDA graphs; vLLM OOMs | 2026-07-21 |
| llama.cpp · Qwen3-8B | Prefill @1024 | HIVE 1.34× | 2026-07-20 |
| llama.cpp · Qwen3-8B | Decode | HIVE 1.25–1.26× | 2026-07-20 |
| the card itself | Decode vs measured roofline | ~80% of achieved memory bandwidth | 2026-07-20 |
Bit-width disclosure: the llama.cpp pairing is not equal bit-width (~4.2 bits/weight vs ~5.0–5.3), so part of that margin is the format, not the engine. The vLLM comparison is equal-bit-width and is the fairer read. Roofline percentages use the bandwidth measured on this card, never the datasheet peak.
HIVE Limited — the demo that measures itself.
A deliberately limited, source-available build. It answers one question at a time, and everything it shows you it measured on your machine while you watched — nothing is pre-recorded.
Side-by-side races in your browser
Type a question, press LAUNCH, and watch HIVE Limited and a rival engine you installed answer it together — one clock, greedy decoding both sides, load time excluded, and no winner claimed when no rival ran.
Proof of the two-line stack
A panel that lists the shared libraries actually mapped into the running engine. On HIVE Limited it shows the NVIDIA driver — and no CUDA toolkit, no cuBLAS, no inference library. Check it yourself, live.
An independent reference, on the spot
One command re-runs the engine against an independent implementation and checks token agreement — the same fail-closed discipline as the rest of this site, running on your hardware.
curl -fsSL https://raw.githubusercontent.com/Questeria/HIVE-Limited/main/install.sh | bash
irm https://raw.githubusercontent.com/Questeria/HIVE-Limited/main/install.ps1 | iex
Either installer checks your machine, fetches the ~4 GB model, and starts the arena. Every failure it can hit names its exact fix, and doctor.sh re-checks everything on demand. The engine is also callable from your own Python — construct it, hand it token ids, get tokens back — documented in the repository.
What the demo is not.
HIVE Limited is limited by omission — the fast paths are absent, not disabled — so the demo can never be mistaken for the ceiling.
- It is not HIVE. Batch-1 only, one quantization form, no optimized prefill. The batch and serving paths, the compiler toolchain and the kernel research record are not in the repository at all.
- Its weights are heavier than a 4-bit rival's. The demo ships the finer per-32 quantization: exactly 5.000 bits per weight. In a race it reads more bytes per token than a 4-bit rival — the comparison states this rather than hiding it.
- The record above is not reproducible in the demo. Those figures come from the full engine. Nothing in the demo can produce them, and the demo says so on its own pages too.
- Rivals are installed by you, not bundled. The arena races engines you install from their own projects, under their own licenses, with ordinary flags — and claims no winner when no rival answered.
See the full HIVE run.
The full engine is not public. For a live preview, licensing, or any question about the numbers on this page — including the losses — there is one inbox, and it belongs to the person who built the stack.