Hybrid(Windows/Linux/Mac): Input -> x264/x265/Xvid/VP8/VP9

[Selur]

Using:

clip = vsrvrt.Deblur(clip, device="cuda", preview_mode=True)

Vapoursynth Preview works fine here.
During encoding VRAM was at 10.5GB and ran @1.42fps.

encoded 149 frames, 1.42 fps, 8498.35 kbps, 5.02 MB
encode time 0:01:44, CPU: 0.1, GPU: 51.7, GPUClock: 2775MHz, VEClock: 2160MHz
frame type IDR   1
frame type I     1,  total size  0.08 MB
frame type P    37,  total size  0.00 MB
frame type B   111,  total size  4.95 MB

The script that was created by Hybrid:

# Imports
import vapoursynth as vs
# getting Vapoursynth core
import sys
import os
core = vs.core
# Limit frame cache to 48449MB
core.max_cache_size = 48449
# Import scripts folder
scriptPath = 'F:/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# loading plugins
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/SourceFilter/DGDecNV/DGDecodeNV_AVX2.dll")
# Import scripts
import validate
# Source: 'C:\Users\Selur\Desktop\VID_20251026_113323.mp4'
# Current color space: YUV420P8, bit depth: 8, resolution: 1920x1080, frame rate: 30.048fps, scanorder: progressive, yuv luminance scale: limited, matrix: 709, transfer: bt.709, primaries: bt.709, format: HEVC
# Loading 'C:\Users\Selur\Desktop\VID_20251026_113323.mp4' using DGSource
clip = core.dgdecodenv.DGSource("J:/tmp/mp4_6694054a41f976fc6e415da2ab1c7fab_853323747.dgi") # 30.048 fps, scanorder: progressive
frame = clip.get_frame(0)
# setting color matrix to 709.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT709)
# setting color transfer (vs.TRANSFER_BT709), if it is not set.
if validate.transferIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT709)
# setting color primaries info (to vs.PRIMARIES_BT709), if it is not set.
if validate.primariesIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT709)
# setting color range to TV (limited) range.
clip = core.std.SetFrameProps(clip=clip, _ColorRange=vs.RANGE_LIMITED)
# making sure frame rate is set to 30.048fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=3756, fpsden=125)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # scan type: progressive
# adjusting color space from YUV420P8 to RGB24 for vsRVRTFilter
clip = core.resize.Bicubic(clip=clip, format=vs.RGB24, matrix_in_s="709", range_in_s="limited", range_s="full")
# Debluring using RVRT
import vsrvrt
clip = vsrvrt.Deblur(clip, device="cuda", preview_mode=True)
# adjusting output color from RGB24 to YUV420P10 for NVEncModel
clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P10, matrix_s="709", range_in_s="full", range_s="limited", dither_type="error_diffusion") # additional resize to match target color sampling
# output
clip.set_output()

So it's not a general problem.

Cu Selur

Ps.: going to bed now, n8.

[locotus]

Okay, so it is something that LSFmod uses, so it must be zsmooth, since CAS with MSharpen works.
Ah, looking throughout my code it seems like everywhere else I made sure that zsmooth wasn't used on non-AVX2 capable systems.
=> uploaded a new dev, which should not load zsmooth, but removegrain which hopefully should fix the problem with LSFmod too.

Cu Selur
Ps.: let me know if you find other filters that crash.

Seems to be working just fine up to now, if I run into any other problem I'll let you know.
Thanks again.

[Platos]

@selur: i could use now the newest dev stuff from yesterday and it did still not work, same issue as postet above. Here is the vapoursynth code:

