Help us keep the list up to date and submit new video software here.

  Search or Browse all software by sections

Tool Description Type Rating Comment


VapourSynth is an application for video manipulation. Or a plugin. Or a library. It’s hard to tell because it has a core library written in C++ and a Python module to allow video scripts to be created. It came to be when I started thinking about alternative designs for Avisynth and most of it was written over a 3 month period. The software has been heavily inspired by Avisynth and aims to be a 21st century rewrite, taking advantage of the advancements computers have made since the late 90s. Requires Python!

Free software
File size:7.3MB
Portable version
Old versions available
Version history available

0 votes

Similar tools
Post comment

  Latest version

r33.1 (August 24, 2016)

Download sites

Visit developer's site

Download VapourSynth r33.1 (direct link)

Download VapourSynth r33.1 64-bit (direct link)

Download portable and other versions

Download VapourSynth r33.1 portable (direct link)

Download VapourSynth r33.1 portable 64-bit (direct link)

Download old versions

Download VapourSynth old versions

Supported operating systems


VapourSynth screenshot
Click to enlarge screenshot
Version history / Release notes / Changelog

R33.1 – Leaking Memory is Bad
Posted on August 24, 2016

Already a new release because I created a memory leak in filters like Invert and Binarize. Update OR DIE!

R33 – A Somewhat Experimental Release
Posted on August 23, 2016

What’s to experimental in this release you ask? Basically all the code got modified. Everywhere. To re-factor and optimize things. The most important improvements are:

8-bit and 16-bit integer and float support in all core functions where it makes sense
Many commonly used core functions were optimized (Median, Minimum, Maximum, Inflate, Deflate, Convolution)
The internal resizers can now have the active region set to achieve things like subpixel shifts
VSFS was removed and replaced by AVFS, this AVFS version works with both VapourSynth and Avisynth and has all the latest changes
The Python installation to use can now be selected in the installer
Release builds are now mostly compiled with clang-cl for improved speed
There are also a few important compatibility related changes from previous versions:

AVFS works very differently from VSFS (command line vs shell integration) but can still accomplish more or less the same thing
PlaneStats function had the MinMax property split into separate Min and Max
GenericFilters is no longer included because the core functions plus the TCanny plugin can now replace 99% of its uses
AssVapour was renamed to SubText and uses the sub namespace now

R32 – Interlaced Resizing is Evil
Posted on April 8, 2016

But we added it anyway. Seriously people, just say no to interlaced material. Or de-interlace it properly. And you should all update since a bug that caused caches to not always be automatically inserted where they should be was fixed.

Breaking changes:

Progressive material that’s encoded as interlaced (far too common) may not by default have interlaced resizing applied to it. Use core.std.SetFieldBased(clip, 0) to easily flag it as progressive before resizing.

PlaneAverage has now been removed. Use PlaneStats instead.

VSPipe outputs planar RGB in the GBR plane order now to match what other programs expect as input.

R31 – Boring Maintenance
Posted on February 3, 2016

All code is bug free until someone else tries to run it. It’s a scientific fact!

This release fixes all known resizer issues that have been discovered so far. Fortunately none of them led to image corruption, just incorrect rejection of certain conversions.

And it can’t be a release without warning about something that’s slightly changed in some way. So here comes the warning. The installer now writes the registry keys related to the 64bit version into HKLM64 which makes more sense. All the old entries will also be kept until everyone has switched to the new ones. This is in preparation of the day the 32bit VapourSynth windows version stops existing, which unfortunately won’t be anytime soon despite it being over 12 years since we got x64.

R30 – Recommended by 9 out of 10 Installer Haters
Posted on January 19, 2016

Other possible titles:

DEATH TO… Installers?
More Avisynth than Avisynth
Improvements to Reduce Seeking in Source Filters
Welcome to the glorious even numbered release of R30! A release with so many new things a single topic cannot do it justice.

