Its own publisher asks for a GPU with 80 GB — and says so with the memory-saving options already switched on. We measured this clip at 6.5 GB on one RTX 3090, against 17.7 GB for the standard fp8 offload path on the same card, and the footprint is not bought by letting the picture fall apart: across the clip veizik loses 8–11% of its sharpness where that path loses 47%.†
LTX-Video, Wan, HunyuanVideo, CogVideoX, Step-Video and FLUX run on the same runtime. veizik doctor reads your card and tells you what it will run, per family, before you commit to a download.
one install, every familyEach figure on this site ships with the config that produced it — model hash, resolution, frame count, steps, seed — and a run manifest you can diff against your own. Run the same fixed config on your card and compare.
method & conditionsYour prompts, your inputs and your renders stay local — the engine runs on your GPU, so there is no upload and no per-render charge. What you buy is a runtime licence, not cloud credits.
install free · upgrade laterThe benchmark harness, metrics, manifest schema and these run records are live today: run the fixed config against the same model hash and diff your run record against ours. The one-line curl wrapper and the veizik bench subcommand are convenience wrappers still in development.
# planned — not live yet: $ curl -fsSL https://veizik.com/bench.sh | bash # planned $ veizik bench --suite ltx-consumer --upload=ask # planned # today — real: run the fixed config from # benchmark-method.md against the same model hash
GPU RTX 3090 24GB (sole tenant · 420W verified) Model Lightricks/LTX-Video @ 8984fa2 Profile veizik-native · bf16 Config 768x448 · 49f · 30 steps · seed 42 Peak VRAM 9.55 GB (spread 0.00, 5 runs) Wall 18.5 s (median · ±0.97 · min 17.4 / max 20.4) Output sha256 66b560f1…c16c28 Manifest veizik-bench/reports/runs/d605e616….json
Every figure carries its conditions and raw per-run JSONL, and is reproducible on the same card. Method: benchmark-method.md · Reproduce: REPRODUCE.md (LTX/FLUX evidence + lockfile).
Rendered locally on a single NVIDIA GPU, 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.
A high-resolution still is generated first, then turned into a 5-second cinematic film with image-to-video — all on one local GPU, and nothing leaves the machine. Test conditions for every figure on this page →
RTX 3090 · exclusive GPU · 420 W verified · same seed/prompt/scheduler each run:
Every run ships raw per-run JSONL (conditions · GPU UUID · observed draw) in veizik-bench, so the number is reproducible on the same card.
Every row below is a real render on a pinned config — model hash, resolution, frame count, steps and seed all published — with wall time, peak VRAM and peak host RAM taken from the run itself. Run the same config on your card and compare.
| Model · text-to-video | Workload | Wall (median) | Peak VRAM | Peak host RAM | Runs |
|---|---|---|---|---|---|
| LTX-Video | 768×448 · 49f · 30 steps | 18.5 s 17.4–20.4 | 9.55 GB | 18.7 GB | 5 runs |
| FLUX.1-dev (image) | 1024² · 24 steps | 49.25 s 48.8–50.5 | 12.78 GB | 45.2 GB | 4 runs |
| CogVideoX-2b | 720×480 · 49f · 50 steps | 195.2 s 195–213 | 16.29 GB | 18.6 GB | 3 runs |
| Wan 2.1 · 1.3B | 832×480 · 49f · 30 steps | 149.4 s 149–150 | 11.60 GB | 23.4 GB | 3 runs |
| Wan 2.1 · 14B | 832×480 · 49f · 30 steps · seq offload | 854.5 s | 16.68 GB | 94.9 GB | 1 run |
| Step-Video · 30B | 992×544 · 51f · 30 steps | 1730 s | 12.48 GB | 96.0 GB | 1 run |
Conditions: 420 W verified, sole GPU tenant, seed 42, on 24 GB-class NVIDIA hardware. The 14B/30B rows need ~96 GB of host RAM — read the host-RAM column before you plan a build. Run the same config on your card and open a result PR.
Technical Preview. The tags below say what the downloadable build does today and what is still planned — see Known Issues for the open ledger, and test conditions for every figure on this page.
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 downloadThe runtime fits large video models on consumer NVIDIA GPUs without manual offload tuning — LTX-Video 2B peaks at 9.55 GB, and doctor prints the per-model fit for your card.
peak VRAM measuredEngine 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. Image and video today; language models and more on the roadmap.
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. 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).
Start a 40-step LTX render. SIGKILL it at step 20. Resume from the last checkpoint and compare to an uninterrupted run of the same seed.
Branch A/B/C: the prefix is computed once; each additional ending (warm / cyberpunk / luxury) costs only its tail. Conditions: one LTX run on an RTX 3090, claim id VZK-TM-LTX-RESUME-3090.
These families have a native 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.
Performance here is not one leaderboard number. Each axis below is measured on a pinned config — same model hash, prompt, seed, scheduler, steps, resolution and power cap — so a figure means the same thing every time it is published. Test conditions →
Peak VRAM at equal model and quality. LTX-Video 2B peaked 9.55 GB on a 24 GB card, 5 runs.
Wall time on a pinned config, 420 W verified. LTX 18.5 s (5 runs) · FLUX 49.25 s (4 warm runs), each with a run record.
Resume and branch savings after a kill — the prefix is kept and only the tail re-renders. TimeMachine ships as a Preview build asset.
One pinned config per row — model hash, prompt, seed, scheduler, steps, resolution, frame count and power cap all fixed and recorded — so the same command reproduces the same number on the same card. Full method: benchmark-method.md.
| Render · 24 GB card, sole tenant | Wall time | OOM |
|---|---|---|
| LTX image-to-video · 1216×704 · 49f · 30 steps | 33.5 s | none |
| LTX image-to-video · 1216×704 · 73f · 30 steps | 71.3 s | none |
| LTX text-to-video · 1216×704 · 49f · 30 steps | 32.2 s | none |
| 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 |
| Wan 2.1 | 5.53e-7 | block-level |
| FLUX.1-dev | 4.58e-7 | block-level |
The comparison that matters on a desktop card is memory and stability, not a leaderboard second. Below is Wan2.2 image-to-video run two ways on one machine, with the conditions published so you can run the same config yourself.
| Mode (same clip, same card) | Peak GPU | Temporal drift (front→back) | Wall · step counts differ |
|---|---|---|---|
| Veizik native int8 | 6.5 GB | −8…−11% | ~430–600 s |
| fp8 CPU-offload (reference) | 17.7 GB | −47% | 752 s |
~2.7× less peak VRAM than the fp8 reference, and far less back-half drift (−8% vs −47%). Conditions: Wan2.2 image-to-video, 5 s · 81 f · 848×480, one 24 GB card, same clip and same card per row; step counts differ per row, so wall time is not an identical-condition comparison; drift is distance from fp8, not a quality score; measured on the veizik-native · int8 engine profile (2026-07-17). Claim id VZK-WAN22-I2V-INT8-3090.
Run it yourself: the same fixed config ships in veizik-bench — open a result PR with what your card does — start here. Negative results are welcome and published.
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 · plannedThe runtime fits large video models on a single consumer NVIDIA GPU — LTX-Video 2B peaks at 9.55 GB, and doctor prints the fit per model family for your card. Frames and prompts are never uploaded to a rendering cloud.
LTX-Video 2B working set 9.55 GBIt runs locally and keeps working offline for 30 days at a time. Media, prompts, and project data stay on disk — only license activation talks to veizik.com, and no output is sent anywhere.
local · 30-day offlineEvery number above comes from a run on a pinned config — test conditions for every figure on this page →
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 |
| Large 30B-class video on one consumer GPU | native engine path, verified at block level (rel_L2 2.35e-6) | n/a | — |
| 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 · paid from $29/mo | monthly cloud plan | free / DIY |
Same graph. Your own GPU. No per-render bill. Keep the workflow you already built and run it low-VRAM on hardware you own.
Local, repeatable, resumable batch production. A crash doesn't discard the render — the good prefix is kept and only the tail re-runs.
More headroom per node — measured before a job runs. doctor profiles GPU capacity so admission is a decision, not a surprise OOM.
Ship your model to consumer GPUs. A native engine path verified at the block level against your reference — a low-VRAM distribution option without a fork.
Install is free, and inspecting the hardware scan and entitlement client is free. What you buy is a local runtime license: which model families the engine will run, how far you can push resolution and length, commercial use rights, and the advanced execution paths. No cloud credits. You supply the GPU.
Licence unit = 1 key, 1 PC. Rungs differ only by what the engine can do — never by how much you render. Need a second machine? That's a second key (volume discount from 5). Changing hardware is 3 self-service transfers a year.
There is no per-render charge, and there never will be. The engine runs on your GPU and your electricity — we don't pay for your renders, so we don't bill for them.
Every tier writes a machine-readable AI provenance mark (C2PA); it cannot be switched off. No tier watermarks your output — not even the free one. The C2PA mark is a signature in the file's metadata that says a machine made it; that is a legal obligation and stays. It does not put anything on the picture. AI transparency · Model licences — a paid tier licenses the runtime, not the models.
Twelve paid months earn you one version, permanently. Not a discount and not a trial. Complete a paid year and every version released during it is yours — including the one you were actually running on your last paid day, not a build from twelve months earlier. It keeps working at your tier if you stop paying, and if we stop existing. What exactly you get — including what we owe you if we shut down, the limits we cannot insure against, and the one condition we have not finished building, which is why nothing is issued today.
We measure whether your current model and quality target can move to a lower-cost accelerator tier — same weights, same output target, reported GPU memory, host memory, throughput and cost per output. Evaluations, design-partner pilots and OEM/embedding agreements are scoped per engagement.
Talk to salesBilling opens after preview validation — nothing is charged today. Enterprise and deployment enquiries: sales@veizik.com.
What "commercial output" means: it is your right to use the Veizik runtime commercially. It does not change the licence of the underlying models — those keep their own terms. FLUX.1-dev is published under a non-commercial licence, and HunyuanVideo's licence does not apply in the EU, UK or South Korea. Check every model you plan to bill for on the model licences page before you take paid work.
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 (Veizik 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). Veizik does not ship face swapping, lip-sync, or voice cloning — those capabilities are not in any build. The Service is currently not offered to residents of the EU, EEA or UK. Feature states are labelled research / development / private preview / public preview / shipped.
# 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 timings for measured configs are in the benchmarks table below 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.
An NVIDIA GPU on Linux x86_64; Windows 11 + WSL2 + NVIDIA is experimental. How much VRAM you need depends on the model, not on a card class — the peak VRAM per model family is in the results table, and veizik doctor reads your card and prints the support tier per family before you download anything (free, no key needed). Apple Silicon is 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.
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 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 (Veizik) 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 engine path. We publish block/engine-level numerical checks for five of them (Step-Video, Wan 2.1, LTX, CogVideoX, FLUX.1 — rel_L2 ~1e-6–1e-7 vs reference, a component check, not an end-to-end render benchmark). We do not publish figures or outputs for HunyuanVideo: its licence excludes the EU, UK and South Korea from the territory it covers — see model licences. The experimental t2v render path today targets LTX-class models on Linux + NVIDIA.
Free keys allow commercial work and are not watermarked. Each model still carries its own licence. Every tier writes a machine-readable AI provenance mark. Your key authorizes via a server-signed entitlement — issued below, enforced in the runtime.
Look up or revoke the keys tied to an email, in the account console.
Open the consoleRun 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.
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; release notes land in the public repo as each piece ships.
Drop your email and the launch, billing-open and Preview-build notices go out to the list automatically. Compatibility questions land in the auto-acknowledged support inbox; anything worth a public answer goes to the public issue tracker and the docs.