# Imports
import vapoursynth as vs
# getting Vapoursynth core
import sys
import os
core = vs.core
# Import scripts folder
scriptPath = 'C:/Program Files/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# loading plugins
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/SourceFilter/LSmashSource/LSMASHSource.dll")
# Import scripts
import validate
# Source: 'C:\Users\Gaming-Tower\Pictures\LocalSend\Stabilisation-Tests\Verschiedene-Stabilizer-Test\Video_3\VID_20251026_113323_VidStabGui-11frames_5degree.mp4'
# Current color space: YUV420P8, bit depth: 8, resolution: 1920x1080, frame rate: 30fps, scanorder: progressive, yuv luminance scale: limited, matrix: 709, transfer: bt.709, primaries: bt.709, format: AVC
# Loading 'C:\Users\Gaming-Tower\Pictures\LocalSend\Stabilisation-Tests\Verschiedene-Stabilizer-Test\Video_3\VID_20251026_113323_VidStabGui-11frames_5degree.mp4' using LibavSMASHSource
clip = core.lsmas.LibavSMASHSource("C:/Users/Gaming-Tower/Pictures/LocalSend/Stabilisation-Tests/Verschiedene-Stabilizer-Test/Video_3/VID_20251026_113323_VidStabGui-11frames_5degree.mp4")
frame = clip.get_frame(0)
# setting color matrix to 709.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT709)
# setting color transfer (vs.TRANSFER_BT709), if it is not set.
if validate.transferIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT709)
# setting color primaries info (to vs.PRIMARIES_BT709), if it is not set.
if validate.primariesIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT709)
# setting color range to TV (limited) range.
clip = core.std.SetFrameProps(clip=clip, _ColorRange=vs.RANGE_LIMITED)
# making sure frame rate is set to 30fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=30, fpsden=1)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # scan type: progressive
# adjusting color space from YUV420P8 to RGB24 for vsRVRTFilter
clip = core.resize.Bicubic(clip=clip, format=vs.RGB24, matrix_in_s="709", range_in_s="limited", range_s="full")
# Debluring using RVRT
import vsrvrt
clip = vsrvrt.Deblur(clip, device="cuda", preview_mode=True)
# adjusting output color from RGB24 to YUV420P10 for x265Model
clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P10, matrix_s="709", range_in_s="full", range_s="limited", dither_type="error_diffusion") # additional resize to match target color sampling
# set output frame rate to 30fps (progressive)
clip = core.std.AssumeFPS(clip=clip, fpsnum=30, fpsden=1)
# output
clip.set_output()
# script was created by Hybrid 2026.03.27.1

But: Thanks for your video: I could compare frame by frame and sadly rvrt is AI-Shit compared to original Camera-footage. It looked not good in my opinion. The denoise-video i saw in discord did good result then (i have to try that another time), but the deblur is sth i do not like. i prefer blurry over the "AI-Sharp". The blurry images looked after deblur not good and the actually "sharp" images look worse to after deblurring. But that's my opinion.

These papers on github always use sooo low resolution-examples, that you can't see any artifacts.

