Runtime & Engine

Veizik is a local AI-video runtime built on a native inference engine. This page describes the engine internals and — just as importantly — draws a hard line between what the public v0.1.0 download does today, what is experimental, and what is not yet public. Every number here is internal: v0.1.0 is a Public Preview and there are no external reproductions yet.

1What v0.1.0 actually ships

We split every capability into three honest buckets. Nothing in the "not yet public" list is present in the download you can install today.

$ veizik doctor
  # standard-library hardware scan + model-family support tiers
  platform        : detected at runtime
  nvidia / cuda   : detected at runtime (report prints with or without a GPU)
  entitlement     : free (server-signed)

  model family        engine path            tier
  ----------------    -------------------    ---------------------
  LTX-Video           native engine        internally verified
  HunyuanVideo        native engine        internally verified
  Wan 2.1             native engine        internally verified
  Step-Video 30B      native engine        internally verified
  CogVideoX           native engine        internally verified
  FLUX.1-dev          native engine        internally verified
  (others)            universal fallback     experimental

2The engine

The engine is Veizik’s execution layer. Its job is to run large open diffusion-transformer (DiT) video and image models on a single consumer GPU with predictable memory behaviour. It keeps only the working set in VRAM so large models fit, runs the flagship families on Veizik’s own native engine paths, and routes everything else through a universal fallback path. The value proposition is execution quality and reliability on hardware you already own.

3Low-VRAM execution

A 30B-class video model does not fit weights-resident on a 24 GB card. The engine keeps only the working set of weights in VRAM and sources the rest from host memory as each step needs them. Because activations, not the full weight set, dominate the resident footprint, the peak stays well under the card’s capacity.

4Native engine

The flagship families run on Veizik’s own native engine paths rather than the stock PyTorch module graph. The kernel outputs are compared against the reference implementation at the block and engine level, matching to a relative L2 error on the order of 1e-6 to 1e-7 (numerically indistinguishable, not bit-identical).

5Quantization

The engine applies quantization only where it holds up numerically against the fp16 reference, and leaves it off where it does not — the decision is validated per path, not applied blanket. Memory savings are taken only when they do not cost quality.

6Numerical verification methodology

For each supported family we take the reference module's inputs, run both the reference and the native engine path, and compare outputs with a relative L2 error. To date, 6 model-family engine paths have been numerically checked at the block/engine level, each landing on the order of 1e-6 to 1e-7. The table lists the internal block-level figures; read them as "the native block reproduces the reference block", not as end-to-end output equality.

These are block/engine-level checks measured internally. They are not end-to-end generation verifications, and there are no external reproductions yet — v0.1.0 is a Public Preview.

7Benchmark methodology

Render time and throughput are profile-conditional — they depend on resolution, frame count, step count, and model. To avoid publishing numbers that cannot be reproduced under a fixed profile, we are holding them back for v0.1.0.

The only hardware measurement we publish today is peak VRAM. We will publish render-time and throughput figures once they are measured under a fixed, reproducible profile.

8Model adapters

Each supported family has an adapter that maps the reference model’s module graph onto the native engine — matching layer shapes, attention layout, conditioning, and the diffusion schedule so the native path is a drop-in for that family. Families outside the native set are routed through the universal fallback path, which is experimental in v0.1.0 and depends on your local torch / diffusers environment. We describe the fallback as a compatibility path under active work, not a guarantee for every model.

9ComfyUI integration

ComfyUI integration is an upcoming preview. The intended design is a drop-in that runs existing ComfyUI graphs on the Veizik runtime (run / serve) so the low-VRAM and native-engine paths apply without rewriting the graph. This is not part of the v0.1.0 public download — it is planned for a later Preview build and will be described as available only once a specific build carries it.

10Support tiers

Where each configuration stands today, stated conservatively. v0.1.0 is a Public Preview with no external reproductions on record, so nothing below is presented as universal.

"Internally verified" means we reproduced it on our own hardware. It is not a claim about every GPU, every model, or every render — those results are still ahead of us.

11Operating entity