Convert Figma logo to code with AI

NatronGitHub logoNatron

Open-source video compositing software. Node-graph based. Similar in functionalities to Adobe After Effects and Nuke by The Foundry.

4,619
337
4,619
239
View on GitHub

Top Related Projects

AcademySoftwareFoundation's avatar

OpenColorIO

1,762

A color management framework for visual effects and animation.

AcademySoftwareFoundation's avatar

OpenTimelineIO

1,439

Open Source API and interchange format for editorial timeline information.

mltframework's avatar

shotcut

10,740

cross-platform (Qt), open-source (GPLv3) video editor

OpenShot's avatar

openshot-qt

4,242

OpenShot Video Editor is an award-winning free and open-source video editor for Linux, Mac, and Windows, and is dedicated to delivering high quality video editing and animation solutions to the world.

jliljebl's avatar

flowblade

2,636

Video Editor for Linux

olive-editor's avatar

olive

8,129

Free open-source non-linear video editor

Quick Overview

Natron is an open-source, cross-platform compositing software for visual effects and motion graphics. It aims to provide a powerful, node-based workflow similar to industry-standard tools like Nuke, while remaining free and accessible to a wide range of users.

Pros

  • Free and open-source, making it accessible to independent artists and small studios
  • Cross-platform compatibility (Windows, macOS, and Linux)
  • Powerful node-based compositing system with a wide range of built-in effects
  • Active community and ongoing development

Cons

  • Steeper learning curve compared to some simpler video editing software
  • Less extensive documentation and tutorials compared to commercial alternatives
  • May lack some advanced features found in high-end professional tools
  • Performance can be slower than commercial alternatives for complex compositions

Getting Started

To get started with Natron:

  1. Visit the official Natron website: https://natrongithub.github.io/
  2. Download the appropriate version for your operating system
  3. Install Natron following the provided instructions
  4. Launch Natron and familiarize yourself with the interface
  5. Start a new project and begin creating node-based compositions
  6. Refer to the official documentation and community resources for tutorials and guidance

Note: As Natron is a visual effects and compositing software, not a code library, there are no code examples or quick start code snippets to provide.

Competitor Comparisons

AcademySoftwareFoundation logo

OpenColorIO

1,762

A color management framework for visual effects and animation.

Pros of OpenColorIO

  • Widely adopted industry standard for color management in visual effects and animation
  • Extensive documentation and community support
  • Actively maintained by the Academy Software Foundation

Cons of OpenColorIO

  • More complex and specialized, focusing solely on color management
  • Steeper learning curve for beginners
  • Requires integration with other tools for a complete workflow

Code Comparison

OpenColorIO:

#include <OpenColorIO/OpenColorIO.h>
namespace OCIO = OCIO_NAMESPACE;

OCIO::ConstConfigRcPtr config = OCIO::GetCurrentConfig();
OCIO::ConstProcessorRcPtr processor = config->getProcessor("input", "output");
processor->apply(pixelData, numPixels);

Natron:

#include <Engine/EffectInstance.h>

boost::shared_ptr<Natron::Image> output(new Natron::Image(rod, args.mipMapLevel, par, depth, false));
EffectInstance::applyPixelClipping(procWindow, rod, output.get());
EffectInstance::copyUnProcessedChannels(args.originalImage, output.get(), procWindow);

OpenColorIO focuses on color space transformations, while Natron provides a broader set of image processing capabilities. OpenColorIO's code is more specialized for color management tasks, whereas Natron's code demonstrates general image processing operations within a compositing framework.

AcademySoftwareFoundation logo

OpenTimelineIO

1,439

Open Source API and interchange format for editorial timeline information.

Pros of OpenTimelineIO

  • Broader industry support and adoption, backed by the Academy Software Foundation
  • More focused on interoperability and standardization of timeline formats
  • Active development with frequent updates and contributions

Cons of OpenTimelineIO

  • More limited in scope, primarily focused on timeline representation
  • Less comprehensive feature set compared to Natron's full compositing capabilities
  • Steeper learning curve for integration into existing workflows

Code Comparison

OpenTimelineIO (Python):

import opentimelineio as otio