(I thought i could fix motion blur from camera-shaking. After stabilizeing there are some frames which are blurry because of the motion blurr from the shaky handheld. You don't know sth to fix that or make better at least without makign it look AI? I think i will open a question in another thread)

[Selur]

GRLIR and BasivVSR++ both have deblur modes, but you probably won't be happy with them either. Only other solution that comes to mind are difusion based solutions like seedvr2 or topaz starlight. (don't know about starlight, but seedvr2 is really resource hungry, so if rvrt doesn't work on your system, they might not work either)
Usually when stuff doesn't work and one gets strange errors it's down to VRAM or drivers.
Does RVRT work if you call it on SD resolution content? (just to know whether it' a general problem)

Cu Selur

[Platos]

Ok, i did now resize the video with hybrid to 480x270 pixel (and then used that video in a second encode) and it did still crash. I think when you have 10gb VRAM on 1080p is should not run out of vram with a rtx5080 16GB. It ist still the same error:

2026-03-28 14:48:23.731
C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\torch\functional.py:554: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at C:\actions-runner\_work\pytorch\pytorch\pytorch\aten\src\ATen\native\TensorShape.cpp:4316.)
return _VF.meshgrid(tensors, **kwargs) # type: ignore[attr-defined]

2026-03-28 14:48:23.806
Failed to evaluate the script:
Python exception: Ran out of input

Traceback (most recent call last):
File "src/cython/vapoursynth.pyx", line 3393, in vapoursynth._vpy_evaluate
File "src/cython/vapoursynth.pyx", line 3394, in vapoursynth._vpy_evaluate
File "C:\Users\Gaming-Tower\Documents\Hybrid\Tempfolder\tempPreviewVapoursynthFile14_48_21_643.vpy", line 38, in 
clip = vsrvrt.Deblur(clip, device="cuda", preview_mode=True)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\vsrvrt\rvrt_filter.py", line 857, in Deblur
return _create_filter_wrapper(
^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\vsrvrt\rvrt_filter.py", line 614, in _create_filter_wrapper
return _create_filter_wrapper_preview(
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\vsrvrt\rvrt_filter.py", line 429, in _create_filter_wrapper_preview
inference = RVRTInference(config, use_fp16=use_fp16, device=device_obj)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\vsrvrt\rvrt_core.py", line 53, in __init__
self.model = self._load_model()
^^^^^^^^^^^^^^^^^^
File "C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\vsrvrt\rvrt_core.py", line 143, in _load_model
checkpoint = torch.load(model_path, map_location="cpu", weights_only=False)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\torch\serialization.py", line 1549, in load
return _legacy_load(
^^^^^^^^^^^^^
File "C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\torch\serialization.py", line 1797, in _legacy_load
magic_number = pickle_module.load(f, **pickle_load_args)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
EOFError: Ran out of input

And here is the code:

# Imports
import vapoursynth as vs
# getting Vapoursynth core
import sys
import os
core = vs.core
# Import scripts folder
scriptPath = 'C:/Program Files/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# loading plugins
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/SourceFilter/LSmashSource/LSMASHSource.dll")
# Import scripts
import validate
# Source: 'C:\Users\Gaming-Tower\Pictures\LocalSend\Stabilisation-Tests\Verschiedene-Stabilizer-Test\Video_3\Eigene\VID_20251026_113323_resizetest480.mkv'
# Current color space: YUV420P10, bit depth: 10, resolution: 480x270, frame rate: 30.046fps, scanorder: progressive, yuv luminance scale: limited, matrix: 709, transfer: bt.709, primaries: bt.709, format: HEVC
# Loading 'C:\Users\Gaming-Tower\Pictures\LocalSend\Stabilisation-Tests\Verschiedene-Stabilizer-Test\Video_3\Eigene\VID_20251026_113323_resizetest480.mkvÄ using LWLibavSource
clip = core.lsmas.LWLibavSource(source="C:/Users/Gaming-Tower/Pictures/LocalSend/Stabilisation-Tests/Verschiedene-Stabilizer-Test/Video_3/Eigene/VID_20251026_113323_resizetest480.mkv", format="YUV420P10", stream_index=0, cache=0,repeat=True, prefer_hw=0)
frame = clip.get_frame(0)
# setting color matrix to 709.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT709)
# setting color transfer (vs.TRANSFER_BT709), if it is not set.
if validate.transferIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT709)
# setting color primaries info (to vs.PRIMARIES_BT709), if it is not set.
if validate.primariesIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT709)
# setting color range to TV (limited) range.
clip = core.std.SetFrameProps(clip=clip, _ColorRange=vs.RANGE_LIMITED)
# making sure frame rate is set to 30.046fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=15023, fpsden=500)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # scan type: progressive
clip = core.std.AddBorders(clip=clip, left=0, right=0, top=0, bottom=2) # add borders to archive mod 8 (vsRVRTFilter) - 480x272
# adjusting color space from YUV420P10 to RGBS for vsRVRTFilter
clip = core.resize.Bicubic(clip=clip, format=vs.RGBS, matrix_in_s="709", range_in_s="limited", range_s="full", dither_type="error_diffusion")
# Debluring using RVRT
import vsrvrt
clip = vsrvrt.Deblur(clip, device="cuda", preview_mode=True)
clip = core.std.Crop(clip=clip, left=0, right=0, top=0, bottom=2) # removing added borders from mod requirement (vsRVRTFilter) -  480x270
# adjusting output color from RGBS to YUV420P10 for x265Model
clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P10, matrix_s="709", range_in_s="full", range_s="limited") # additional resize to match target color sampling
# output
clip.set_output()
# script was created by Hybrid 2026.03.27.1

And i uploaded also the error-picture. DO you also need a debug ? Hybrid gui says Hybrid 2026.03.27.1 and i did download yesterday the vapoursynth and vsmlrt experimental version from your server and install everything (overwrite-copy).

[Selur]

Can't reproduce, filter is too new to know much about it. Could be something interfering,..
No clue, maybe the author of the filter has an idea.

[Platos]

When i use VSMLRT with TorchRIFE with "TensorRT" enabled, i get a crash (It works with RIFEmlrt TensorRT RTX):

# Imports
import vapoursynth as vs
# getting Vapoursynth core
import site
import logging
import sys
import os
core = vs.core
# Import scripts folder
scriptPath = 'C:/Program Files/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# Force logging to std:err
logging.StreamHandler(sys.stderr)
os.environ["CUDA_MODULE_LOADING"] = "LAZY"
# loading plugins
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/Support/vszip.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vs-mlrt/vstrt_rtx.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vs-mlrt/vstrt.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vs-mlrt/vsort.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/Support/fmtconv.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/MiscFilter/MiscFilters/MiscFilters.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/SourceFilter/LSmashSource/LSMASHSource.dll")
# Import scripts
from importlib.machinery import SourceFileLoader
vsmlrt = SourceFileLoader('vsmlrt', 'C:/Program Files/Hybrid/64bit/vs-mlrt/vsmlrt.py').load_module()
from vsmlrt import Backend
import validate
# Source: 'C:\Filme-Serien-Dokus&Animes\Encoding-Filter_Tests\[Animes]\Berserk 1997\Berserk - E01_Mutaito-Remux_Kurz2.mkv'
# Current color space: YUV420P10, bit depth: 10, resolution: 1440x1080, frame rate: 23.976fps, scanorder: progressive, yuv luminance scale: limited, matrix: 709, format: AVC
# Loading 'C:\Filme-Serien-Dokus&Animes\Encoding-Filter_Tests\[Animes]\Berserk 1997\Berserk - E01_Mutaito-Remux_Kurz2.mkvÄ using LWLibavSource
clip = core.lsmas.LWLibavSource(source="C:/Filme-Serien-Dokus&Animes/Encoding-Filter_Tests/[Animes]/Berserk 1997/Berserk - E01_Mutaito-Remux_Kurz2.mkv", format="YUV420P10", stream_index=0, cache=0, fpsnum=24000, fpsden=1001)
frame = clip.get_frame(0)
# setting color matrix to 709.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT709)
# setting color transfer (vs.TRANSFER_BT709), if it is not set.
if validate.transferIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT709)
# setting color primaries info (to vs.PRIMARIES_BT709), if it is not set.
if validate.primariesIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT709)
# setting color range to TV (limited) range.
clip = core.std.SetFrameProps(clip=clip, _ColorRange=vs.RANGE_LIMITED)
# making sure frame rate is set to 23.976fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=24000, fpsden=1001)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # scan type: progressive
from vsrife import rife
# adjusting color space from YUV420P10 to RGBS for vsTorchRIFE
clip = core.resize.Bicubic(clip=clip, format=vs.RGBS, matrix_in_s="709", range_in_s="limited", range_s="full", dither_type="error_diffusion")
# adjusting frame count&rate with RIFE (torch)
clip = rife(clip, trt=True, trt_cache_dir="C:/Users/Gaming-Tower/Documents/Hybrid/Engine-Files", fps_num=60, fps_den=1, sc=True, sc_threshold=0.070) # new fps: 60
# resizing using VSMLRT, target: 2880x2160
clip = vsmlrt.inference([clip],network_path="C:/Program Files/Hybrid/64bit/onnx_models/2x_Ani4Kv2_G6i2_Compact_107500_fp32.onnx", backend=Backend.TRT_RTX(fp16=False,device_id=0,num_streams=3,verbose=True,use_cuda_graph=False,workspace=1073741824,builder_optimization_level=3,engine_folder="C:/Users/Gaming-Tower/Documents/Hybrid/Engine-Files")) # 2880x2160
# making sure 0-1 limits are respected
clip = core.vszip.Limiter(clip=clip, min=[0,0,0], max=[1,1,1])
# adjusting output color from RGBS to YUV420P10 for x265Model
clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P10, matrix_s="709", range_in_s="full", range_s="limited") # additional resize to match target color sampling
# set output frame rate to 60fps (progressive)
clip = core.std.AssumeFPS(clip=clip, fpsnum=60, fpsden=1)
# output
clip.set_output()
# script was created by Hybrid 2026.03.27.1

