OpenTimelineIO: Open Source Design & Prototyping

What is OpenTimelineIO?

OpenTimelineIO is an Apache-2.0 interchange format and C++ API, with an official Python binding, for editorial cut information — the order, length and media references of timeline edits — built for developers and pipeline engineers in film, television, animation, VFX and game development who need to move cuts between non-linear editors, game engines and content creation tools.

What it is

OpenTimelineIO is an interchange format and API for editorial cut information. It carries information about the order and length of cuts together with references to external media, and it is deliberately not a container format for media. The core library is implemented in C++ and provides an in-memory data model as well as library functions for interpreting, manipulating and serializing that model; inside the core sits opentime, a dependency-less library that deals strictly with time. An official Python binding is provided as an idiomatic and ergonomic interface for Python developers, and it includes a plugin system supporting a number of plugin types, most notably adapters that read and write legacy formats into the OTIO data model.

The problem it solves is translation between editorial applications. Cut information normally lives inside each application's own project format, so every pair of tools needs its own bespoke conversion. OTIO gives those tools a shared data model and a serialized form to hand over instead, and the project reports native support in most non-linear editing applications with deep integration in game engines, digital content creation tools and adjacent industries. It lives in the visual effects ecosystem and follows the VFX Reference Platform, with the current release supporting platform years 2022 through 2025 and Python 3.9 to 3.15; the code is hosted under the Academy Software Foundation on GitHub.

Key capabilities

An in-memory editorial data model implemented in C++, with library functions for interpreting, manipulating and serializing it.
opentime, a dependency-less time library inside the core that isolates the handling of time from the rest of the model.
An official Python binding spanning Python 3.9 through 3.15, intended to be idiomatic and ergonomic for Python developers.
A Python plugin system with several plugin types, most notably adapter plugins that read and write legacy formats into the OTIO data model.
Interchange of cut order and length plus references to external media, without acting as a media container itself.
A documented support matrix for VFX Reference Platform years 2022 to 2025, maintained in VERSIONS.md.
Documentation on ReadTheDocs covering quick start, architecture, use cases and API docs.

Who uses it and how

Film and television editorial teams: the framework is described as mature and widely deployed across the film and television industries, with native support in most non-linear editing applications.
Game and content-creation pipelines: deep integration in game engines and digital content creation tools, and in adjacent industries as well.
VFX facilities that pin their toolchain to a VFX Reference Platform year, choosing among the 2022 to 2025 releases and the corresponding Python versions.
Pipeline developers who write adapter plugins to bring applications lacking a native integration into the same data model.
Teams that want a stable, Apache-2.0 licensed API they can deploy now: the project states the API is considered stable and may be confidently deployed.

Getting started

Start with the quick start in the ReadTheDocs documentation, which covers the C++ core library and the official Python binding. The VERSIONS.md support matrix records which release supports which VFX Reference Platform year and Python version.

How it compares

The facts provided name no paid products that OpenTimelineIO replaces, and no comparable interchange tools are listed alongside it in this registry. It therefore stands alone here, and the comparison that matters is with the individual proprietary project formats of the editing applications it is designed to sit between.

When to use it — and when not to

Adopting it means building and shipping a C++ core and Python binding against specific VFX Reference Platform and Python versions, and maintaining adapter plugins for any format that lacks a native integration. It is the wrong choice for anyone who needs a media container format or a finished editing application, since OTIO carries cut information and media references only. The project also describes its API as stable but still undergoing active development, refinement and bug fixes, with work under way to strengthen its mathematical and theoretical underpinnings — a caveat worth weighing alongside the 211 open issues if timeline arithmetic is central to your pipeline.

project readme (upstream, from github) — read inline

OpenTimelineIO

DEVELOPMENT STATUS

OpenTimelineIO is a mature framework widely deployed across the film and television industries. It is natively supported in most non-linear editing applications, and has deep integration in game engines, digital content creation tools and adjacent industries as well.

The API for OpenTimelineIO is considered stable, but is still undergoing active development, refinement and bug fixes. Work is underway to strengthen the mathematical and theoretical underpinnings of OpenTimelineIO. The current version of OpenTimelineIO may be confidently deployed in your domain.

We encourage all developers and end users to provide feedback, requests, comments, and/or code contributions.

Overview

OpenTimelineIO is an interchange format and API for editorial cut information. OTIO contains information about the order and length of cuts and references to external media. It is not however, a container format for media.

For integration with applications, the core OTIO library is implemented in C++ and provides an in-memory data model, as well as library functions for interpreting, manipulating, and serializing that data model. Within the core is a dependency-less library for dealing strictly with time, opentime.

The project also supports an official python binding, which is intended to be an idiomatic and ergonomic binding for python developers. The python binding includes a plugin system which supports a number of different types of plugins, most notably adapters, which can be used to read and write legacy formats into the OTIO data model.

Documentation

Documentation, including quick start, architecture, use cases, API docs, and much more, is available on ReadTheDocs

Supported VFX Platforms

The current release supports:

VFX platform 2025, 2024, 2023, 2022
Python 3.9 - 3.15