timeline = otio.schema.Timeline()
track = otio.schema.Track()
clip = otio.schema.Clip(name="My Clip")
track.append(clip)
timeline.tracks.append(track)

Natron (Python):

app = natron.getApplication()
project = app.createProject()
reader = project.createReader("file.mov")
writer = project.createWriter("output.mov")
writer.connectInput(0, reader)

Both projects use Python for scripting, but OpenTimelineIO focuses on timeline manipulation, while Natron provides a more comprehensive set of tools for compositing and visual effects.

mltframework logo

shotcut

10,740

cross-platform (Qt), open-source (GPLv3) video editor

Pros of Shotcut

  • More active development with frequent updates and bug fixes
  • Broader range of supported video formats and codecs
  • User-friendly interface suitable for beginners and intermediate users

Cons of Shotcut

  • Less powerful for complex compositing and visual effects work
  • Limited node-based workflow options compared to Natron
  • Fewer advanced features for professional-grade video editing

Code Comparison

Shotcut (C++):

void MainWindow::onOpenOther()
{
    QString path = Settings.openPath();
    QString filename = QFileDialog::getOpenFileName(this, tr("Open File"), path);
    if (!filename.isEmpty()) {
        Settings.setOpenPath(QFileInfo(filename).path());
        open(filename);
    }
}

Natron (C++):

void NodeGraph::createReaderNode(const std::string& filename, bool useDialog, int majorVersion)
{
    CreateNodeArgs args(PLUGINID_NATRON_READ, std::string(), -1, -1, -1, true, INT_MIN, INT_MIN, true, true, QString(), CreateNodeArgs::DefaultValuesList(), QString(), false, false, QString(), QPointF(), true);
    args.fixedName = "Read";
    NodePtr node = getApp()->createNode(args);
    if (!node) {
        return;
    }
}

Both projects use C++ and Qt for their user interfaces, but Natron's code tends to be more complex due to its focus on node-based compositing and advanced features.

OpenShot logo

openshot-qt

4,242

OpenShot Video Editor is an award-winning free and open-source video editor for Linux, Mac, and Windows, and is dedicated to delivering high quality video editing and animation solutions to the world.

Pros of OpenShot

  • User-friendly interface, making it more accessible for beginners
  • Supports a wider range of video formats and codecs
  • More frequent updates and active community support

Cons of OpenShot

  • Limited advanced compositing and visual effects capabilities
  • Less precise control over individual frames and keyframes
  • Fewer professional-grade tools for color grading and motion graphics

Code Comparison

OpenShot (Python):

def resize_project(self, new_width, new_height, new_fps, new_sample_rate, new_channels):
    """Resize project dimensions"""
    self.changes.emit(["width", "height", "fps", "sample_rate", "channels"])
    self.info.width = new_width
    self.info.height = new_height
    self.info.fps = new_fps

Natron (C++):

void Project::setProjectDefaultFormat(int w, int h, double par)
{
    QMutexLocker k(&_imp->projectLock);
    _imp->projectDefaultFormat.x = w;
    _imp->projectDefaultFormat.y = h;
    _imp->projectDefaultFormat.par = par;
    _imp->setProjectDefaultFormatKnobs(w, h, par);
}

Both projects are open-source video editing software, but they cater to different user needs. OpenShot focuses on simplicity and ease of use, while Natron provides more advanced compositing and visual effects capabilities. The code snippets show that OpenShot uses Python, which is generally easier for beginners, while Natron uses C++ for potentially better performance in complex operations.

jliljebl logo

flowblade

2,636

Video Editor for Linux

Pros of Flowblade

  • Lightweight and efficient video editor, suitable for lower-end hardware
  • User-friendly interface with a focus on quick editing workflows
  • Active development with frequent updates and bug fixes

Cons of Flowblade

  • Limited advanced compositing features compared to Natron
  • Primarily focused on video editing rather than visual effects
  • Smaller community and fewer third-party plugins available

Code Comparison

Flowblade (Python):

def _get_track_counts():
    audio_tracks = get_track_counts()[1]
    video_tracks = get_track_counts()[0]
    return (video_tracks, audio_tracks)

Natron (C++):