And:

# Imports
import vapoursynth as vs
# getting Vapoursynth core
import site
import logging
import sys
import os
core = vs.core
# Import scripts folder
scriptPath = 'C:/Program Files/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# Force logging to std:err
logging.StreamHandler(sys.stderr)
os.environ["CUDA_MODULE_LOADING"] = "LAZY"
# loading plugins
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/Support/vszip.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vs-mlrt/vstrt_rtx.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vs-mlrt/vstrt.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vs-mlrt/vsort.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/Support/fmtconv.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/MiscFilter/MiscFilters/MiscFilters.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/SourceFilter/LSmashSource/LSMASHSource.dll")
# Import scripts
from importlib.machinery import SourceFileLoader
vsmlrt = SourceFileLoader('vsmlrt', 'C:/Program Files/Hybrid/64bit/vs-mlrt/vsmlrt.py').load_module()
from vsmlrt import Backend
import validate
# Source: 'C:\Filme-Serien-Dokus&Animes\Encoding-Filter_Tests\[Animes]\Berserk 1997\Berserk - E01_Mutaito-Remux_Kurz2.mkv'
# Current color space: YUV420P10, bit depth: 10, resolution: 1440x1080, frame rate: 23.976fps, scanorder: progressive, yuv luminance scale: limited, matrix: 709, format: AVC
# Loading 'C:\Filme-Serien-Dokus&Animes\Encoding-Filter_Tests\[Animes]\Berserk 1997\Berserk - E01_Mutaito-Remux_Kurz2.mkvÄ using LWLibavSource
clip = core.lsmas.LWLibavSource(source="C:/Filme-Serien-Dokus&Animes/Encoding-Filter_Tests/[Animes]/Berserk 1997/Berserk - E01_Mutaito-Remux_Kurz2.mkv", format="YUV420P10", stream_index=0, cache=0, fpsnum=24000, fpsden=1001)
frame = clip.get_frame(0)
# setting color matrix to 709.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT709)
# setting color transfer (vs.TRANSFER_BT709), if it is not set.
if validate.transferIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT709)
# setting color primaries info (to vs.PRIMARIES_BT709), if it is not set.
if validate.primariesIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT709)
# setting color range to TV (limited) range.
clip = core.std.SetFrameProps(clip=clip, _ColorRange=vs.RANGE_LIMITED)
# making sure frame rate is set to 23.976fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=24000, fpsden=1001)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # scan type: progressive
from vsrife import rife
# adjusting color space from YUV420P10 to RGBS for vsTorchRIFE
clip = core.resize.Bicubic(clip=clip, format=vs.RGBS, matrix_in_s="709", range_in_s="limited", range_s="full", dither_type="error_diffusion")
# adjusting frame count&rate with RIFE (torch)
clip = rife(clip, trt=True, trt_cache_dir="C:/Users/Gaming-Tower/Documents/Hybrid/Engine-Files", fps_num=60, fps_den=1, sc=True, sc_threshold=0.070) # new fps: 60
# resizing using VSMLRT, target: 2880x2160
clip = vsmlrt.inference([clip],network_path="C:/Program Files/Hybrid/64bit/onnx_models/2x_Ani4Kv2_G6i2_Compact_107500_fp32.onnx", backend=Backend.TRT_RTX(fp16=False,device_id=0,num_streams=3,verbose=True,use_cuda_graph=False,workspace=1073741824,builder_optimization_level=3,engine_folder="C:/Users/Gaming-Tower/Documents/Hybrid/Engine-Files")) # 2880x2160
# making sure 0-1 limits are respected
clip = core.vszip.Limiter(clip=clip, min=[0,0,0], max=[1,1,1])
# adjusting output color from RGBS to YUV420P10 for x265Model
clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P10, matrix_s="709", range_in_s="full", range_s="limited") # additional resize to match target color sampling
# set output frame rate to 60fps (progressive)
clip = core.std.AssumeFPS(clip=clip, fpsnum=60, fpsden=1)
# output
clip.set_output()
# script was created by Hybrid 2026.03.27.1