The first point proves that sometimes less is more. There’s now a version for windows that doesn’t need to be installed. It’s used together with embeddable Python and allows vspipe to be used for output. It’s also possible to use the VapourSynth Editor with it by putting it in the same directory.

For those of you who still can’t live without certain Avisynth filters there are great news. Avisynth 2.6 plugins are now supported in both 32 and 64 bit builds. Note that 64 bit builds can’t use 2.5 plugins. Which isn’t a real problem since almost none exist anyway.

And finally the performance related change. This continues the work in R29 of making the time it takes to produce a single frame more consistent. Plugins can now signal that they prefer to have frames requested in sequential order, if possible, and a reasonable effort will be made to make it that way. This fixes most of the remaining possible slowdowns to in scripts because the source filter has to search too much. Note that new source filter builds are needed which will be out soon. FFMS2, d2vsource and L-SMASH works will be released with support for this in a few days… or weeks.

Of course there are some other small fixes too but they aren’t really interesting enough to list here.

Possibly breaking changes:

The resize functions have their default behavior changed to make the colorimetry arguments override the frame properties by default. Previously the frame properties would always take precedence when present. To restore the old behavior set prefer_props.

PlaneDifference is completely removed and PlaneAverage will be completely removed in R32. They’re both replaced by PlaneStats which can calculate multiple metrics at once with no speed penalty.

Posted on December 8, 2015

Today is a great day. SWScale is no longer the default resizing library included with the core. Instead the much more accurate zimg library is now the default. This means a few new resize algorithms are available and there are many new options. The change has been made to break as few scripts as possible but there is one important difference, since YUV has so many different variants, the matrix to use always has to be specified when converting to YUV and it also sometimes has to be specified when converting from YUV.

Will always work:
c = core.resize.Bilinear(c, format=vs.YUV420P8, matrix_s="709")

Will now only work if c is a YUV clip:
c = core.resize.Bilinear(c, format=vs.YUV420P8)

Likewise this will always work for YUV input:
c = core.resize.Bilinear(c, format=vs.RGB24, matrix_in_s="709")

But this will only work with YUV input if the proper matrix is set as a frame property:
c = core.resize.Bilinear(c, format=vs.RGB24)

There are also many other fixes and changes such as:

More consistent performance with many threads
Various VIVTC fixes
R28 would sometimes misdetect Python paths and fail
More specific error messages in most core filters

R28 – eControversy
Posted on October 7, 2015

What’s controversial you ask? Checking if plugins actually use the API as documented. Walls of derping on the subject were quickly created. But enough about that, now it’s time to list the new features and interesting changes.

The first thing you’ll notice is that Python 3.5 is now required instead of 3.4. This is good because it’s not bad. And I don’t have to keep an ancient compiler around anymore when developing things. Windows development only needs VS2015 now.

Other interesting changes are:

Expr is much faster because it has runtime code generation – there should be much less reason to use Lut(2) now
Expr can have 26 input clips – many instances of Lut2 and other small logic filters can now be folded into one much faster expression
Float support in PlaneAverage, imwri, Lut and Lut2 (only output in the lut filters)
“vs.get_core()” can be used everywhere in scripts – previously it would throw an error if used in script function callbacks
Much smaller installer

R27 – Revising Stuff and Things
Posted on May 13, 2015

There’s some kind of theme to this release but I’m not sure what it is. Maybe I should say it’s all about fixing past mistakes since the majority of GenericFilters got rewritten and integrated into the core. The original code quality was simply too low and there were small bugs and differences littered all over it.

Or maybe it’s about streamlining the API to have fewer odd cases to deal with. The so-called “unknown length” clips have now been deprecated and trying to return one from a filter will trigger an error. All potential uses of it can simply be replaced with one very long clip. No reason to keep unnecessary complexity around.

