What Is OpenTimelineIO (OTIO) and Why Should Creators Care?

Most video editors have hit this wall at some point: you start a project in one tool, then need to move it to another. Maybe your team uses Premiere, but your colorist works in Resolve. Maybe you want to try a different editor without rebuilding your entire timeline from scratch. Maybe an AI tool generated a rough cut and you want to refine it somewhere with better tools.

The export options are usually frustrating. XML sometimes works. FCPXML might import cleanly. EDL is ancient and carries barely any metadata. You end up recreating cuts by hand, or sending screenshots and timecodes and hoping for the best.

OpenTimelineIO (OTIO) is designed to fix this. It’s an open format for moving timeline data between tools — and it matters more than most creators realize until they need it.

What OTIO Actually Is

OpenTimelineIO is an interchange format for editorial timeline information. Think of it as a modern Edit Decision List that actually reflects how people edit today, rather than how people edited on linear tape in 1965.

What it stores:

Clip order and position on the timeline
Cut points and transitions
Multiple tracks (video, audio, subtitles)
Timing and duration information
References to source media files
Metadata like markers, comments, and labels

What it does not store:

The actual video or audio files themselves
Rendered video output
Effects that require tool-specific rendering

OTIO describes your edit — the decisions you made about what goes where — without containing any of the media itself. This makes it lightweight and easy to move between machines and tools.

Why OTIO Exists

The film industry has been trying to move timelines between tools for decades. The problem is that the existing formats were never designed for modern editing.

EDL (Edit Decision List): Created in the 1960s for linear tape editing. Extremely limited — one video track, one audio track, no metadata beyond basic timecode. Still used in broadcast because nothing better existed for a long time.

XML (multiple variants): Different software uses different XML schemas, and they’re not compatible with each other. Premiere’s XML isn’t the same as Final Cut’s XML, which isn’t the same as Resolve’s. Converting between them almost always loses information somewhere.

FCPXML (Final Cut Pro XML): Apple’s format for Final Cut Pro. Works well inside Apple’s ecosystem, less reliably outside it.

AAF (Advanced Authoring Format): Complex, leans proprietary, and is primarily used in Avid Media Composer environments.

Each of these formats solves one ecosystem’s problem. None of them solve the general problem of moving an edit between any two tools without losing information along the way.

That’s the gap OTIO was built to fill — a format that’s universal from the ground up, extensible when you need it to be, and not controlled by any single vendor.

Who Makes It

OpenTimelineIO was originally created by Pixar and is now maintained by the Academy Software Foundation — the same organization behind OpenEXR, USD, and other professional film production standards.

This is important because it means OTIO isn’t a proprietary format controlled by one company with its own agenda. It’s an open standard designed for the entire industry, with an Apache 2.0 open-source license and transparent development. The goal is interoperability, not lock-in.

How It Works

At a basic level, OTIO files are JSON documents that describe your timeline structure in a hierarchy:

Timeline
  └── Stack (multiple tracks layered)
        └── Track (single video or audio track)
              └── Clip (individual media item)
                    └── MediaReference (link to source file)

When you export OTIO from one tool, you’re exporting this structure. When another tool imports it, it reads the structure and reconstructs your timeline — with clips, cuts, and tracks intact.

Typical use cases:

Edit in an AI tool or lightweight editor, export OTIO, open in DaVinci Resolve for color grading
Build a rough cut in one NLE, hand the OTIO file to a collaborator who uses different software
An AI tool generates timeline suggestions, you refine them in your preferred editor
Archive an edit in a format that isn’t tied to one specific software version

DaVinci Resolve Support

As of DaVinci Resolve 18.5, OTIO is natively supported — which is a significant milestone for the format.

To import OTIO in Resolve:

File → Import Timeline → select your .otio file
Resolve reads the timeline structure and creates a new timeline
You may need to relink source media if file paths have changed

To export OTIO from Resolve:

Right-click the timeline in the media pool
Export Timeline → OpenTimelineIO
Save the .otio file

This means Resolve users can now move timelines to and from any OTIO-compatible tool without going through XML conversion gymnastics.

OTIO vs. Traditional Formats