And i uploaded the error-window-message:

[Selur]

Sadly, afaik there is nothing I can do about it.
You can try, the latest dev with the latest vs-mlrt addon and if that does not work, you can report the problem to https://github.com/AmusementClub/vs-mlrt/
But the truth is not all models work with every method, setting and driver combination.

Cu Selur

[Platos]

Ah ok, still thanks for the answer. Then i use mlrtRIFE instead of torchRIFE, then it works.

[Platos]

Is it possible to downscale a video from 2160p to 1080p before i use vsmlrt Resizer for a 2x Upscale ? i did not find out how to do that. With Filter Queque i can't do it i guess. I feel like in past i could do that, but im not sure.

[Selur]

With the latest dev, 'Lower resolution before resize' is under 'Filtering->Vapoursynth->Resizer', in older versions the option was under 'Filtering->Vapoursynth->Misc->Script'. (this is possible since 2023.12.02.1)

Cu selur

[Platos]

Thank you very much! It works with the new dev version. I will also try lower Resolution after resize with a custom cript. That's also interesting.

Can i Insert Custom Scripts after sth? like after resize to make it downsize after the resize?

[Selur]

Sure, if you resize inside a custom script you need to let Hybrid know what the new resolution is. (see tool-tip of 'Insert before')

[Platos]

Ok, thanks. Would you use spline 36, 64 or lanczos for downsize 2x in terms of best quality? Because on the new dev you use spline64 for upscaling (as always) but on the downscale-checkbox lanczos is standart. is lanczos better for downscaling ?

Edit: I realisze downscaling after Upscaling is useless. i can use just the "crop/resize" for that, because i saw in the vapoursynth-code-preview, that it does upscale anyway. I thought it would not do that, when i use same resolution there, as the input.

[Selur]

Usually I would use Bilinear or Bicubic for down scaling, since I only use this when I try to get to a native resolution.
If it's about retaining info, I would use DPID, maybe a spline resizer.
Lanczos is more for upscaling, and even then I don't really like it.

[Platos]

Ok, thank you.

[Platos]

Did you ever saw this?: https://github.com/pifroggi/vs_temporalfix#benchmarks

it is like 10x faster than classical temporalfix on the cpu and he says its better quality. would that be easy to implement in hybrid ?

[Selur]

It's already supported in the dev version.

[Platos]

Ahh, yes, you mean the "torch"-checkbox. Thank you, did not see it.

[Platos]

I got an error with using only Temporalfix with Torch enabled and Tensorrt or Cuda Backend (no other filter):

2026-04-25 15:12:28.641
Failed to evaluate the script:
Python exception: module 'vs_temporalfix' has no attribute 'model'