There’s also been a big effort put into making the frame properties mean something and for them to be used. Now most filters will automatically use the flagged field order when present, the order specified in filter arguments will only be used if no valid order is set. There’s also more color information provided so colorspace converters can automatically pick the right input format. To make this work you’ll need to update to the latest fmtconv and FFMS2 builds. The z library will probably be updated soon too.

Important Compatibility Information

The API version has been increased to 3.2 to show that unknown length clips are no longer available. This means plugins compiled against the new header won’t work with older versions.

The plugin version of GenericFilters will be removed in the next release so start changing all scripts to use the equivalent functions in the std namespace instead.

R26 – Speed!
Posted on January 28, 2015

The focus on this release is mostly speed. By switching to using tcmalloc in windows some scripts get very substantial performance gains, in some extreme cases over 200% speedup but don’t expect it in every clip. Other parts of the code were also steamlined and cleaned up for some additional minor gains.

The other highlight is as usual bugfixes, a pile of small and annoying things have been fixed and there is now full documentation of the API available. Something most open source projects don’t manage to do ever (sprinkling doxygen everywhere doesn’t count unless it’s readable).

Important script writing detail
If you write a python module with functions to be imported into another script DO NOT store the core object in global scope. This will cause odd behavior since the global scope is only evaluated once but a new core is provided every time a script is reloaded. The result is that you will have two or more cores in the same script and most likely crash or get an error.

R25 – Death to Windows XP!
Posted on November 24, 2014

The main new features this time are:

Added more missing modes to RGVS and VerticalCleaner
Saner loading of plugins with multiple dlls on windows, the directory containing the loaded plugin will now be searched as well
Includes pdb files for vapoursynth.dll to help debugging and plugin development
The possibility to chain commands together
Won’t work on XP anymore

Here’s how you can now combine commands. The clip gets passed as the first unnamed argument to the next command.


R24 – Making VSScript Sane
Posted on August 14, 2014

It’s finally time for another release with big improvements. Mostly because people tried to use VapourSynth and had opinions about it, and as a result the VSScript API has been improved to make more sense and plenty of minor odd things in the Python module have been fixed.

Release highlights:

FreezeFrames, DuplicateFrames and DeleteFrames filters added
An experimental ImageMagick reader/writer added
VSPipe can pass arguments into scripts being evaluated
The number of threads to use can be set at any time both from the API and Python
The VSScript API has been improved and now behaves more sanely in addition to reporting failure/success for more operations
An exceptional number of serious bugs fixed, most of them fortunately rare
Main compatibility issues with previous versions:

The Python module no longer adjusts arguments for filters that had them changed in R22. See the R22 release post for more details.
VSPipe has a new argument parser and slightly changed argument handling better match command line utilities in general. Short versions of arguments have also been added.

R23 – A Typical Maintenance Release
Posted on March 11, 2014

R23 is done. As usual it took a bit longer than expected since people kept finding bugs in the RC builds. There’s really nothing exciting here at all. Only a fix for a pile of crash bugs in filters and documentation errors. Non-windows users may also enjoy some of the improvements to the build system that makes it a bit less finicky.

Summary: everyone should upgrade but must look bored while doing so.

R22 – The number of bits shall be 64
Posted on December 10, 2013
Have you ever wanted to encode things in 64 bits? Now you can!

The latest release adds support for x64 windows and all native filters have x64 compiles ready as well, however Avisynth x64 plugins can’t be loaded because the moron who originally converted the Avisynth header did it in a sloppy way and forgot to make the memory offsets stored as a ptrdiff_t.

There have also been substantial changes to the core code as all use of the Qt libraries have been removed and replaced with C++11 instead. This reduces the number of dependencies and makes VapourSynth easier to compile. During this process all the locking was reviewed and every relevant function should now be thread-safe. For those of you who want to contribute to the core project there are Visual Studio 2013 projects available in the repository which makes compiling a lot easier.

Those were the major changes, here’s a list of some of the smaller improvements made:

Added the MakeDiff and MergeDiff filters (equivalent to masktool’s mt_makediff and mt_adddiff)
Arguments passed to functions with the value None are now ignored in Python — this makes it much easier to pass on filter arguments
Filter arguments in Python now accept any iterable type and not just lists — go crazy and use expressions such range(3) or (clipa, clipb) as function arguments
The usual small tweaks such as improved code examples, fps display in vspipe and rare memory leak fixes
Important Compatibility Information

Lut2, Merge and MaskedMerge now take two clip arguments instead of the original two clip array. For example:

core.std.Merge(clips=[clip1, clip2], 0.5)
Should be changed to:

core.std.Merge(clipa=clip1, clipb=clip2, 0.5)
The python module will automatically rewrite it to the new version for now to keep script compatibility. Script writers who want to test that their script works with only the new behavior can create a new core this way:


R21 – Big Improvements Again!
Posted on October 29, 2013
It’s once again time for a release. This release can mostly be described as a big bugfix one. Mostly taking care of some bugs introduced in R20 (which is no longer linked since R19 is better to use when testing if things work in a previous version). Anyway, the main new features are:

FrameEval – A nice and convenient way to do almost any per frame operation conceivable
RemoveGrain/Repair — Now ported to be native plugins
Text – A very handy function to print text for debug purposes
There are also plenty of small improvements such as error messages being printed on VFW error clips, optimizations of common functions and fixes here and there.

For R22 the long C++11 migration will start. The ultimate goal is to remove the dependency on Qt completely but that will most likely take over a year to accomplish. As a short term goal writing more filters is my priority.

lut/lut2 now processes all planes by default
ported to work on arm and powerpc (Zor)
fixed 9-16 bit format support in Expr
properly initialize color in addborders to 0
calls to the getFrame() function inside vapoursynth can never deadlock now, the thread handling is also slightly improved
fixed a bug in the cache that would stop it from freeing all its frames when memory is needed, fixes an out of memory error reported by Chikuzen
output is no longer determined by setting the last variable in __main__, instead clip.set_output(int index = 0) is used to set which clip(s) are exported
fixed some memory leaks in the internal filters when they're freed (jackoneill)
now properly initializes blankclips to all 0 when no values are given
added proper const declarations now that cython supports it, cython 0.18 or later required to build the extension now
fixed get_write_ptr() in python to actually return a write pointer
fixed the lut and lut2 filters for > 8 bit formats (ADub)
various minor fixes to vivtc
removed clip.output() since it's a bad design decision, now a command-line program called vspipe can be used to pipe or write raw video output
renamed newMap() to createMap() to match the naming of all other functions
added core.get_plugins() for the core and core.namepace.get_functions() for namespaces, it works similarly to list_functions() but instead returns the information in a dict
removed the unmentioned and unused link option for filter arguments as it is completely pointless and similar functionality may be implemented anyway
there's now a sane external api available for embedding in other applications, see vsscript.h and vsvfw for an example
now a singleton pattern is used for the core in python scripts, use vs.get_core() to get a reference to it
clip.get_frame() now throws an exception when out of bounds frames are requested
fixes a reference leak in the VideoProps python class
now ignores functions with . in their argument string for avisynth compatibility, this makes warpsharp mostly compatible

R18 – Beta Quality
Posted on January 14, 2013
I’m back on my release early and often schedule… or at least something resembling it. This is a big bug fix release and officially brings the core of VapourSynth to beta quality. Less memory will be leaked and pressing F2 in VirtualDub is no longer the fastest way to run out of address space and crash.

There are only a few more things to add and change but the goal is getting closer. Report any bug you find no matter how small it is. The focus of the next release will be on performance and I’m interested in all speed comparisons between VapourSynth and Avisynth, especially the single threaded versions.

You should also check out Chikuzen’s GenericFilters which implement almost all missing features from masktools that aren’t already present in the core. This has made it possible to port a few more scripts to be fully native.