void Node::getInputsOutputsDimensions(std::map<int, std::vector<NodePtr> >* inputs,
                                      std::map<int, std::vector<NodePtr> >* outputs) const
{
    QMutexLocker k(&_imp->inputsMutex);
    *inputs = _imp->inputs;
    *outputs = _imp->outputs;
}

Flowblade is a Python-based video editor with a focus on simplicity and efficiency, while Natron is a C++ compositing software with more advanced features for visual effects. Flowblade's code tends to be more concise and readable, while Natron's code is more complex but offers greater performance and flexibility for advanced operations.

olive-editor logo

olive

8,129

Free open-source non-linear video editor

Pros of Olive

  • More user-friendly interface, designed for video editing beginners
  • Faster rendering times for basic video editing tasks
  • Actively maintained with frequent updates and new features

Cons of Olive

  • Limited advanced compositing and visual effects capabilities
  • Fewer professional-grade tools compared to Natron
  • Smaller plugin ecosystem and third-party support

Code Comparison

Olive (C++):

void TimelineWidget::mousePressEvent(QMouseEvent *event) {
  if (event->button() == Qt::LeftButton) {
    // Handle left mouse button press
  }
}

Natron (C++):

void NodeGraph::mousePressEvent(QMouseEvent* e) {
  if (e->button() == Qt::LeftButton) {
    // Handle left mouse button press
  }
}

Both projects use similar event handling approaches in their UI code, with Olive focusing on timeline-specific interactions and Natron on node graph operations.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Natron

GPL2 License Contributor Covenant Build Status Coverage Status Documentation Status Packaging status OpenHub

Natron is a free, open-source (GPLv2 license) video compositor, similar in functionality to Adobe After Effects, Foundry's Nuke, or Blackmagic Fusion. It is portable and cross-platform (GNU/Linux, macOS, and Microsoft Windows).

Help wanted

Natron is looking for developers and maintainers! You can help develop and maintain Natron if you have the following skills:

For more information, see the "Contributing" section below.

If you are willing to help, please contact the development team on the pixls.us Natron forum.

Features

  • 32-bit floating-point linear color processing pipeline.

  • Color management handled by OpenColorIO.

  • Dozens of video and image formats supported such as: H264, DNxHR, EXR, DPX, TIFF, JPG, PNG through OpenImageIO and FFmpeg.

  • Support for many free, open-source, and commercial OpenFX plugins—currently almost all features of OpenFX v1.4 are supported. Those marked with (+) are included in the binary releases.

  • Intuitive user interface: Natron aims not to break habits by providing an intuitive and familiar user interface. It is possible to customize and separate the graphical user interface on any number of screens. You can re-use your layouts and share your layout files (.nl).

  • Performance: In Natron, anything you do produces real-time feedback in the viewer thanks to the optimized multi-threaded rendering pipeline and support for proxy rendering (computing at a lower resolution to speed up rendering).

  • Multi-task: Natron can render multiple graphs at the same time. It can also be used as a background process in headless mode.

  • Recover easily from bugs: Natron's auto-save system detects inactivity and saves your work for yourself. Natron is also able to render frames in a separate process, meaning that any crash in the main application would not crash the ongoing render (and the other way around).

  • Project files saved in XML and easily editable by humans.

  • Fast & interactive viewer - Smooth & accurate zooming/panning even for very large image sizes (tested on 27k x 30k images).

  • Real-time playback: Natron offers real-time playback with excellent performance thanks to its RAM/Disk cache. Once a frame is rendered it can be reproduced instantly afterward, even for large image sizes.

  • Animate your visual effects: Natron offers a simple and efficient way to deal with keyframes with a very accurate and intuitive Curve Editor as well as a Dope Sheet to quickly edit your motion graphics.

  • Command-line rendering: Natron is capable of running without a GUI for batch rendering with scripts or on a render farm.

  • Rotoscoping, rotopainting, and tracking support

  • Multi-view workflow: Natron saves time by keeping all the views in the same stream. You can separate the views at any time with the OneView node.

  • Python scripting integration:

    • Parameters expressions
    • User-defined parameters
    • Nodes groups as Python scripts
    • Script editor to control the application overall
    • User-defined python callbacks to respond to particular checkpoints of the internals of the software (change of a parameter, before rendering a frame, etc…)
    • Integration of Pyside to the GUI so that the interface is extensible with new menus and windows

  • Multi-channel compositing: Natron can manipulate multi-layered EXR files thanks to OpenImageIO. Users can choose to work with any layer or channel on any node, new custom layers can also be created.