Traceback (most recent call last):
File "vapoursynth.pyx", line 3524, in vapoursynth._vpy_evaluate
File "vapoursynth.pyx", line 3525, in vapoursynth._vpy_evaluate
File "C:\Users\Gaming-Tower\Documents\Hybrid\Tempfolder\tempPreviewVapoursynthFile15_12_27_933.vpy", line 48, in 
clip = vs_temporalfix.model(clip, strength=1, backend="tensorrt", engine_folder="C:/Users/Gaming-Tower/Documents/Hybrid/Engine-Files")
^^^^^^^^^^^^^^^^^^^^
AttributeError: module 'vs_temporalfix' has no attribute 'model'

That's the VapourSynth-Preview-Message above the error:

# Imports
import logging
import sys
import os
import vapoursynth as vs
# getting Vapoursynth core
core = vs.core
# Import scripts folder
scriptPath = 'C:/Program Files/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# Force logging to std:err
logging.StreamHandler(sys.stderr)
# loading plugins
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/Support/fmtconv.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vs-mlrt/vstrt.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/SourceFilter/LSmashSource/LSMASHSource.dll")
# Import scripts
import vs_temporalfix
import validate
# Source: 'C:\Users\Gaming-Tower\Downloads\$Filme-Serien-Animes&Dokus$\Star Wars The Clone Wars 2008 S01 German DL EAC3 1080p DSNP WEB H264-ZeroTwo\test.mkv'
# Current color space: YUV420P8, bit depth: 8, resolution: 1920x1080, frame rate: 23.976fps, scanorder: progressive, yuv luminance scale: limited, matrix: 709, transfer: bt.709, primaries: bt.709, format: AVC
# Loading 'C:\Users\Gaming-Tower\Downloads\$Filme-Serien-Animes&Dokus$\Star Wars The Clone Wars 2008 S01 German DL EAC3 1080p DSNP WEB H264-ZeroTwo\test.mkvÄ using LWLibavSource
clip = core.lsmas.LWLibavSource(source="C:/Users/Gaming-Tower/Downloads/$Filme-Serien-Animes&Dokus$/Star Wars The Clone Wars 2008 S01 German DL EAC3 1080p DSNP WEB H264-ZeroTwo/test.mkv", format="YUV420P8", stream_index=0, cache=0, prefer_hw=0)
frame = clip.get_frame(0)
# setting color matrix to 709.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT709)
# setting color transfer (vs.TRANSFER_BT709), if it is not set.
if validate.transferIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT709)
# setting color primaries info (to vs.PRIMARIES_BT709), if it is not set.
if validate.primariesIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT709)
# setting color range to TV (limited) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_LIMITED})
# making sure frame rate is set to 23.976fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=24000, fpsden=1001)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # scan type: progressive
# changing range from limited to full range for vsTemporalfix
clip = core.resize.Bicubic(clip, format=vs.YUV420P8, range_in_s="limited", range_s="full")
# setting color range to PC (full) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_FULL})
# adjusting color space from YUV420P8 to RGBH for vsTemporalfix
clip = core.resize.Bicubic(clip=clip, format=vs.RGBH, matrix_in_s="709", range_in_s="full", range_s="full")
# stabilizing using Temporalfix (Torch)
clip = vs_temporalfix.model(clip, strength=1, backend="tensorrt", engine_folder="C:/Users/Gaming-Tower/Documents/Hybrid/Engine-Files")
# adjusting output color from RGBH to YUV420P10 for x265Model
clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P10, matrix_s="709", range_in_s="full", range_s="full", dither_type="error_diffusion") # additional resize to match target color sampling
# changing range from full to limited range for to match intended output luma scale
clip = core.resize.Bicubic(clip, format=vs.YUV420P10,range_in_s="full", range_s="limited")
# setting color range to TV (limited) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_LIMITED})
# set output frame rate to 23.976fps (progressive)
clip = core.std.AssumeFPS(clip=clip, fpsnum=24000, fpsden=1001)
# output
clip.set_output()
# script was created by Hybrid 2026.04.24.1

Thats the Script preview:

# Imports
import logging
import sys
import os
import vapoursynth as vs
# getting Vapoursynth core
core = vs.core
# Import scripts folder
scriptPath = 'C:/Program Files/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# Force logging to std:err
logging.StreamHandler(sys.stderr)
# loading plugins
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/Support/fmtconv.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vs-mlrt/vstrt.dll")
core.std.LoadPlugin(path="C:/Program Files/Hybrid/64bit/vsfilters/SourceFilter/LSmashSource/LSMASHSource.dll")
# Import scripts
import vs_temporalfix
import validate
# Source: 'C:\Users\Gaming-Tower\Downloads\$Filme-Serien-Animes&Dokus$\Star Wars The Clone Wars 2008 S01 German DL EAC3 1080p DSNP WEB H264-ZeroTwo\test.mkv'
# Current color space: YUV420P8, bit depth: 8, resolution: 1920x1080, frame rate: 23.976fps, scanorder: progressive, yuv luminance scale: limited, matrix: 709, transfer: bt.709, primaries: bt.709, format: AVC
# Loading 'C:\Users\Gaming-Tower\Downloads\$Filme-Serien-Animes&Dokus$\Star Wars The Clone Wars 2008 S01 German DL EAC3 1080p DSNP WEB H264-ZeroTwo\test.mkvÄ using LWLibavSource
clip = core.lsmas.LWLibavSource(source="C:/Users/Gaming-Tower/Downloads/$Filme-Serien-Animes&Dokus$/Star Wars The Clone Wars 2008 S01 German DL EAC3 1080p DSNP WEB H264-ZeroTwo/test.mkv", format="YUV420P8", stream_index=0, cache=0, prefer_hw=0)
frame = clip.get_frame(0)
# setting color matrix to 709.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT709)
# setting color transfer (vs.TRANSFER_BT709), if it is not set.
if validate.transferIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT709)
# setting color primaries info (to vs.PRIMARIES_BT709), if it is not set.
if validate.primariesIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT709)
# setting color range to TV (limited) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_LIMITED})
# making sure frame rate is set to 23.976fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=24000, fpsden=1001)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # scan type: progressive
# changing range from limited to full range for vsTemporalfix
clip = core.resize.Bicubic(clip, format=vs.YUV420P8, range_in_s="limited", range_s="full")
# setting color range to PC (full) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_FULL})
# adjusting color space from YUV420P8 to RGBH for vsTemporalfix
clip = core.resize.Bicubic(clip=clip, format=vs.RGBH, matrix_in_s="709", range_in_s="full", range_s="full")
# stabilizing using Temporalfix (Torch)
clip = vs_temporalfix.model(clip, strength=1, backend="tensorrt", engine_folder="C:/Users/Gaming-Tower/Documents/Hybrid/Engine-Files")
# adjusting output color from RGBH to YUV420P10 for x265Model
clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P10, matrix_s="709", range_in_s="full", range_s="full", dither_type="error_diffusion") # additional resize to match target color sampling
# changing range from full to limited range for to match intended output luma scale
clip = core.resize.Bicubic(clip, format=vs.YUV420P10,range_in_s="full", range_s="limited")
# setting color range to TV (limited) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_LIMITED})
# set output frame rate to 23.976fps (progressive)
clip = core.std.AssumeFPS(clip=clip, fpsnum=24000, fpsden=1001)
# output
clip.set_output()
# script was created by Hybrid 2026.04.24.1

Is this an error in hybrid or the plugin itself ?

[Selur]

(works fine here)
Did you use the latest torch-add-on too?
(you need to delete the Vapoursynth folder and replace it,..)

[Platos]

No, but i did it now (Delete and fresh copy the VapoursynthR74_Torch_2026.04.21) into 64bit (so the "Vapoursynth" folder, not the one with the date). It does give me still the error.

Edit: I did use the newest Torch before already, but i meant i did not delete and freshcopy, i did overwrite. But now i did delete and fresh copy, but still the same error.

[Selur]

Can you check your "Hybrid\64bit\Vapoursynth\Lib\site-packages" folder?
There should be a "vs_temporalfix-X.X.X.dist-info"-folder which should be "vs_temporalfix-2.1.0.dist-info" if everthing is up-to-date.
Which is the current version, which comes within VapoursynthR74_torch_2026.04.21 (<- which is the current torch for the dev version),...
The code generated here:

# Imports
import logging
import sys
import os
import vapoursynth as vs
# getting Vapoursynth core
core = vs.core
# Limit frame cache to 48449MB
core.max_cache_size = 48449
# Import scripts folder
scriptPath = 'F:/Hybrid/64bit/vsscripts'
sys.path.insert(0, os.path.abspath(scriptPath))
# Force logging to std:err
logging.StreamHandler(sys.stderr)
# loading plugins
core.std.LoadPlugin(path="F:/Hybrid/64bit/vs-mlrt/vstrt.dll")
core.std.LoadPlugin(path="F:/Hybrid/64bit/vsfilters/SourceFilter/BestSource/BestSource.dll")
# Import scripts
import vs_temporalfix
import validate
# Source: 'G:\TestClips&Co\files\test.avi'
# Current color space: YUV420P8, bit depth: 8, resolution: 640x352, frame rate: 25fps, scanorder: progressive, yuv luminance scale: limited, matrix: 470bg, format: MPEG-4 Visual
# Loading 'G:\TestClips&Co\files\test.avi' using BestSource
clip = core.bs.VideoSource(source="G:/TestClips&Co/files/test.avi", cachepath="J:/tmp/test_bestSource", track=0, hwdevice="opencl")
frame = clip.get_frame(0)
# setting color matrix to 470bg.
clip = core.std.SetFrameProps(clip, _Matrix=vs.MATRIX_BT470_BG)
# setting color transfer (vs.TRANSFER_BT601), if it is not set.
if validate.transferIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Transfer=vs.TRANSFER_BT601)
# setting color primaries info (to vs.PRIMARIES_BT470_BG), if it is not set.
if validate.primariesIsInvalid(clip):
  clip = core.std.SetFrameProps(clip=clip, _Primaries=vs.PRIMARIES_BT470_BG)