If you’re curious about the future direction and changes go check out the bug tracker. I use it as a place to write down most planned enhancements as well and scribble a row or two about it. I have also been commissioned to make an image writer plugin based on ImageMagick so that will most likely show up before R19.

R17 – A Soft Package
Posted on December 27, 2012
It took a bit longer than I anticipated to get R17 done but it’s finally done enough. The highlights are:

User contributions! – this is the first release where several fixes and parts were contributed by other people
The new Expr filter (similar to mt_lutxyz) which can evaluate expressions per pixels during run-time
A subtitle filter based on libass (inappropriately named assvapour)
Lots of bugfixes, for example AVISource should now be usable with all formats and alpha output
Even stricter checks for filters – the ongoing work to detect common coding and API usage errors continues
With this release a few more popular scripts can be implemented using only VapourSynth filters, however the work will continue to recreate the missing common filters from masktools. I would appreciate some help in implementing equivalents to mt_edge, mt_inpand, mt_expand, mt_inflate and mt_deflate. It’s a simple project and good for someone who wants to get started writing filters and help out, I just happen to want to start with the challenging stuff. MVTools. The core part of several of the most powerful Avisynth scripts and a something that could certainly use a rewrite.

Posted in VapourSynth | Leave a reply

R16 – The Slightly Less Broken Release
Posted on November 18, 2012
R15 had a serious issue that prevented the Avisynth compatibility stuff from working with anything except YV12, this release mainly fixes it. There isn’t much else new of interest in this release.

If you need more stuff to fidget with then go try the new resizers for VapourSynth too. They will most likely replace swscale once they become stable so testing is appreciated. They’re based on the dither tools code.

Next on my own todo list is a plugin to evaluate expressions at run-time, think mt_lutxy(z) but without insane memory requirements for 16bit formats. The other thing on the list mostly is about VSFS and that is to improve error handling and adapt the code to the latest Pismo File Mount API.

Posted in VapourSynth

R15 – API Improvements
Posted on November 15, 2012
The time has come to break the API slightly to add some missing features. It also ends the alpha support discussion. The proper (and only) way to handle alpha is to return it as a separate mask clip. To make this easier filters now have a reasonably simple API to return more than one clip.

The new filters this time try to fill in some of the biggest feature holes, they are Merge, MaskedMerge and AVISource. MaskedMerge is very similar to masktool’s mt_merge in terms of functionality and the other two are very similar to the internal Avisynth filters with the same name. AVISource can of course open both VapourSynth and Avisynth scripts for import too.

There are also minor changes that need to be done to make plugins compile (binary compatibility with old plugins is however preserved). Previously the VSNodeRef type was always declared as const, this superfluous const declaration has now been removed everywhere in the API. Below are examples of the other two changes needed.

vsapi->setVideoInfo(a, b);
Change it to:
vsapi->setVideoInfo(a, 1, b);
The other construct that needs changing is filter creation which now automatically assigns itself to the out map:

cref = vsapi->createFilter(in, out, "Invert", invertInit, invertGetFrame, invertFree, fmParallel, 0, data, core);
vsapi->propSetNode(out, "clip", cref, 0);
Change it to:
vsapi->createFilter(in, out, "Invert", invertInit, invertGetFrame, invertFree, fmParallel, 0, data, core);
And don’t forget to check out my previous post with suggested tasks if you want to help out.

Posted in VapourSynth

R14 – Improved Packaging
Posted on October 30, 2012
It’s time for another release. The main highlights are bug fixes and the possibility to set the max cache size. The default max is 1GB everywhere to prevent running out of address space in 32bit applications. I’ve also decided to start bundling some potentially useful filters:

TemporalSoften – C code restored from inline asm
Histogram – with support for higher bitdepths in the default mode
VIVTC – think TIVTC but less features and portable
EEDI3 – improved to work on all 8bit formats
Since this project’s success depends a lot on good plugins being available I’ve also included all files needed to start developing in the installer. Just check out the SDK directory and the example invert filter to get started.