See also OpenTimelineIO VFX Reference Platform Support Matrix for details of which versions of OTIO support which VFX Reference Platform years.

For more information on our vfxplatform support policy: Contribution Guidelines Documentation Page For more information on the vfxplatform: VFX Platform Homepage

Adapter Plugins

To provide interoperability with other file formats or applications lacking a native integration, the opentimelineio community has built a number of python adapter plugins. This includes Final Cut Pro XML, AAF, CMX 3600 EDL, and more.

Note: for releases after v0.16, the OpenTimelineIO PyPI package will only include the core libraries and file formats. Users that need the full set of adapter plugins should use the OpenTimelineIO-Plugins PyPI Package. Each OpenTimelineIO release will have a matching OpenTimelineIO-Plugins release.

For more information: https://github.com/AcademySoftwareFoundation/OpenTimelineIO/issues/1386

For more information about this, including supported formats, see: https://opentimelineio.readthedocs.io/en/latest/tutorials/adapters.html

All adapters except the native .otio, .otioz and .otiod have been relocated to separate repositories under the OpenTimelineIO organization located here: https://github.com/OpenTimelineIO The OTIO python bindings also support several other kinds of plugins, for more information see:

Media Linkers - Generate media references to local media according to your local conventions.
HookScripts - Scripts that can run at various points during OTIO execution (ie before the media linker)
SchemaDefs - Define OTIO schemas.

Installing / Quick-Start

The Python-wrapped version of OpenTimelineIO is publicly available via PyPI. You can install OpenTimelineIO via:

python -m pip install opentimelineio

For detailed installation instructions and notes on how to run the included viewer program, see: https://opentimelineio.readthedocs.io/en/latest/tutorials/quickstart.html

Example Usage

C++:

#include <iostream>

#include "opentimelineio/timeline.h"

void
main()
{
    OTIO_NS::SerializableObject::Retainer<OTIO_NS::Timeline> tl(
            dynamic_cast<OTIO_NS::Timeline*>(
                OTIO_NS::Timeline::from_json_file("taco.otio")
        )
    );
    for (const auto& cl : tl->find_clips())
    {
        OTIO_NS::RationalTime dur = cl->duration();
        std::cout << "Name: " << cl->name() << " [";
        std::cout << dur.value() << "/" << dur.rate() << "]" << std::endl;
    }
}

Python:

import opentimelineio as otio

timeline = otio.adapters.read_from_file("foo.aaf")
for clip in timeline.find_clips():
  print(clip.name, clip.duration())

There are more code examples here: https://github.com/AcademySoftwareFoundation/OpenTimelineIO/tree/main/examples

Also, looking through the unit tests is a great way to see what OTIO can do: https://github.com/AcademySoftwareFoundation/OpenTimelineIO/tree/main/tests

Developing

If you want to contribute to the project, please see: https://opentimelineio.readthedocs.io/en/latest/tutorials/contributing.html

You can get the latest development version via:

git clone git@github.com:AcademySoftwareFoundation/OpenTimelineIO.git --recursive

You can install development dependencies with python -m pip install .[dev]

You can also install the PySide2 dependency with python -m pip install .[view]

You may need to escape the [ depending on your shell, \[view\] .

Currently the code base is written against python 3.9-3.15, in keeping with the pep8 style. We ask that before developers submit pull request, they:

run make test -- to ensure that none of the unit tests were broken
run make lint -- to ensure that coding conventions conform to pep8
run make coverage -- to detect code which isn't covered

PEP8: https://www.python.org/dev/peps/pep-0008/

For advanced developers, arguments can be passed to CMake through the pip commandline by using the CMAKE_ARGS environment variable.

*nix Example:

env CMAKE_ARGS="-DCMAKE_VAR=VALUE1 -DCMAKE_VAR_2=VALUE2" pip install .

Additionally, to reproduce CI failures regarding the file manifest, run: make manifest locally to run the python check-manifest program.

C++ Coverage Builds

To enable C++ code coverage reporting via gcov/lcov for builds, set the following environment variables:

OTIO_CXX_COVERAGE_BUILD=ON
OTIO_CXX_BUILD_TMP_DIR=path/to/build/dir

When building/installing through pip/setup.py, these variables must be set before running the install command (python -m pip install . for example).

License

OpenTimelineIO is open source software. Please see the LICENSE.txt for details.

Nothing in the license file or this project grants any right to use Pixar or any other contributor’s trade names, trademarks, service marks, or product names.

Contact

For more information, please visit http://opentimeline.io/ or https://github.com/AcademySoftwareFoundation/OpenTimelineIO or join our discussion forum: https://lists.aswf.io/g/otio-discussion

Frequently asked questions

Is OpenTimelineIO free to use?

OpenTimelineIO is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does OpenTimelineIO do?

Open Source API and interchange format for editorial timeline information.

What is OpenTimelineIO written in?

OpenTimelineIO is primarily written in C++. Its source is publicly available at https://github.com/AcademySoftwareFoundation/OpenTimelineIO, and it has 2,032 GitHub stars.