Built to run where your footage lives.
Seven model families — super-resolution, diffusion restoration, interpolation, denoising, depth, and segmentation — compiled into engines tuned for your exact hardware and executed entirely on your machine.
Not a port of a cloud service. A native engine.
Most AI video tools run inference in a datacenter and stream you the result. Refocused inverts that: each model is built into an engine on your own hardware, so the heavy lifting happens at full local bandwidth — no upload queues, no credits, no per-minute pricing.
Download
Model weights arrive encrypted from our servers — your video never moves over the network in either direction.
Build
Engines are compiled on your machine, for your machine: CoreML on Apple Silicon, TensorRT on NVIDIA — tuned to your GPU and memory.
Configure
Choose tile sizes, precision, and compute units — CPU, GPU, or Neural Engine — or use one-click starter presets.
Run
Frames flow through a staged worker pipeline — decode, preprocess, infer, postprocess, encode — with live per-stage telemetry and automatic crash recovery.
Long clips and large frames are handled by automatic tiling with feathered seam blending, so even 8 GB machines can process footage that would never fit in memory at once.
Seven families. Seven different problems.
Each family is a distinct architecture chosen for its job — not one network with seven presets. Here is how each one works, and why it works that way.
Refocus
How it worksAn event-driven super-resolution network: it synthesizes brightness-change “events” between frames into motion cues, then uses them to reconstruct detail a single frame can’t carry.
Why it mattersMotion awareness is the difference — per-frame upscalers hallucinate independently on every frame and shimmer; Refocus stays sharp and temporally stable. Fixed 4×, combinable with output downscale for 2×-equivalent results.
DETAILS →Regenerate
How it worksA generative diffusion pipeline — VAE encoder, diffusion transformer, VAE decoder — that rebuilds plausible high-frequency detail instead of interpolating pixels.
Why it mattersFor heavily degraded footage, there is nothing left to interpolate; detail has to be re-synthesized. A turbo decoder option speeds decode ~7×, and runtime load/unload plus disk offload let it run on constrained hardware.
DETAILS →Regenerate-Q
How it worksA one-step streaming variant of Regenerate: stateful per-tile KV caches carry context from frame to frame, so each new frame needs only a fraction of the compute.
Why it mattersDiffusion-class detail at practical speed, with strong temporal consistency built into the cache design. Scales from 8 GB consumer GPUs to 80 GB datacenter cards via VRAM/RAM/disk tiering.
DETAILS →Interpolate
How it worksOptical-flow estimation with softmax-splatting frame synthesis — new frames are rendered by warping real ones along measured motion, not by blending.
Why it mattersAny integer factor: 2× doubles frame rate for 60/120 fps conversion or silky slow motion, without the ghosting of naive frame blending.
DETAILS →Denoise
How it worksA self-supervised spatio-temporal blind-spot network with flow alignment and Bayesian temporal fusion — trained without any clean reference footage.
Why it mattersFusing evidence across aligned frames removes noise without smearing detail, and the temporal fusion is what keeps it flicker-free. One dial: strength (σ).
DETAILS →Depth
How it worksMonocular video depth from a ViT backbone with a temporal head, processed in 32-frame windows with seam-free alignment between them.
Why it mattersTwo variants — relative and metric (real-world meters) — in three sizes. Depth powers the app’s synthetic depth-of-field Focus tool and depth-threshold masking, and exports as grayscale/float maps for VFX pipelines.
DETAILS →Segment
How it worksSAM 2.1 promptable object segmentation with video mask tracking — click an object once and the mask follows it across every frame.
Why it mattersTracked masks are what make region-targeted work possible: fix, denoise, or regenerate one object without touching the rest of the frame. Four sizes, tiny to large.
DETAILS →The models are designed to be combined.
Enhancement rarely ends with one pass. The architecture treats every model as a stage that can be chained, targeted at a masked region, or re-run on just the part of the frame that needs it.
One job, many stages
The pipeline builder chains models in a single run — Refocus into Regenerate for the flagship workflow, with Interpolate and Denoise stages insertable anywhere in the chain. Presets are saveable and copyable from any past project.
Refine — surgical fixes after enhancement
A persistent workspace where the models compose interactively: tracked SAM 2.1 masks, depth-threshold selections, synthetic depth-of-field focus, and region-targeted reprocessing that runs a fresh pipeline on just a masked area and blends it back.
Compare — verify at the pixel level
Timestamp-synchronized A/B wipe between any two videos with up to 8× zoom and pan — built for checking work frame by frame, even when frame counts differ after interpolation.
Professional I/O
ProRes 10-bit 4:2:2/4:4:4, H.265/H.264, AV1, VP9; HDR metadata passthrough and override (PQ/HDR10, HLG, BT.2020); PNG/TIFF image sequences with alpha; hardware encode via VideoToolbox and NVENC.
Made for Apple Silicon. Ready for NVIDIA.
Neural Engine and GPU, at the same time.
Models are compiled to CoreML, and the workload is split across the chip: some components run on the Apple Neural Engine while others run on the GPU, so both are working at once instead of taking turns. In Regenerate-Q, the diffusion transformer runs on the GPU concurrently with encode and decode on the Neural Engine; Interpolate and Denoise offer the same dual-execution mode.
Our diffusion models are optimized to run locally on macOS hardware without the extreme quantization that degrades other models' output — the detail the model generates is the detail you get.
Hardware video encode via VideoToolbox; ProMotion-aware native playback throughout the app.
TensorRT engines, built for your card.
On NVIDIA hardware, models compile to TensorRT/CUDA engines optimized for the specific GPU in your machine. VRAM, system RAM, and disk tiering let the generative models scale from 8 GB consumer cards up to 80 GB datacenter GPUs.
Hardware video encode via NVENC. Windows and Linux support is currently in Beta.
Local isn't a feature. It's the architecture.
On-device. Every model executes locally — no cloud inference, no uploads, no credits or render quotas. Your footage never leaves your machine.
Uploads. The only network traffic is downloading model weights and license checks — never your content.
Once engines are built and your license is active, processing works without an internet connection.
The proof is in the pixels.
Interactive before/afters for every model — or download the free trial and run the engines on your own footage.