Requirements

A machine running one of the supported operating systems (GNU/Linux, macOS, Microsoft Windows), and a 32-bits x86 or 64-bits x86-64 processor.

An OpenGL 2.0 compatible graphics card is needed to run Natron (2.1+) with hardware-accelerated rendering. Other graphics cards work with software-only rendering (see below).

The following graphics cards are supported for hardware-accelerated rendering:

  • Intel GMA 3150 (Linux-only)
  • Intel GMA X3xxx (Linux-only)
  • Intel GMA X4xxx (Windows 7 & Linux)
  • Intel HD (Ironlake) (Windows 7 & Linux)
  • Intel HD 2000/3000 (Sandy Bridge) (Windows 7/Linux/Mac)
  • Intel HD 4000 and greater (All platforms)
  • Nvidia GeForce 6 series and greater
  • Nvidia Quadro FX and greater
  • Nvidia Quadro NVS 285 and greater
  • ATI/AMD Radeon R300 and greater
  • ATI/AMD FireGL T2-64 and greater (FirePro)

On Windows and Linux you can enable software rendering. On Linux, enable the environment variable LIBGL_ALWAYS_SOFTWARE=1 before running Natron. On Windows, enable the legacy hardware package in the installer.

Installing

Binary distribution

Standalone binary distributions of Natron are available for GNU/Linux, Windows, and macOS on GitHub, or from the Natron web site. These distributions contain Natron and four included sets of OpenFX plugins:

Alternatively, on Linux systems you can install Natron through flatpak: flatpak install fr.natron.Natron

For each architecture / operating system, you can either download a stable release, a release candidate (if available), or one of the latest snapshots. Note that snapshots contain the latest features and bug fixes, but may be unstable.

Building and installing from source

There are instructions for building Natron and the basic plugins from source is this directory on various architectures / operating systems:

This documentation may be slightly outdated, so do not hesitate to submit updated build instructions, especially for the various GNU/Linux distributions.

Automatic build scripts & other development tools

These can be found in tools/README.md

These scripts run on virtual machines running a specific operating system, setting these up is more complicated than the basic build process linked above.

Contributing

Low hanging fruits

You should start contributing to the Natron project by first picking an easy task, and then gradually taking more difficult tasks. Here are a few sample tasks, by order of difficulty (from 0 to 10):

  • 2: Pyplugs, Shadertoy scripts (there are still developers for these, see https://github.com/NatronGitHub/natron-plugins )
  • 4: Write an OpenFX plugin, starting from an example in openfx-misc or from the official OpenFX examples, for example try to make an OpenFX plugin from a widely-used PyPlug. There are a few OFX plugin developers in the community.
  • 5: Build Natron locally (on any system)
  • 7: Compile a redistributable Natron binary (Linux is easier since we build and ship most dependencies using the build scripts)
  • 9: Fix a simple Natron bug
  • 10: Add new functionality to Natron (see issues)

Logistics

We coordinate development through the GitHub issue tracker.

The main development branch is called "master". The stable version is on branch RB-2.5.

Additionally, each stable release supported has a branch on its own. For example, the stable release of the v1.0. and all its bug fixes should go into that branch. At some point, a version that is no longer supported will get removed from GitHub's branches and only a release tag will be available to get the source code at that point.

Feel free to report bugs, discuss tasks, or pick up work there. If you want to make changes, please fork, edit, and send us a pull request, preferably on the "RB-2.5" branch.

There's a .git-hooks directory in the root. This contains a pre-commit hook that verifies code styling before accepting changes. You can add this to your local repository's .git/hooks/ directory by doing the following:

cd Natron
mkdir .git/hooks
ln -s ../../.git-hooks/pre-commit .git/hooks/pre-commit

Pull requests that don't match the project code style are still likely to be accepted after manually formatting and amending your changeset. The formatting tool (astyle) is completely automated; please try to use it.