It’s now time for me to start spending more time porting/rewriting some useful Avisynth things…

Posted in VapourSynth

R13 – Conditional Filtering and Memory Optimizations
Posted on October 15, 2012
It’s time for another release since it’s been over a week. The new things are a redone system for accessing frame properties and this time it’s less awkward and arcane, the possibility to write a full filter in python only (if you’re clever enough to figure out how to abuse ModifyFrame) and the memory management has been enabled. This means that VapourSynth will aggressively try to keep the amount of used framebuffer memory below 1GB to avoid running out of address space.

I also added all useful internal Avisynth filters turned into a standalone plugin to the downloads. It should make the transition to VapourSynth easier while waiting for your favorite internal filter to be ported. If your favorite filter happens to be a simple one I suggest you give porting it a try yourself.

As I feel the core is almost complete now I will focus on creating more automated regression tests, documentation everything and tweaking the automatic cache size adjustment for the next release. Phase one of the project is nearing the end. After that I will focus on porting popular filters properly, as in making them work on Windows, Linux and OSX in both 32 and 64bit mode. As some of you may have noticed I’ve already ported EEDI3 and I’m currently working on TIVTC, a difficult project (but not for the right reasons) which I’ll write another post about.

Posted in VapourSynth

R12 – VapourSynth Takes a Step in The Enterprise Direction
Posted on October 5, 2012
This new version has something for everyone. It has a round of bug fixes, one of them to the threading which means that it should be able to completely max out a 4 core CPU when running mdegrain2. The other features (requested through donations) are support for v210 output, the most used 10 bit format in professional video editing. To enable this output in VSFS and VFW add this to your script:

last = yourvideo
If you do not add it the output will default to P210. The documentation will be updated later today with more detailed installation instructions for VSFS. For those of you who can’t wait the install method is very similar to AVFS (just look for vsfs.dll).

Posted in VapourSynth

R11 – VFW returns and Python 3.3
Posted on October 1, 2012
VFW has been debugged. Greatly. I’ve also added high bitdepth output support. However v210 shall be left out (I hate packed formats) unless someone contributes a patch or requests it in a donation message. VFW also has some behavioral changes such as returning a clip with colorful bars on error. This version also requires the Python 3.3 as this cuts down on the number of copies of visual studio I have to keep around.

Note that it is possible and quite easy to recompile the python and VFW modules for other versions. Maybe someone will contribute a python 2.7 compile one day.

Posted in VapourSynth

R10 – VFW enters the scene from the left
Posted on September 29, 2012
Another few days have passed and the VFW module is now ready for a first test out in reality. It supports all the same output formats as Avisynth 2.6 plus one more! (which you will probably never use) I have decided that the official extension for these virtual avi scripts should be .vpy. Think Video PYthon script to remember it. It was the best I could come up with that wasn’t used by something else as well. The VFW part has been tested with AVISource in Avisynth, MPC-HC and VirtualDub. Out of these VirtualDub is the only one that needs a small workaround since it detects the special compatibility mode based on file extension, you MUST SELECT the compat option in the FileOpen dialog or it won’t open.

Of course there’s also a bunch of other changes such an installer that comes with all the needed runtimes, the usual pile of Python module fixes and other things. Release early, Release often as the saying goes. My schedule is to try to make a new release every time I cross off something on the todo list.

I have also added a donation button. At least consider using it. Click on it once and then quickly close the window if you don’t want to donate anything. I will however never threaten to stop the project or anything else that’s close to drama if donations are low.

Posted in VapourSynth

R9 – the mostly done release
Posted on September 26, 2012
This is the big release. The new things are:

Full documentation of all the included functions
The full source released as LGPL
Fixes bugs in most of the internal filters
Adds Python + operator and slicing support to clips
Fully working on linux (and probably osx too if you want to try compiling there)
Many other small things like more fixes to y4m output
With this release I consider the API stable and the core mostly feature complete. So start writing and porting plugins!

What’s next on the todo list (in no particular order):

Write a masktools replacement (probably with asmjit)
Write a general subtitling plugin, something like AssRender for Avisynth
Figure out what to do about the horrible resizers
Write a vfw module
Make it possible to write full plugins and not just functions in Python
Document the C API and make a small example of how to write an Invert filter
Other stuff

Posted in VapourSynth

R8 – The sad interim release with some bugfixes
Posted on September 20, 2012
The title says it all, I hoped to have a bit more ready but this is at least a bit over halfway to my stated goals.

The big news is the addition of a function type. This allows some interesting things like this:

def selector1(sdict):
a = sdict['N']
a = a % 2
b = {'val':a}
# return the index of the clip to select
return b

def selector2(sdict):
# for these functions the key 'N' holds the requested frame number
# and FX corresponds to the index of the frames
frame_properties = get_props(sdict['F0'])
if frame_properties['SomeFrameProperty'] < 0.5:
return {'val':0}
return {'val':1}

# some source for clip0 and clip1 here
ret = core.std.SelectClip(clips=[clip0, clip1], src=[clip0], selector=selector1)

# ret will now return every other frame from clip0 and clip1 interleaved

# selector2 shows how frame properties can be factored into it
Posted in VapourSynth

R7 – the source is slowly coming
Posted on September 12, 2012
After almost 2 weeks of rapid improvement R7 is done. It mostly introduces more improvements for the python module, which now accepts unnamed arguments and has improved y4m output. The most important detail being the addition of a B value to the y4m header so it can signal higher bitdepths automatically too. Since it’s a minor change I hope x264, libav and other tools will adopt this property soon.

Another new thing that may interest some of you is that this build also comes with the header for developing your own plugins plus a the full source for all the functions in the std namespace (MIT licensed). I still have a few more things I want to add and revise before releasing the rest of the source to the public.

So instead of giving an vague “soon” as a release schedule for the source I will simply give you a list of things I want to finish before it goes out the door:

Decide which license to release it under. (discuss it if you want but I’m tilting towards something like free for non-commercial use, source modifications must be shared)
The addition of a function type. This is mostly for internal use as python handles callable objects well enough.
The ability to write whole filters in python. It would make quick prototyping easy and open up filter writing for more people (unfortunately python itself has one huge mutex called the GIL so if it’s used too much it could lead to serious slowdowns).
More checks, one of the most important things in my opinion is to detect errors early and report them. Especially for developers. The core already has a lot of checks in its handling of external plugins so new plugin writers will become aware of their mistakes.
Finish the standard functions. The main missing functions are Transpose, CropRel and several small ones for property manipulation and per frame selection.
Maybe I’ll reveal the long term goals next time.

Posted in VapourSynth

R2 is here
Posted on September 5, 2012
This time the release should be mostly usable for real encoding. Try it and report any crashes and avisynth plugin compatibility.

Posted in VapourSynth
Hide changelog

All features / Full description

The main features compared to Avisynth are:

Multithreaded – Frame level multithreading
Generalized Colorspaces – New Colorspaces can be specified at runtime
Per Frame Properties – Additional metadata can be attached to frames
Python Based – The scripting part is implemented as a Python module so you don’t have have to learn a special language
Support for video with format changes – Some video just can’t stick to one format or frame size VapourSynth can handle any kind of change

Sections/Browse similar tools

Alternative to VapourSynth


Guides and How to's

No guides/tutorials, submit guides here.

Notify me when software updated or report software

Email me when it has been updated    Report this tool (dead link/new version)  


Post comment
0 comments, Showing 0 to 0 comments
0 comments, Showing 0 to 0 comments