# setting color range to TV (limited) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_LIMITED})
# making sure frame rate is set to 25fps
clip = core.std.AssumeFPS(clip=clip, fpsnum=25, fpsden=1)
# making sure the detected scan type is set (detected: progressive)
clip = core.std.SetFrameProps(clip=clip, _FieldBased=vs.FIELD_PROGRESSIVE) # scan type: progressive
# changing range from limited to full range for vsTemporalfix
clip = core.resize.Bicubic(clip, format=vs.YUV420P8, range_in_s="limited", range_s="full")
# setting color range to PC (full) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_FULL})
# adjusting color space from YUV420P8 to RGBH for vsTemporalfix
clip = core.resize.Bicubic(clip=clip, format=vs.RGBH, matrix_in_s="470bg", range_in_s="full", range_s="full")
# stabilizing using Temporalfix (Torch)
clip = vs_temporalfix.model(clip, backend="tensorrt", engine_folder="J:/TRT")
# adjusting output color from RGBH to YUV420P10 for NVEncModel
clip = core.resize.Bicubic(clip=clip, format=vs.YUV420P10, matrix_s="470bg", range_in_s="full", range_s="full", dither_type="error_diffusion") # additional resize to match target color sampling
# changing range from full to limited range for to match intended output luma scale
clip = core.resize.Bicubic(clip, format=vs.YUV420P10,range_in_s="full", range_s="limited")
# setting color range to TV (limited) range.
prop_name = '_Range' if core.core_version.release_major >= 74 else '_ColorRange'
clip = core.std.SetFrameProps(clip=clip, **{prop_name: vs.RANGE_LIMITED})
# set output frame rate to 25fps (progressive)
clip = core.std.AssumeFPS(clip=clip, fpsnum=25, fpsden=1)
# output
clip.set_output()
# script was created by Hybrid 2026.04.24.1

uses:

clip = vs_temporalfix.model(clip, backend="tensorrt", engine_folder="J:/TRT")

(also works fine with different models)
Which works fine.

Cu Selur

[Platos]

Yes, i have this folder: "C:\Program Files\Hybrid\64bit\Vapoursynth\Lib\site-packages\vs_temporalfix-2.1.0.dist-info"

[Selur]

Then I don't get the error:

AttributeError: module 'vs_temporalfix' has no attribute 'model'

since model should exits in Hybrid\64bit\Vapoursynth\Lib\site-packages\vs_temporalfix

__init__.py contains:

from .temporalfix_model import model
from .temporalfix_classic import classic

so vs_temporalfix.classic calls the old version and vs_temporalfix.model the new version.

[Platos]

i have two folders. One is vs_temporalfix and one is vs_temporalfix-2.1.0.dist-info. The _init_.py does contain that, but it is only found in the vs_temporalfix folder. The 2.1.0 folder does not contain it. The vs_temporalfix folder does also contain 3 .pth models and 3 .onnx models and one .py file and pycache folder.

Is it normal, that the vs_temporalfix-2.1.0.dist-info folder does not contain any of these stuff ?

[Selur]

yes, that is normal.

[Selur]

I got an idea:
Did you install the Hybrid dev by simply overwriting an existing version?
Then your vsscripts folder might contain scripts from the old and new version, and instead of having a just having a vs_temporalfix_classic.py and a
vs_temporalfix_utils.py in your vsscripts folder, you might also have a vs_temporalfix.py which should not be there and would be loaded instead of the new version.
=> Uninstall Hybrid, and reinstall the dev version.

Cu Selur

[Platos]

Yes, i closed hybrid and just executed the .exe file of your dev. Should i do that in an other way ?

Maybe then i should reinstall completly. When i save the "hybrid" folder in AppData\Roaming, i can restore all my settings in hybrid, right ?

[Selur]

You don't have to remove the settings during deinstallation, but you should deinstall the previous version before installing a dev version.