Veizik is a hardware-aware local AI media runtime powered by the LimML engine: it checks your hardware and reports a runnable support tier and recommended execution profile. Public Preview — internally verified on Linux + NVIDIA 24 GB class; Windows WSL2 is experimental.
Rendered on one RTX 3090 we own, with every number below measured on that run — not estimated. Full conditions travel with each clip so you can judge it the way you'd judge your own hardware.
The seed still that pinned this shot: view the FLUX frame. Earlier internal clips below.
Public Preview. The tags below say exactly what the downloadable build does today versus what is still internal or planned — see Known Issues for the honest ledger.
veizik doctor scans your machine and prints a runnable support tier per model family, so you know what fits before you render.
live in the downloadCapacity-compute tiering (hot / warm / cold placement) targets fitting large video models on a single 24 GB GPU. LTX-13B peak 9.55 GB on an RTX 3090 (internal).
internal · VRAM measuredSix model-family engine paths are numerically checked at the block/engine level (rel_L2 ~1e-6–1e-7 vs reference) — a component-level check, not an end-to-end render benchmark.
block-level numerical checkveizik login redeems a free key for a server-signed entitlement. Your media and prompts stay on your machine; only license data is exchanged.
live in the downloadBranch from a saved checkpoint: keep the good prefix, re-render only the failing tail. Validated internally on GPU; ships as a Preview build asset — not in the current download yet.
planned · Preview buildGoal: run your existing ComfyUI graph under Veizik with low-VRAM + native engines. Under preview validation — run / serve land in the next release.
upcoming previewThe biggest waste in AI video is "the first part is good but the rest breaks, so I re-render everything." TimeMachine addresses that — one checkpoint infrastructure serves both crash-resume (same settings) and creative branching (new settings).
These families have a native CUDA DiT engine path, each numerically checked at the block/engine level (rel_L2 ~1e-6–1e-7 vs reference — a component check, not an end-to-end render benchmark). A universal fallback path for other models is under development.
We separate claim types on purpose. Measured internally so far: the LTX render times and peak VRAM below, plus block/engine-level numerical equivalence. Still blank: the other model families, and any external reproduction — nobody outside has verified these yet, which is what the Preview is for. Method: benchmark-method.md.
| Render (RTX 3090, 24 GB · 420 W cap · internal) | Wall time | Peak VRAM | OOM |
|---|---|---|---|
| LTX image-to-video · 1216×704 · 73f · 40 steps | 657 s | 20.6 GB | none |
| LTX text-to-video · 1216×704 · 73f · 40 steps | 597 s | 20.6 GB | none |
| FLUX.1-dev seed still · 1216×704 · 32 steps | 1940 s | 24.2 GB | none |
| CogVideoX · HunyuanVideo · Wan · Step-Video | measuring… | measuring… | — |
| Engine path | Block/engine rel_L2 | |
|---|---|---|
| Step-Video 30B | 2.35e-6 | block-level |
| LTX-Video | 1.94e-7 | block-level |
| CogVideoX | 8.43e-7 | block-level |
| HunyuanVideo | 3.6e-6 | block-level |
| Wan 2.1 | 5.53e-7 | block-level |
| FLUX.1-dev | 4.58e-7 | block-level |
Cloud video tools bill a monthly subscription plus metered GPU credits that scale with how much you render. Veizik is a local runtime instead: it runs on the GPU you already have, keeps your media on your machine, and takes the manual memory tuning out of running large models.
Cloud video tools bill a monthly subscription plus metered GPU credits that grow with usage. Veizik renders on the GPU you already own — there's no per-render charge, only the electricity the card draws.
your GPU · electricity onlySkip the model / VRAM / offload trial-and-error and the OOM restarts. veizik doctor scans your machine and reports a runnable support tier per model family, so you know what fits before you render.
doctor · live auto-apply · plannedCapacity-compute tiering targets fitting large video models on a single 24 GB GPU — LTX-13B peaked at 9.55 GB on an RTX 3090 (internal). Frames and prompts are never uploaded to a rendering cloud.
LTX-13B peak 9.55 GB · internalIt runs locally and keeps working offline inside your license grace window. Media, prompts, and project data stay on disk — only license activation talks to veizik.com, and no output is sent anywhere.
local · offline graceEvery number above is measured internally and left blank where it isn't — see exactly what is measured, and what is still measuring…, in measured status.
curl -fsSL https://veizik.com/install.sh | sh on Linux or Windows WSL2 (git + Python 3.10+). No key needed to install.
veizik doctor scans this machine and prints the support tier per model family — so you know what runs before you commit.
veizik login <key> redeems a free key from veizik.com for a signed entitlement. Universal t2v render is experimental today.
| Veizik | Cloud video (Runway / Pika) | Raw ComfyUI | |
|---|---|---|---|
| Runs on your own GPU | yes | no — cloud | yes |
| 30B video on 24 GB | no OOM | n/a | needs manual low-VRAM tuning |
| Checkpoint branch (keep prefix) | TimeMachine preview build | re-render | re-render |
| Per-render cost | your electricity | metered / clip | your electricity |
| Data leaves your machine | stays local | uploaded | stays local |
| Price | Free Preview · Founding $9/mo | monthly cloud plan | free / DIY |
The public runner is the distribution channel — free to install, free to inspect. What you buy is a local runtime license: commercial use rights, stable profiles, private Model Adapters, advanced quantization, Capsules, Queue/batch, Recover & TimeMachine, the API bridge, update rights, and how many machines may run at once. No cloud credits. You supply the GPU.
Metering unit = concurrent run nodes. You are never charged for each machine you install on — install on several computers; the license decides how many may render at the same time.
Founding Creator checkout is live — use the same email at checkout as your free key and payment upgrades that key automatically. Founding Pro and Studio Node are not purchasable today; they open after Preview validation, and the links above only register interest. Sales: sales@veizik.com.
One bootstrap CLI for every tier — no separate builds. The public binary carries the parser, updater, doctor, license client, telemetry client, pack loader, signature verifier and the public Adapter interface; a server-signed entitlement unlocks the matching private runtime pack (LimML native runtime, advanced kernels, Adapters, Capsules, GPU Oracle planner, Recover, TimeMachine, Queue, API bridge). The runtime — not the UI — enforces features. Billing by Polar (merchant of record; USD, tax included). Feature states are labelled research / development / private preview / public preview / shipped; render-time figures are published only where actually measured (LTX today) and left blank elsewhere.
# install (git + python 3.10+) curl -fsSL https://veizik.com/install.sh | sh veizik doctor # scan GPU + per-model support tier veizik login <key> # redeem a free key for a signed entitlement veizik status # show current tier & entitlement
# experimental universal render — Linux + NVIDIA, your own torch/diffusers env # measured on our RTX 3090: ~9 s/frame at 1216x704, 40 steps (see the status section) veizik t2v "a barista pouring latte art, warm cafe" \ --model ltx --w 1280 --h 704 --frames 49 --steps 40
# NOT in the current download — landing in upcoming Preview releases: # veizik run my_workflow.json # ComfyUI integration (next release) # veizik branch --from-step 15 # TimeMachine (Preview build asset) # # track status: github.com/veizikhq/veizik · KNOWN_ISSUES.md
No. Veizik runs entirely on your own GPU — nothing is uploaded and no cloud render credits are involved. A license is a local runtime license; you supply the hardware.
The Preview is internally verified on Linux x86_64 with an NVIDIA 24 GB-class GPU; Windows WSL2 + NVIDIA is experimental. We don't claim every GPU works — run veizik doctor first (it's free and needs no key) and it tells you what it detects. Apple Silicon and smaller memory classes are planned.
Not yet. ComfyUI integration (run / serve) is under preview validation and lands in the next release — it is not in the current download. The goal is that your existing graph runs under Veizik with low-VRAM + native engines; we'll say it's live only when the downloadable build does it.
It branches a render from a saved denoise-step checkpoint: the approved prefix is reused and only the failing tail is regenerated with a new prompt / style / CFG. It has been validated internally on GPU. It ships as a Preview build asset and is not in the current public download yet.
No — Veizik is a proprietary commercial runtime. Installation and evaluation are free; production use requires a license. The engine (LimML) is not distributed as source.
Permission is a server-signed entitlement token, not the key itself. Activation binds to a device fingerprint, and feature gating lives in the runtime executor — not just the UI. You can issue and revoke keys above.
Step-Video 30B, HunyuanVideo, Wan 2.1, LTX, CogVideoX, and FLUX.1 each have a native CUDA DiT engine path, numerically checked at the block/engine level (rel_L2 ~1e-6–1e-7 vs reference — a component check, not an end-to-end render benchmark). The experimental t2v render path today targets LTX-class models on Linux + NVIDIA.
Free keys render watermarked, non-commercial. Your key authorizes via a server-signed entitlement — issued below, enforced in the runtime.
Keys are stored hashed; the raw key is shown only once. Revoke anytime — the entitlement stops validating.
Run your existing ComfyUI graph under Veizik with low-VRAM + native engines — run / serve, under preview validation.
Checkpoint branching in the downloadable build: keep the good prefix, re-render only the failing tail. Validated internally on GPU.
Batch, A/B fanout, multi-GPU and team seats open after Preview validation. Your free account carries over.
Live in the current download: doctor, login/status, and a free entitlement, plus an experimental universal t2v path. Everything above is on the way — we mark it live only when the build does it.
Drop your email to hear when billing opens and Preview builds ship, or send a compatibility question — it reaches us directly.