1 tool hits, Showing 1 to 1 tools
NEW SOFTWARE= New tool since your last visit
NEW VERSION= New version since your last visit
NEW COMMENT= New comment since your last visit

Type and download
NO MORE UPDATES? = The software hasn't been updated in over 2 years.
NO LONGER DEVELOPED = The software hasn't been updated in over 3 years.
RECENTLY UPDATED = The software has been updated the last 31 days.
Freeware = Free software.
Free software = Free software and also open source code.
Freeware/Ads = Free software but supported by advertising, usually with a included browser toolbar. It may be disabled when installing or after installation.
Free software/Ads = Free software and open source code but supported by advertising, usually with a included browser toolbar. It may be disabled when installing or after installation.
Trialware = Also called shareware or demo. Trial version available for download and testing with usually a time limit or limited functions.
Payware = No demo or trial available.
Portable version = A portable/standalone version is available. No installation is required.
v1.0.1 = Latest version available.
Download beta = It could be a BETA, RC(Release Candidate) and even a ALPHA version of the software.
Download (direct link) = A direct link to the software download.
Download (developer's site) = A link to the software developer site.
Download (mirror link) = A mirror link to the software download. It may not contain the latest versions.
Download old versions = Free downloads of previous versions of the program.
Download 64-bit version = If you have a 64bit operating system you can download this version.
Download portable version = Portable/Standalone version meaning that no installation is required, just extract the files to a folder and run directly.
Windows = Windows version available.
Mac OS = Mac OS version available.
Linux = Linux version available.
Our hosted tools are virus and malware scanned with several antivirus programs using

Rating from 0-10.

Browse software by sections
All In One Blu-ray Converters (12)
All In One DVD Converters (15)
All In One MKV to MP4/Blu-ray (10)
All In One Video Converters (28)
Animation (3D & 2D animation) (7)
Audio Editors (17)
Audio Encoders (68)
Audio Players (8)
Authoring (Blu-ray/AVCHD) (22)
Authoring (DivX) (5)
Authoring (DVD) (34)
Authoring (SVCD/VCD) (10)
Bitrate Calculators (7)
Blu-ray to AVI/MKV/MP4 (14)
Blu-ray to Blu-ray/AVCHD (10)
Burn (CD,DVD,Blu-ray) (22)
Camcorders/DV/HDV/AVCHD (34)
Capture (32)
CD/DVD recovery (3)
Codec Packs (7)
Codec/Video Identifiers (32)
Codecs (67)
Decrypters (Blu-ray Rippers) (8)
Decrypters (DVD Rippers) (15)
DigitalTV/DVB/HDTV (37)
DVD to AVI/DivX/XviD (18)
DVD to DVD (21)
DVD to MP4/MKV/H264 (18)
ISO/Image (16)
Linux video tools (106)
MacOS video tools (158)
Media (Blu-ray/DVD/CD) (9)
Media Center/HTPC/PS3/360 (41)
Other useful tools (114)
Photo Blu-ray/DVD/SlideShow (10)
Portable/Mobile/PSP/iPod (38)
Region free tools (5)
Screen capture/Screenshots (28)
Subtitle (58)
Video De/Multiplexers (54)
Video Editors (Advanced/NLE) (37)
Video Editors (Basic) (47)
Video Editors (H264/MP4/MKV/MTS) (18)
Video Editors (MPG/DVD) (20)
Video Editors (WMV/AVI) (15)
Video Encoders (AVI/WMV) (40)
Video Encoders (H264/H265/MP4/MKV) (46)
Video Encoders (MPG/DVD) (27)
Video Encoders / Converters (151)
Video Frameservers (8)
Video Players (34)
Video Repair/Fix (19)
Video Scripting (10)
Video Streaming (22)
Video Streaming Recording (56)
Virtualdub tools (10)
Search   Contact us   About   Advertise   Forum   RSS Feeds   Statistics   Software   

Site layout: Default Classic Blue