A big model, resident in a heartbeat.
The slow part of running a large model is often not the compute — it is getting the model into memory and onto the accelerator. veizik’s hypercache restores a prepared, resident model instead of loading it cold, so the first response comes back in seconds, and on small models in milliseconds — on a datacenter GPU and on a single-board computer alike.
Cold, OS-warm, and hypercache.
Loading a model is three different costs depending on where it already is. veizik supports the original-checkpoint path it always has — and adds a restorable hypercache tier on top of it.
- Tier 1 — cold. The model is not in memory. The checkpoint is read from disk, the weights are prepared in veizik’s own number formats, and the result is uploaded to the accelerator. For a 122-billion-parameter model this is minutes.
- Tier 2 — OS-warm. The file is already in the operating system’s page cache (or on a RAM disk), so there is no disk read — but the engine still re-prepares and re-uploads. Tens of seconds.
- Tier 3 — hypercache. veizik restores a prepared, resident snapshot: the weights are already where the compute needs them and the context is already built. The first token comes back in seconds — on small models, in milliseconds.
A 122B model, answering in six seconds.
Qwen3.5-122B-A10B is a mixture-of-experts model carried in veizik’s mixed sub-byte formats (the experts at a grouped 4-bit precision, the dense path in bf16). A cold start on a single 24 GB card is minutes; from the OS page cache it is tens of seconds; from hypercache the first token returns in about six.
Measured on one RTX 3090 (WSL2). Cold load 230–311 s (checkpoint read, prepare and upload); OS-warm 30–46 s from a RAM disk; hypercache warm first token ~6 s. A development build; the figure is a record of the load path, not a release speed claim.
The same tier, from a datacenter card to a single-board computer.
The hypercache tier is not a GPU trick — it is the same idea on every target veizik runs on. On a phone and a Raspberry Pi it restores a resident arena on the CPU; on an NVIDIA GPU it restores the CUDA context, so the weights are never re-uploaded. Every figure below is a measurement on the stated device.
| Device | Model | Cold load | Hypercache | Gain |
|---|---|---|---|---|
| RTX 3090 | Qwen3.5-122B-A10B (MoE) | 230–311 s | ~6 s first token | 38× |
| RTX 3090 | gpt-oss-20b | cold load | 4.83 s restore | byte-identical |
| Galaxy Note10 Exynos 9825 | SmolLM2-135M | 10.6 s | 14 ms | ~750× |
| Galaxy S26 Exynos 2600 | MobileNet V1/V2 · Inception | cold load | ~0 ms resident | instant |
| Galaxy S26 Exynos 2600 | SDXS-512 | 4.30 s | 1.62 s | 2.7× |
| Jetson AGX Orin | FLUX.1-schnell 1024² | cold load | 8.3 s / image | warm |
| Raspberry Pi 5 Cortex-A76 | SDXS-512 | 28–31 s | 2.9 s warm | ~10× |
| Raspberry Pi 5 Cortex-A76 | GPT-2 124M | 35.7 s | 116 ms | ~308× |
| Raspberry Pi 5 Cortex-A76 | MobileNet V2 vision | 2.64 s | 20 ms | ~132× |
| Raspberry Pi 5 Cortex-A76 | Inception V3 vision | 17.6 s | 118 ms | ~149× |
| Raspberry Pi Zero 2 W Cortex-A53 · 512 MB | GPT-2 124M | 150.6 s | 20 ms | ~7530× |
| Raspberry Pi Zero 2 W Cortex-A53 · 512 MB | MobileNet V2 vision | 9.74 s | <1 ms | >9700× |
Where the model is read from sets the cold number. The RTX 3090 rig (a Threadripper Pro workstation) reads from an AMD RAIDXpert2 SSD array — a 16 TB and a 4 TB array, with a Seagate FireCuda SSD alongside; the Raspberry Pi 5 from a WD SN740 NVMe SSD on the Pi’s PCIe Gen 2 ×1 link; the phones from on-package UFS flash. Cold is bounded by that drive — hypercache takes the read out of the path entirely, which is why the warm figure stays low across storage this different.
Cold is a first load with nothing in memory; hypercache is a restore of a prepared resident snapshot. Phone and edge figures are on-device; GPU figures are development builds, shown as a record of the load path. Research devices and pre-release builds are included and labelled; they are not a release speed claim. The Raspberry Pi 5 and Pi Zero 2 W figures are measured at the boards’ default power and governor, and the warm restore is correctness-gated across model classes — both a language model (GPT-2) and a vision model (MobileNet V2) restore with output bit-identical to the cold load.
Original checkpoints, and a faster way.
- The original-weights path is still there. veizik reads the publisher’s own checkpoint directly — the method it has always used — so nothing about your weights changes. Hypercache is added on top; you keep both.
- It restores, it does not reload. On an NVIDIA GPU the resident context is brought back in place rather than re-uploaded across the bus; on a phone, a Jetson or a Pi the prepared arena is restored in memory. The restored state is verified — a warm restore of gpt-oss-20b is byte-identical to its cold load.
- The internals are not shown. In keeping with how veizik publishes, the measured load times are on this page; the snapshot format and the restore path are proprietary and are not. The security review covers that boundary.
The benchmarks page has the measurement method; the models page lists what runs on each device.