Feature	EDL	XML	FCPXML	OTIO
Multiple video tracks	No	Varies	Yes	Yes
Multiple audio tracks	No	Varies	Yes	Yes
Metadata support	Minimal	Limited	Yes	Extensible
Open source	No	No	No	Yes
Universal compatibility	No	No	Apple-centric	Designed for it
Modern tool support	Broadcast only	Varies	Final Cut	Growing

OTIO isn’t meant to replace your project files — it’s a transfer format. Your original project stays in your primary NLE, and OTIO is how you move timeline data out of it and into something else.

Why This Matters for Creators

Most creators never think about interchange formats until they’re stuck trying to move an edit somewhere. Here’s why it’s worth caring about before you hit that wall.

You’re Not Locked Into One Tool

If your editor changes pricing, drops a feature you depend on, or shuts down entirely, your edit decisions exist in a format you can take elsewhere. You’re not rebuilding from scratch.

AI Tools Can Feed Into Your Workflow

Emerging AI editing tools — VioletFlare, Eddie AI, and others — use OTIO as an export format. The AI generates a rough timeline, you open it in Resolve or Premiere, and you make it yours. The AI isn’t a closed box; it’s a starting point that hands off to your real editor.

Collaboration Gets Simpler

If you work with editors, colorists, or sound designers who use different software, OTIO reduces the friction of moving work between people. You’re not asking everyone to adopt the same NLE — you’re handing them a timeline they can actually open.

Edit Templates Become Portable

If you build template timelines, reusable structures, or workflow assets, OTIO lets those travel between tools and software versions. Your templates aren’t locked to one specific NLE release.

Limitations

OTIO has real constraints worth knowing about.

Effects often don’t transfer. Basic cuts and transitions come through fine, but complex effects, motion graphics, and tool-specific filters usually don’t. OTIO describes what clips exist and where they sit — not how to render every proprietary plugin.

Color grades are tool-specific. A basic grade might survive the transfer, but advanced color work is deeply tied to each tool’s color science. Resolve’s node graph doesn’t automatically translate to Premiere’s Lumetri panel.

Source media must be accessible. OTIO references source files by path rather than containing them. If the person receiving the OTIO file doesn’t have access to the original media, the timeline opens but the clips show as offline.

Not every tool supports it yet. Support is growing — Resolve has it natively, several AI tools support it, and conversion utilities exist — but Premiere Pro and Final Cut Pro don’t import OTIO natively as of this writing. The opentimelineio Python library can bridge the gap for conversion.

Getting Started with OTIO

If you want to start using OTIO today:

In DaVinci Resolve (18.6+): Import and export OTIO directly from the File menu. It’s native — no plugins or extra steps needed.

In Python: Install the OpenTimelineIO library:

pip install opentimelineio

You can read, write, and convert between formats programmatically:

import opentimelineio as otio
timeline = otio.adapters.read_from_file("edit.fcpxml")
otio.adapters.write_to_file(timeline, "edit.otio")

With conversion tools: The opentimelineio library and tools like ChatOctopus/timeline can convert between OTIO, FCPXML, XML, EDL, and other formats. If your primary NLE doesn’t support OTIO yet, you can convert from its native format as an intermediate step.

Where This Is Heading

OTIO is part of a broader shift in how video production works. The old model was one tool doing everything from start to finish. The emerging model is specialization: rough-cut in an AI tool, color grade in Resolve, mix audio in Fairlight or Pro Tools, add motion graphics in After Effects.

That multi-tool approach only works if the pieces connect — and OTIO is the connection layer. It’s the standard that lets your edit decisions move between tools without information getting lost in translation.

You won’t think about OTIO every time you sit down to edit. You’ll notice it working when moving a timeline between tools feels painless. You’ll notice it missing when you’re recreating cuts by hand and wondering why this is still a problem.

OTIO isn’t a tool you open — it’s infrastructure that makes your tools work together. If you use multiple editors, collaborate with people on different software, or integrate AI tools into how you edit, OTIO is how your timeline survives the transfer. DaVinci Resolve supports it natively, and AI tools are starting to adopt it. It’s worth paying attention to now, before you need it and don’t have it.