简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is AviSynth?
AviSynth is a free, open-source frameserver for video post-production. Instead of exporting intermediate files, you write a text script that tells it how to read, edit, and process video, and other applications can then open that script as if it were a video file. It is licensed under GPLv2 and has no graphical interface of its own; the script is the interface. That makes it precise and reproducible, but it also means a learning curve.
How it works
- You write a script in a simple scripting language, chaining filters and operations.
- AviSynth serves frames on demand to a compatible video application, so edits are applied live rather than baked into a new file.
- Because scripts are plain text, projects are self-documenting and easy to reuse or version.
Who it suits
- Editors who need consistent, repeatable processing across many clips.
- Users comfortable with text-based tools who want fine control over filters.
- Anyone who wants to avoid large temporary files during editing.
Trade-offs
- No built-in GUI: you need a separate editor or host application to view and encode the result.
- Scripting is less intuitive at first than a drag-and-drop editor, though the payoff is precision and speed.
If you are new, start with the wiki's beginner guide and the "Your first script" walkthrough, then try a minimal script that loads a clip and applies one filter before adding complexity. The Avisynth wiki hosts those guides along with the FAQ, filter references, and download links for current and older builds.
How do I write my first AviSynth script?
Start with a short script that loads a video and applies one simple filter. AviSynth is a frameserver: your script is a plain text file that describes the processing, and an application that supports AviSynth reads the result as if it were a video file. There is no GUI, so the script is the project.
A typical first script has three parts:
- Load the source. Use a source filter such as
AviSourcefor AVI files orFFVideoSource/LWLibavVideoSourcefor formats like MP4/MKV (these come from external plugins, not the core install). - Do something. Apply a basic internal filter, for example
Trim,Crop, orResize. - Return the clip. The last expression in the script is what the host application sees.
Example:
video = AviSource("C:\clips\holiday.avi")
video = Trim(video, 0, 300)
video = Crop(video, 0, 0, -0, -0)
return video
Trim(video, 0, 300) keeps only the first 301 frames; remove that line if you want the whole clip. Crop with zero values does nothing — replace the numbers with the pixels you want to cut from each side. The return line is optional when the final expression is the clip, but it makes the script clearer.
Testing it
Save the file with an .avs extension, then open it in a program that accepts AviSynth scripts, such as a media player or an encoder that supports AviSynth input. If the player shows your trimmed clip, the script works. If it errors, the message usually names the failing line, which is the fastest way to find a typo in a filter name or a missing plugin.
Practical notes
- Paths and quotes. Use quotes around file paths, and double backslashes or forward slashes in Windows paths.
- Filter order matters. Resizing before cropping, or cropping after resizing, changes both the result and the speed. For a first script, crop first, then resize.
- Plugins extend the language. Core AviSynth includes many internal filters, but common source and encoding formats need external filters. Install the plugin, then call it like any other filter.
- Scripts are self-documenting. Because the text is readable, you can add comments with
#and keep the file with the project.
For exact filter syntax and the full list of internal filters, the Avisynth wiki is the reference to keep open while writing. Its "Your first script" and "Getting started" pages walk through the same steps with more examples, and the "Filter introduction" page explains what each common filter does. If you get stuck on a specific error, the wiki's FAQ and troubleshooting pages are the next place to look.
How does AviSynth frameserving improve video editing workflow?
AviSynth improves a video editing workflow mainly by separating editing decisions from rendering. It acts as a frameserver: instead of exporting intermediate video files, it feeds processed frames directly to another application. The source video stays on disk as-is, and the script describes what should happen to each frame as it is requested.
Why this helps
- No intermediate files. Traditional editing often requires exporting a lossless or near-lossless file after each stage, which consumes disk space and time. A frameserver skips that step until a final encode is actually needed.
- Reproducible, text-based projects. Because the edit is a script, it is human-readable and self-documenting. You can version it, share it, or revisit it months later and see exactly what was done.
- Precise, non-linear control. The script system allows complex chains of filters and edits without a GUI. This is useful when you need consistent, repeatable processing across many clips.
- Instant editing. Changes to the script are reflected when the frames are next requested, so you can preview and adjust without re-exporting the whole timeline.
A practical scenario
Suppose you have several source clips that need deinterlacing, cropping, color correction, and a logo overlay before editing in a separate NLE or encoder. Instead of rendering each clip through those steps, you write one AviSynth script per clip (or one combined script) and open the script directly in the downstream application. The application sees a normal video source, but every frame is generated on demand by AviSynth.
Trade-offs to weigh
| Consideration | What it means in practice |
|---|---|
| No built-in GUI | You work in a text editor and must learn scripting syntax. |
| Learning curve | Simple scripts are easy, but complex filter chains take practice. |
| Debugging | Errors appear as script messages rather than visual timeline cues. |
| Performance | Frameserving avoids temporary files but still uses CPU for filtering. |
For a beginner, the fastest way to judge the workflow is to follow the wiki's "Your first script" and "Getting started" guides, then open that script in a compatible application to see the frameserved result. If you prefer visual timeline editing and rarely repeat the same processing chain, a conventional NLE may feel more direct. If you value consistency, automation, and avoiding intermediate renders, AviSynth's approach is likely to save time. The Avisynth wiki is the natural starting point for syntax and filter references.
What filters are available in AviSynth and how do I use them?
AviSynth's filters are organized into two main groups on the wiki: internal filters that ship with the application, and external filters that you download separately and load into your script. Both are called the same way — by name, with named or positional arguments — so once you understand the calling convention, the catalog is mostly a matter of looking up the right filter for the job.
Internal vs. external filters
| Internal filters | External filters | |
|---|---|---|
| Where they come from | Included with AviSynth | Separate plugin files you download |
| How they load | Available automatically | Must be loaded, typically with LoadPlugin or an autoload folder |
| Typical uses | Source loading, resizing, cropping, color adjustment, frame-rate conversion, basic denoising and sharpening | Specialized denoising, advanced deinterlacing, encoding helpers, format-specific work |
| Trade-off | Stable and always present, but limited in scope | Much broader capability, but you manage versions, bit depth and architecture yourself |
How you actually use a filter
Filters are chained: each one takes a clip and returns a clip, so the output of one line becomes the input of the next. A simple script reads as a sequence of operations — load a source, trim it, resize it, then hand it to an encoder or a frameserving host. Arguments can be given by position or by name; naming them makes longer scripts far easier to read and to debug.
Practical habits that save time:
- Keep one operation per line. When something breaks, you can comment out a single line instead of untangling a nested expression.
- Check the filter's parameter list on the wiki before guessing. Many filters have sensible defaults but a few require explicit arguments, especially anything involving color space or pixel format.
- Watch the pixel format. A filter written for 8-bit YUV may refuse to run on a 16-bit or RGB clip; insert a conversion filter rather than assuming it will work.
- Preview before committing. Because AviSynth is a frameserver, you can scrub the script in a compatible player or editor and see the result instantly, with no intermediate files written.
A concrete starting scenario
Suppose you have a noisy DVD source you want to clean up and encode. You would load the source with an internal source filter, trim to the section you care about, apply a deinterlacing filter if the material is interlaced, then apply an external denoiser, and finally resize to your target resolution. Each step is one line, and if the denoiser produces artifacts you remove that single line and try a different one — the rest of the chain is untouched.
Where to go next
Start with the wiki's own beginner path: the first-script guide and the filter introduction, then the script examples page, which shows how filters are combined in real projects. The FAQ and troubleshooting pages cover the common failure modes — missing plugins, wrong color space, filters that silently do nothing. For the full catalog, browse the internal filters and external filters indexes side by side, since a task you assume needs a plugin is sometimes handled by a built-in filter.
The wiki itself is community-maintained and hosted independently; if you rely on it regularly, the main page notes that donations keep it online. Related discussion and plugin announcements tend to happen on the Doom9 forum, and the AviSynth+ project has its own homepage and release pages linked from the wiki.
Why does AviSynth not have a GUI and what tools can I use with it?
AviSynth deliberately has no graphical interface: it is a frameserver, not an editor. You describe the edit in a text script, and AviSynth serves the processed frames to whatever program asks for them, without writing temporary files in between. The trade-off is a learning curve in exchange for precision and reproducibility — a script is human-readable, so a project documents itself and produces the same result every time you run it. The wiki frames this as a deliberate design choice rather than a missing feature, and points to the script system as the way advanced non-linear editing is done.
In practice, that means you pair AviSynth with two kinds of tools.
- A host application that opens the script as if it were a video file. Encoding, playback and authoring programs that accept AviSynth input do the GUI-side work: you scrub, set encoder options, and export, while AviSynth feeds frames. The wiki's "More information" section addresses exactly this — which applications work well with AviSynth.
- A script editor or plain text editor. Since the "interface" is the script, your editor is where the real work happens; the wiki's getting-started, grammar and filter-introduction pages are the manual for that environment.
A concrete reader scenario: you have a batch of clips that all need the same deinterlace, crop, resize and colour correction. In a GUI you would repeat those steps by hand for each clip. With AviSynth you write the chain once, save it as a script, and point each host application at that script — or generate one script per clip from a template — so the treatment is identical across the whole batch.
If you are deciding whether this approach suits you, use two criteria: how repetitive and rule-based your processing is (favours scripts), and how much you rely on interactive, frame-by-frame creative decisions (favours a conventional editor). Many people use both — a GUI editor for creative cutting, AviSynth for the systematic processing stages.
A useful next step is to read the wiki's introduction to the scripting language and its filter introduction, then try the smallest possible script on one short clip in a host application you already own. If the script route feels natural, the "Script examples" page shows how the pieces combine in real projects. The project is free and open source under GPLv2, and the wiki is maintained by volunteers, so the guides are the primary documentation. Related discussion and builds are also referenced from AviSynth+ and Doom9 Forum.
How do I troubleshoot common AviSynth script and configuration errors?
Start with the wiki's own troubleshooting section for the version you run, then isolate the failure by simplifying the script until it loads. Most AviSynth problems fall into four buckets: the script can't find a file or plugin, a filter doesn't exist, a color format or resolution mismatch occurs, or the host application can't open the frameserver output.
A practical isolation routine
- Reduce the script to one line that opens a source, such as a single
AviSourceorFFVideoSourcecall, and preview it in a simple viewer. - Add one filter at a time and re-test. The last addition before failure is your suspect.
- Replace variables with literal values to rule out a bad path or number.
- Check the error text: "Unable to load plugin" points to a DLL problem, while "Invalid arguments to function" points to a syntax or parameter issue.
- Confirm the host (an encoder or editor) is reading the correct script and that 32-bit/64-bit versions match between host, AviSynth and plugins.
Common causes and fixes
| Symptom | Likely cause | What to try |
|---|---|---|
| Script won't open at all | Syntax error, missing quote or bracket | Read the reported line number; comment out sections |
| "Plugin not found" | Plugin DLL not in the plugin directory or wrong bit depth | Move the DLL to the autoload folder; match 32/64-bit |
| "No function named ..." | Filter not loaded or misspelled | Load the plugin explicitly or check the function name |
| Wrong colors or banding | Color format mismatch (YV12, YUY2, RGB) | Convert early with the appropriate conversion filter |
| Output plays but is black or silent | Source path wrong or decoder missing | Test the file in a normal player; install the needed source filter |
| Host crashes on open | Bit-depth or version mismatch | Align host, AviSynth build and plugins |
Configuration notes
Keep plugins in the designated autoload directory so they load without explicit calls, and avoid mixing builds from different major versions in one setup. If a script works in a preview tool but fails in an encoder, the encoder is usually the 32-bit/64-bit mismatch. The AviSynth wiki's FAQ, filter introduction and troubleshooting pages cover the syntax and filter specifics, and the forum linked from the site is where unusual decoder issues get diagnosed.
For a concrete case: if a batch of clips fails only when a denoise filter is added, test that filter alone on one short clip. If it fails there too, the plugin or its parameters are the problem, not your source files.
The Netherlands
User reviews (0)