An open-source AI video toolkit built for anime. Interpolation, upscaling, restoration, depth and segmentation, chained in whatever order you need, as a desktop app, an After Effects panel or a command line.
--upscale adore. Drag the handle.
New in 3.0
TAS 3.0 runs dedup, restore, upscale, interpolate and resize in the order you type them, as many times as you need. It also adds RIFE 4.26 and NVIDIA Maxine frame generation, makes RIFE much faster, and does all encoding inside TAS.
Type --upscale before --interpolate and TAS upscales first. Swap them and it interpolates first. Restore after upscaling or dedup between two interpolations: TAS prints the order it resolved before the first frame.
--upscale span --interpolate rife4.26
› Order: upscale span → interpolate rife4.26 2xType a stage again to run it again. Each pass takes its own settings as values right after the flag, and a repeat without values reuses the previous one's: two upscalers back to back, or a second interpolation on the first one's output.
--upscale span --upscale shufflecugan
--interpolate rife4.26 --interpolate 3x--resize is now a stage with a target: 1080p, 4k, 1920x1080 or 50%. Typed first, the decoder does it. Typed last, it sets the output size, so you can downscale a 4K source, upscale it, then fit the result.
--resize 1080p --upscale span --resize 1440pNew RIFE weights, a Heavy build with a 16-channel feature encoder, and Ultra for final renders. Ultra runs Heavy as four flipped views and was closer to ground truth on 87% of 442 held-out anime frames, at 3–4× Heavy's render time.
--interpolate rife4.26-ultra-tensorrtNVIDIA's Video Frame Generation, available as an interpolation method in low, medium and high. It holds frames at shot changes it detects itself. Needs an RTX 40 or 50 series GPU.
--interpolate maxine-highRIFE on CUDA and TensorRT now shares one implementation, and its output is unchanged. High-quality depth needs far less VRAM: video_small_v3 at 1080p dropped from 18.5 GB to 5.3 GB.
--interpolate rife4.26-tensorrt
# 720p, RTX 3090: 201 → 332 fpsLong flags such as --upscale_method and --interpolate_factor still work, and now apply to the last stage of their kind typed before them. What did change is the order. In 2.x, interpolation always ran before upscaling. In 3.0, --upscale_method typed before --interpolate_method upscales first. These flags were removed, and TAS stops with the replacement if it sees one:
| Removed in 3.0 | Use instead |
|---|---|
--interpolate_first |
Type the order you want: --interpolate before --upscale. |
--resize --resize_factor 0.5 |
--resize 0.5 as the first stage. Same decoder resize, bit-identical output. |
--output_scale 2560x1440 |
--resize 2560x1440 as the last stage. It resizes bicubic in the chain instead of bilinear in the encoder. |
--preset, --list_presets |
A --json file. It now takes a "chain" list, one stage per entry, with the same values as the command line. |
x264_nelux, prores_nelux, … |
The plain name: x264, prores. Every encoder runs in-process now. |
gmfss, gmfss-rocm |
RIFE or DistilDRBA. |
Full grammar in PARAMETERS.MD, every change in the changelog.
Capabilities
Multiply frames between keyframes with RIFE 4.26, 4.26-heavy and 4.26-ultra, DistilDRBA or NVIDIA Maxine frame generation. Scene-change detection built in.
RIFE · DistilDRBA · Maxine · Scene cut
2× resolution with anime-tuned models. ShuffleCugan, SPAN, Adore, Fallin Strong and the ArtCNN family all supported. Run two upscalers back to back for 4×.
ShuffleCugan · SPAN · Adore · Cyte · ArtCNN
Monocular depth estimation via Depth Anything V2 and V3, temporally-stable Video variants and the anime-tuned Limbo models, for After Effects 2.5D parallax and shader work.
DA V2 / V3 · Video · Limbo
Alpha-channel mattes for character isolation. Clean edges on hair, armor and line art, ready for compositing in Resolve or AE.
ISNet · BiRefNet · Alpha out
SCUNet denoising, anime-specific sharpening and deblock. Rescue old broadcast masters without destroying cel detail, before or after upscaling.
SCUNet · NAFNet · DeHalo · Anime1080Fixer
Drops redundant or near-identical cels before the GPU touches them, for faster passes. Or use --smooth_dedup to interpolate across held drawings and keep the duration and audio.
SSIM · MSE · FlowNetS · VMAF
Apps
Click through it on the desktop, render from inside After Effects, or script every pass from a terminal. Same models, same flags, same results.
3.0 Windows 10 / 11 x64
The whole TAS pipeline in a desktop app. Drop in a clip, switch steps on, press Run. No Python and no terminal: the app installs the engine itself on first launch.
Free with the DirectML, NCNN and CPU backends. The CUDA, TensorRT, ROCm and OpenVINO backends unlock with a $3+ sponsorship on GitHub Sponsors or Patreon.
After Effects 2020+ · Premiere Pro alpha · Windows · macOS
The TAS panel, docked inside your Adobe workflow. Queue shots, drag Restore, Interpolate and Upscale into the order they run, browse community presets and render without leaving your comp. Full After Effects support, with Premiere Pro in alpha.
The CUDA, TensorRT, OpenVINO, ROCm and MPS backends and the NVENC encoders need a $3+ sponsorship in TAS-AdobeEdition.
main.py · Python 3.14 · AGPL-3.0
Every pass is a flag on main.py, run in the order you type it. Script it, batch it, drop it in a Makefile. It's just a CLI, and it's what the other two run underneath.
$ python main.py --input ep01.mkv \
--interpolate rife4.26-tensorrt \
--upscale span-tensorrt
› Order: interpolate rife4.26-tensorrt 2x → upscale span-tensorrt
› done · ep01-Int2-Up2.mkvFree and open source. Every model, every backend.
Pipeline
Every pass TAS runs shares a single in-memory frame queue, with no disk writes between stages. Below is the default order the apps start from. On the command line, the stages run in the order you type them and any of them can repeat.
Local file, batch list or YouTube URL. A --resize typed first is done by the decoder.
mp4 · mkv · mov · webm
Drops redundant cels before the GPU ever sees them, or interpolates across them with --smooth_dedup.
SSIM · MSE · FlowNetS · VMAF
Denoise, deblock, dejpeg, sharpen and darken line art. Several models in one stage, in the order given.
SCUNet · NAFNet · Anime1080Fixer · FastLineDarken
Synthesizes in-between frames from neighboring keyframes. Type it twice to multiply again.
RIFE 4.6 → 4.26-ultra · DistilDRBA · Maxine
2× with anime-tuned super-resolution architectures. Finish with a --resize for an exact output size.
ShuffleCugan · SPAN · Adore · OpenProteus · AniScale2
Encoded inside TAS through Nelux, with no FFmpeg install. Animation-tuned x264/x265, NVENC, Quick Sync or AMF.
x264_animation_10bit · x265 · NVENC · QSV · AV1 · ProRes
Models
77 models across five families in TAS 3.0, before backend variants. Bring your own by passing the file to --upscale or --custom_model: Spandrel formats (.pt, .pth, .ckpt, .safetensors) on CUDA and ROCm, .onnx on TensorRT, DirectML and OpenVINO.
RIFE · DistilDRBA · NVIDIA Maxine
SPAN · ShuffleCugan · ArtCNN · Cyte
Denoise · Deblock · Line art
Depth Anything V2 / V3 · Video · Limbo
ISNet · BiRefNet · Alpha matte output
CLI
Every pass is a flag, and the flags run in the order you type them. Put a stage's settings straight after it (--interpolate rife4.26 3x), type it again to run it twice, and read the resolved order on the first line of output.
$ python main.py --input anime_episode.mkv \
--restore anime1080fixer-tensorrt \
--interpolate rife4.26-tensorrt \
--upscale shufflecugan-tensorrt \
--resize 1440p \
--encode_method x264_animation_10bit --bit_depth 16bit
› Order: restore anime1080fixer-tensorrt → interpolate rife4.26-tensorrt 2x → upscale shufflecugan-tensorrt → resize 1440pInstall
Pick the app on Windows, or grab the prebuilt CLI for Windows x64 and Apple Silicon macOS. Neither needs Python installed. Linux runs from source.
> irm tas.nevermindnilas.dev/install.ps1 | iexFAQ
TAS Standalone if you're on Windows and want to point, click and render. TAS-AdobeEdition if you live in After Effects and want TAS inside your comp. The CLI if you script, batch on a server, run Linux or want every backend for free. All three drive the same engine, so a model or flag behaves the same everywhere.
Two reasons. Stages now run in the order you type them, so a command that typed --upscale_method before --interpolate_method now upscales first. Put the flags in the order you want the passes to run. And a few flags were removed: --interpolate_first, --resize_factor, --output_scale, --preset and the *_nelux encoders, along with GMFSS. TAS stops and names the replacement for each one, and the migration table lists them all.
If you have an RTX 20/30/40/50 card, use the CUDA + TensorRT build for the best speed, and on RTX 40/50 you also get NVIDIA Maxine frame generation. GTX 16 series works on CUDA. Recent AMD cards can run the ROCm backend on Linux, and older AMD cards plus GTX 10 series (Pascal) run on DirectML. Intel iGPUs and dGPUs run on OpenVINO. Apple Silicon runs on MPS. Pick the matching -tensorrt, -rocm, -directml, -openvino or -mps model suffix, and run --list_methods to see what your install supports. TAS Standalone detects your hardware and installs the right runtime for you.
The installer isn't code-signed yet, so SmartScreen shows "Windows protected your PC" for every new release. Choose More info, then Run anyway. Only download it from the official GitHub releases, which is where every link on this page points. It installs per user, so it never asks for admin rights.
macOS: yes, on Apple Silicon with macOS 15 or newer, through the CLI and TAS-AdobeEdition. Every release ships a prebuilt macOS-arm64 zip alongside the Windows one, and MPS accelerates interpolation, upscaling, restoration, depth and motion blur. Be aware of the gaps: segmentation, dedup, scene detection and stabilization have no MPS path and fall back to CPU, there is no TensorRT / DirectML / OpenVINO, there is no hardware video encoder, and Intel Macs are not supported. Encoding runs inside TAS, so you only need Homebrew if you feed TAS YouTube URLs: it installs FFmpeg through it for that.
Linux: runs from source with the CUDA, ROCm or lite dependency profile, but there is no prebuilt binary yet. TAS Standalone is Windows only for now.
Yes. Pass the file straight to the stage (--upscale "D:/models/4x_custom.pth") or use --custom_model. .pt, .pth, .ckpt and .safetensors load through Spandrel on the CUDA and ROCm paths, and .onnx runs on the -directml, -openvino and -tensorrt variants. Just match the backend suffix to the file format. TAS Standalone exposes the same option as a file picker on the Upscale step.
No. TAS Standalone downloads and sets up the engine on first launch, and the prebuilt Windows and macOS CLI releases bundle everything they need. You don't need FFmpeg either: every encoder runs inside TAS through Nelux, and TAS fetches FFmpeg only the first time you give it a YouTube URL. You only need Python if you're cloning the repo to develop, in which case pip install -r requirements.txt plus one of the extra-requirements-* profiles will get you going.
The CLI is. The source is on GitHub under the AGPL-3.0 license. Fork it, modify it, redistribute it, just keep any network-service derivatives open under the same license.
The two apps are free to download and closed source. TAS Standalone is free with DirectML, NCNN and CPU, and its CUDA, TensorRT, ROCm and OpenVINO backends need a $3+ sponsorship. In TAS-AdobeEdition the CUDA, TensorRT, OpenVINO, ROCm and MPS backends and the NVENC encoders need the same sponsorship.
The CLI is unpaid work. The apps' GPU backends, GitHub Sponsors and Patreon cover model training and hardware. Link your sponsor account inside TAS Standalone to unlock its GPU backends. Sponsors also get a role on the Discord: run /verify_sponsor and follow the link it gives you.
Yes. New models, backends and restoration passes land regularly, and TAS Standalone and TAS-AdobeEdition (After Effects, with Premiere Pro support in alpha) are both under active development. Follow releases on GitHub or join the Discord for nightly builds.
Desktop app, After Effects panel or free CLI. Every model, one engine.
TAS is mostly unpaid work. If it saves you render hours, support it on
GitHub Sponsors or
Patreon.
Either one unlocks the GPU backends in TAS Standalone and the sponsor role on Discord via /verify_sponsor.