Built for the model, not around it.
Veizik runs video, image and language models natively on one NVIDIA GPU, and solves the hard part for each kind of work. Here is what that means per model — starting with the one that shows it best.
Three kinds of hard problem.
A long render holds its place through crashes and reboots — and, in resident mode, steps aside for urgent work and resumes from exactly where it stopped. Byte-deterministic on one GPU.
Qwen3.6 reads an image, or a folder of frames, with your prompt and answers about it — on your own GPU, nothing uploaded. Generated media carries a provenance mark.
Greedy decoding is deterministic — the output hash matched across three NVIDIA cards — behind a local OpenAI-compatible server, with no Python.
Interrupted five times. Finished anyway.
A five-second, 1280×720 render was cut off five times — twice by the host machine crashing outright. Every stop resumed from the last completed step, and the three pieces that did work cover all 40 steps once. And resuming is exact: in a separate ultrafast-mode run, a render resumed from its checkpoint and the same render never interrupted came out byte-for-byte the same.
Two things make a long render dependable: it survives interruption (shown below, with the hashes), and — in resident mode — it yields to urgent work without losing progress. Both rest on the same per-step checkpoint.
Release status. The NVIDIA build that renders Wan 2.2 is on Releases. Everything on this page was produced with a development build of that engine, so these figures are a record, not a release speed figure.
Five attempts, one result.
The same command each time, with --resume after a stop.
| Attempt | Steps computed | How it ended |
|---|---|---|
| 1 | Steps 0–16 | Host crash |
| 2 | — | Stopped before its first step |
| 3 | Steps 17–18 | Host crash |
| 4 | — | Stopped before its first step |
| 5 | Steps 19–39, then decode and encode | Finished |
Each resume picked up at the next step, so all 40 steps were computed exactly once — none repeated, none skipped.
A crash costs minutes, not the render.
A long video render runs for hours. Power blips, driver resets and reboots happen in that time. Veizik commits the sampler state after every step, so a stop loses at most the step in flight — and because the engine is deterministic, the resumed result can be checked against an uninterrupted one by hash.
The hashes.
The record of this render, and the check that resuming changes nothing.
| Resumed render, final latent (SHA-256) | dc9a1301b9d368f06373be9bfad490a0dcf1d24787ba1668d3e6b6f3d66ad917 |
| Video (SHA-256) | c57752c3781b6ee7fd4783a9e5539dffd89c3f5dfc14a1c0b72dbe9613b48f0c |
Resuming is exact
The same five-second video in the faster ultrafast mode, run twice with one command: once stopped and resumed from its step-4 checkpoint, once straight through with no interruption, with two machine reboots between the two runs. The final latents are byte-for-byte identical:
| Resumed from step 4 — final latent | b7e65f28629bcf7d13ed522a966985729083e6a9cd1f327bd707c226398872d8 |
| Never interrupted — final latent | b7e65f28629bcf7d13ed522a966985729083e6a9cd1f327bd707c226398872d8 |
The video and the decoded frames match too (video d888126c…, frames ad8a9681…). The quality render above resumes through the same mechanism; it has not itself been re-run uninterrupted, so its hash is shown as a record, not as a comparison.
Urgent work first — without losing the long render.
A long render does not have to block the GPU. In resident mode it steps aside for urgent work and resumes from its checkpoint, exactly.
.vzckpt resume on a single GPU — shipping in the current NVIDIA release.A long render is paused at the next step boundary. Its progress is written to a .vzckpt checkpoint and the GPU is freed. Nothing already computed is thrown away.
The urgent render runs on the freed GPU — sent with priority, it goes ahead of the long job. The model stays loaded in between, so there is no cold reload.
When the urgent work finishes, the long render continues from its .vzckpt — from the step it stopped at, not the start. The engine is deterministic, so the result is the same as if it was never paused.
Why teams and GPU farms care
- One GPU, many uses. A single consumer card runs a long batch render and still answers an urgent request in between — no second machine, no waiting for the batch to finish.
- No compute thrown away. Preemption lands on a step boundary and checkpoints there, so slotting in urgent work never discards the long render's hours of progress.
- The model stays resident. Switching between jobs costs a checkpoint write, not a cold model load, so the urgent answer comes back fast.
- Exact on resume. The resumed render is bit-for-bit what an uninterrupted one would have been — the same guarantee this page already shows for crash-resume, now under deliberate preemption.
How it is used
Run one resident server and send renders to it. When an urgent render arrives, the render already running is the one that pauses: it writes a .vzckpt checkpoint, yields the GPU to the urgent render, and then resumes itself from that checkpoint once the urgent one finishes — from the exact step it stopped at. You never pause or restart the long render by hand; the engine does the checkpoint and the resume.
# 1. start a resident server — the model loads once and stays loaded $ veizik serve wan22_t2v_a14b --port 8000 # 2. submit a LONG render — it starts running on the GPU $ curl -s localhost:8000/v1/videos/generations \ $ -d '{"prompt":"a 5-second cinematic drone shot over a coastline at dawn","seed":42}' # 3. while render #2 is still going, send an URGENT one (priority: urgent): # render #2 auto-pauses to a .vzckpt, the urgent render runs, then render #2 # auto-resumes from its checkpoint. you never stop or restart #2 by hand. $ curl -s localhost:8000/v1/videos/generations \ $ -d '{"prompt":"a 2-second product spin on white","seed":7,"priority":"urgent"}'
Available now. Resident serving with priority preempt and .vzckpt resume ships in the current NVIDIA release — the Wan engine and the veizik command together, on Releases. Install it, start a resident server, and send an urgent render to see the pause-and-resume above. Crash-resume ships in the same build.
See what is running; resume what stopped.
The shipped commands that show render and server state, and steer a long render.
- See what is running.
veizik statusshows the device activation and the installed models;veizik pslists the resident servers (port and model), andveizik stop <port>ends one. - Checkpoint and resume.
--checkpoint-every Nwrites a.vzckptevery N steps;--resume(or--resume-from <name|dir>) continues an interrupted render from its last checkpoint — bit-for-bit. - Priority preempt is automatic. In a resident server an urgent render preempts the one running on its own (above); there is no pause command to run and nothing to schedule by hand.
# what is activated on this machine, and which models are installed $ veizik status # resident servers running here (port + model); stop one, or all $ veizik ps $ veizik stop 8000 # or: veizik stop all # a long render: write a .vzckpt every N steps so it can be resumed $ veizik run wan22_t2v_a14b "<prompt>" --out ./out --checkpoint-every 1 # resume an interrupted render from its last checkpoint $ veizik run wan22_t2v_a14b "<prompt>" --out ./out --resume $ veizik run wan22_t2v_a14b "<prompt>" --resume-from ./out # or a saved --name
One prompt, four renders, measured.
Each mode trades time for detail; every figure below is from the render shown.
- Per step
- 72.4 s
- Render time
- 49.0 min
- Peak GPU memory
- 22.2 GB
- Run
- One uninterrupted run
- Final latent
b7e65f28…
- Per step
- 105.2 s
- Render time
- 71.2 min
- Peak GPU memory
- 21.7 GB
- Run
- One run from the start (an earlier attempt failed and was discarded)
- Final latent
2f9a4f2a…
- Per step
- 139.3 s
- Render time
- 93.6 min
- Peak GPU memory
- 20.9 GB
- Run
- One uninterrupted run
- Final latent
50207565…
- Per step
- 170.1 s
- Render time
- —
- Peak GPU memory
- 20.9 GB
- Run
- Five pieces, resumed — no single-run time
- Final latent
dc9a1301…
Same prompt, seed, size and 40 steps in every mode; one RTX 3090 at 420 W; one development build of the NVIDIA engine (the same build for all four). Render time runs from the first denoising step to the encoded video with the weights loaded, and is given only where the render ran start to finish in one go. Our own figures — not a release speed figure. Another job was using the machine's other GPU.
What the clock does and does not say.
- 170.1 s per step, mean of all 40 steps on one NVIDIA GeForce RTX 3090 at 420 W — the fair figure for a render that ran in pieces.
- The pieces add up to 113 min of stepping. That is a sum, not a run: the wall clock between first and last attempt includes the crashes, so it is not published as a render time.
- For clean run times, see the modes rendered in one go above.
- Our own figures only. Another job was using the machine's other GPU during attempts 3–5.
One consumer GPU, on the record.
Machine
| GPU | NVIDIA GeForce RTX 3090, 24 GB (Ampere, sm_86) |
| Power limit | 420 W |
| Driver | 566.36 |
| OS | Linux (kernel 5.15, Windows host) |
| Engine | Veizik for NVIDIA, development build — not released |
Settings
| Model | Wan2.2-T2V-A14B |
| Size | 1280×720, 81 frames at 16 fps (5.06 s) |
| Steps | 40, two experts |
| Seed | 42 |
| Guidance | 4.0 high-noise / 3.0 low-noise (model default) |
| Shift | 12.0 (720p preset) |
| Mode | quality |
Weights — from their publisher, not shipped by Veizik
| Part | Repository | Snapshot |
|---|---|---|
| Transformer (two experts) | Wan-AI/Wan2.2-T2V-A14B-Diffusers | 5be7df96 |
| Text encoder, tokenizer | Wan-AI/Wan2.1-T2V-14B-Diffusers | 38ec498c |
| VAE | Wan-AI/Wan2.1-T2V-1.3B-Diffusers | 0fad780a |
Everything needed to run it again.
Same prompt, same seed, same settings, same GPU architecture: same latent. Checkpoints are written every step; resuming is one flag.
Prompt sha256 d224fa1df3bf…
Cinematic photoreal close-up of a single capybara relaxing peacefully in a steaming natural hot spring at dusk, only its lower body in the water and its head held calmly well above the surface, dry soft fluffy fur on the head and face with no dripping, eyes gently half closed in bliss and slowly blinking, soft warm steam drifting upward into the air above the pool, gentle ripples spreading slowly across the calm glassy water around its body, a yuzu citrus fruit floating softly beside it, warm amber and soft rose light over a dark forest background, slow smooth cinematic push-in, shallow depth of field, detailed dry fluffy fur, calm still water surface, serene cozy and tranquil, 35mm film look, no text, no people.
Negative prompt sha256 dd682ecfdfa1…
text, watermark, logo, people, human, hands, fingers, extra capybara, morphing, warping, flicker, deformed, extra limbs, low detail, blur, cartoon, cyan, blue, purple, neon, oversaturated, water dripping on head, droplets on head, water on head, water falling on head, dripping from chin, dripping from jaw, dripping from face, soaked fur, spiky wet matted fur, drenched, shaking off water, splashing, water splashes, spray, wet face, rain, raindrops, waterfall, mist on the face.
Command
# produced with a development build; the NVIDIA build is on /releases $ veizik run wan22_t2v_a14b --prompt-file prompt.txt --neg-file neg.txt --width 1280 --height 720 --frames 81 --steps 40 --seed 42 --mode quality --checkpoint-every 1 # after any interruption: the same command, plus $ veizik run wan22_t2v_a14b --prompt-file prompt.txt --neg-file neg.txt --width 1280 --height 720 --frames 81 --steps 40 --seed 42 --mode quality --checkpoint-every 1 --resume
Reads a picture, marks what it makes.
On NVIDIA, Veizik's shipped image capability is understanding — a vision-language model that answers about an image or a sequence of frames; generated media carries a provenance mark.
- Image and video understanding. Qwen3.6-35B-A3B takes one image, or a folder of 2–256 frames, together with your prompt and answers about it — on your own NVIDIA GPU, nothing uploaded. This ships in the current download.
- A provenance mark on generated media. Every frame Veizik generates carries a v1 provenance mark: an in-pixel watermark and an XMP tag marking it AI-generated. It holds no prompt, device, path or account data.
- Image generation. Text-to-image models are coming to NVIDIA — on your own GPU, with the same v1 provenance mark on every image.
Deterministic, local, and yours.
Qwen3.5 and Qwen3.6 run as one native engine on your GPU, with reproducible output and an OpenAI-compatible server — the whole thing on the machine, no Python.
- The same answer on every machine. Greedy decoding is the default and is deterministic — the same prompt gives the same tokens. For the committed benchmark prompt the output hash was identical on the RTX 3090, RTX 4090 and RTX 5090.
- A local OpenAI-compatible server.
veizik serveanswersPOST /v1/chat/completions,/v1/completionsand/v1/modelson 127.0.0.1 — point your existing OpenAI client at it and nothing leaves the machine. - No Python, no framework. One native engine reads the published Hugging Face checkpoint and runs on the NVIDIA driver alone: no CUDA toolkit, no framework stack, no cloud at inference time.