[opensourcedex]

OpenImageIO is a free, open source photo & video editors project written in C++ and released under Apache-2.0. It has 2,378 GitHub stars, 707 forks and 143 open issues, and was last pushed 29 hours ago. On this registry it ranks #45 of 67 tracked projects in Photo & Video Editors, with 5 head-to-head comparisons available.

What is OpenImageIO?

OpenImageIO is a C++ toolset and format-agnostic image I/O library for reading, writing, and processing images across the file formats used in visual effects and animation, built for VFX studios and the developers of renderers, compositors, viewers, and other production-pipeline software.

What it is

OpenImageIO is a library, a set of plug-ins, and a collection of command-line utilities, maintained under the Academy Software Foundation and licensed under Apache-2.0 (with documentation under Creative Commons Attribution 4.0). Its core is a pair of simple but powerful ImageInput and ImageOutput APIs that abstract the reading and writing of nearly any image file format, so that calling applications never need to know format details or even which formats are available. Each format's implementation lives in a plug-in managed by the library, and Python bindings are provided for all of the major APIs.

The concrete problem it solves is the sprawl of image formats in a production pipeline: an application would otherwise need bespoke handling for TIFF, OpenEXR, DPX, PSD, RAW camera files and dozens more. OpenImageIO replaces that per-format code with a single interface whose feature set, scalability, and robustness are aimed at feature film production. It is written in C++ (with C++11 support noted among its topics) and targets image-processing, texture, and VFX workloads.

Key capabilities

  • ImageInput and ImageOutput APIs that read and write files without the calling application knowing format specifics, with per-format implementations loaded as plug-ins at runtime.
  • Plug-in I/O for TIFF, JPEG/JFIF, JPEG XL, OpenEXR, PNG, HDR/RGBE, ICO, BMP, Targa, JPEG-2000, RMan Zfile, FITS, DDS, Softimage PIC, PNM, DPX, Cineon, IFF, OpenVDB, Ptex, Photoshop PSD, Wavefront RLA, SGI, WebP, GIF, DICOM, HEIF/HEIC/AVIF, many "RAW" digital camera formats, and movie formats readable as individual frames.
  • Command-line tools built on those classes: oiiotool for format conversion and image processing, iinfo for printing detailed image info, iconvert for converting among formats and data types or modifying metadata, idiff for comparing images, igrep for searching images by matching metadata, and iv as an image viewer.
  • An ImageCache class that accesses tens of thousands of image files totalling multiple TB while using only a tiny amount of runtime memory, on the order of tens of megabytes.
  • A TextureSystem class providing filtered MIP-map texture lookups on top of the caching behaviour of ImageCache.
  • An ImageBuf class for storing whole images in memory together with ImageBufAlgo functions implementing common image processing computations.
  • Python bindings for all of the major APIs.

Who uses it and how

  • VFX studios embedding the library in a production pipeline where image data must be read and written across many formats.
  • Developers of renderers, compositors, viewers, and other image-related pipeline software who call ImageInput/ImageOutput instead of writing format-specific code.
  • Renderer teams using TextureSystem for filtered MIP-map texture lookups; the README notes it is used in commercial renderers and on many large VFX and animated films.
  • Pipeline engineers running oiiotool, idiff, or igrep in scripts for bulk format conversion, image comparison, and metadata searches.
  • Applications that need to inspect very large image libraries cheaply through ImageCache, holding TBs of files within a memory budget of tens of megabytes.

Getting started

The project is consumed as a C++ library with Python bindings, built from the source repository at https://github.com/AcademySoftwareFoundation/OpenImageIO. The README excerpt does not state a specific package, image, or compose file, so the documented build and usage instructions on https://openimageio.readthedocs.org are the place to start.

How it compares

No paid products this project replaces are named in the available facts, and no comparable open-source libraries are listed either, so it stands alone in this registry.

When to use it — and when not to

It is a developer library rather than an end-user application, so anyone without a C++ build toolchain and a codebase to integrate it into should not pick it, and there is no service to self-host — no database, storage, or SMTP to operate. The facts give no indication of a hosted or packaged one-command deployment, and 143 open issues remain, while a small amount of code incorporated from other projects is covered by third-party licenses rather than Apache-2.0.

project readme (upstream, from github) — read inline

License CI CII Best Practices latest packaged version(s)

Introduction

Mission statement: OpenImageIO is a toolset for reading, writing, and manipulating image files of any image file format relevant to VFX / animation via a format-agnostic API with a feature set, scalability, and robustness needed for feature film production.

The primary target audience for OIIO is VFX studios and developers of tools such as renderers, compositors, viewers, and other image-related software you'd find in a production pipeline.

OpenImageIO consists of:

  • Simple but powerful ImageInput and ImageOutput APIs that provide an abstraction for reading and writing image files of nearly any format, without the calling application needing to know any of the details of these file formats, and indeed without the calling application needing to be aware of which formats are available.

  • A library that manages subclasses of ImageInput and ImageOutput that implement I/O from specific file formats, with each file format's implementation stored as a plug-in. Therefore, an application using OpenImageIO's APIs can read and write any image file for which a plugin can be found at runtime.

  • Plugins implementing I/O for several popular image file formats, including TIFF, JPEG/JFIF, JPEG XL, OpenEXR, PNG, HDR/RGBE, ICO, BMP, Targa, JPEG-2000, RMan Zfile, FITS, DDS, Softimage PIC, PNM, DPX, Cineon, IFF, OpenVDB, Ptex, Photoshop PSD, Wavefront RLA, SGI, WebP, GIF, DICOM, HEIF/HEIC/AVIF, many "RAW" digital camera formats, and a variety of movie formats (readable as individual frames). More are being developed all the time.

  • Several command line image tools based on these classes, including oiiotool (command-line format conversion and image processing), iinfo (print detailed info about images), iconvert (convert among formats, data types, or modify metadata), idiff (compare images), igrep (search images for matching metadata), and iv (an image viewer). Because these tools are based on ImageInput/ImageOutput, they work with any image formats for which ImageIO plugins are available.

  • An ImageCache class that transparently manages a cache so that it can access truly vast amounts of image data (tens of thousands of image files totaling multiple TB) very efficiently using only a tiny amount (tens of megabytes at most) of runtime memory.

  • A TextureSystem class that provides filtered MIP-map texture lookups, atop the nice caching behavior of ImageCache. This is used in commercial renderers and has been used on many large VFX and animated films.

  • ImageBuf and ImageBufAlgo functions -- a simple class for storing and manipulating whole images in memory, and a collection of the most useful computations you might want to do involving those images, including many image processing operations.

  • Python bindings for all of the major APIs.

🏢 Project administration and Licensing

OpenImageIO is (c) Copyright Contributors to the OpenImageIO project.

For original code, we use the Apache-2.0 license, and for documentation, the Creative Commons Attribution 4.0 Unported License. In 2023 we asked historical users to relicense from the original BSD-3-clause license to Apache-2.0, and over 99.86% of lines of code have been relicensed to Apache-2.0. A small amount of code incorporated into this repository from other projects are covered by compatible third-party open source licenses.

The OpenImageIO project is part of the Academy Software Foundation, a part of the Linux Foundation formed in collaboration with the Academy of Motion Picture Arts and Sciences. The technical charter and Project Governance explain how the project is run, who makes decisions, etc. Please be aware of our Code of Conduct.

💁 User Documentation

OpenImageIO Documentation is the best place to start if you are interested in how to use OpenImageIO, its APIs, its component programs (once they are built). There is also a PDF version.

Additional resources:

  • User quick start is a quick example of using OpenImageIO in Python, C++, and the command line.
  • Releases -- see this for the latest release notes, also found in the CHANGES.md file.

👷 Building and installing OpenImageIO

🚑 Contact & reporting problems

Simple "how do I...", "I'm having trouble", or "is this a bug" questions are best asked on the oiio-dev developer mail list. That's where the most people will see it and potentially be able to answer your question quickly (more so than a GH "issue"). For quick questions, you could also try the ASWF Slack #openimageio channel.

A bug or build problem that you are relatively certain is a legit problem in the code, and for which you can give clear instructions for how to reproduce, should be reported as issues.

To report a security vulnerability that is serious enough that it should not be discussed publicly until a patch is ready, please file a GitHub security advisory.

If confidentiality precludes a public question or issue, you may contact us privately at info@openimageio.org, or for security-related issues security@openimageio.org.

🔧 Contributing and developer documentation

OpenImageIO welcomes code contributions, and nearly 250 people have done so over the years. We take code contributions via the usual GitHub pull request (PR) mechanism.

  • Architecture overview is a high-level description of the major classes and their relationships.
  • CONTRIBUTING has detailed instructions about the development process.
  • AI Policy decribes our policies on AI coding assistance tools.
  • ROADMAP is a high-level overview of the current development priorities for the next annual release.
  • RELEASING explains our policies and procedures for making releases. We have a major, possibly-compatibility-breaking, release annually in September/October, and minor bug fix and safe feature addition release at the beginning of every month.
  • Building the docs has instructions for building the documentation locally, which may be helpful if you are editing the documentation in nontrivial ways and want to preview the appearance.
  • Other developer documentation is in the docs/dev directory.
  • You may also have luck learning a bit about the organization and architecture of the project by reading the DeepWiki Analysis of OpenImageIO. But take it with a grain of salt -- like any LLM-generated summary, there may be inaccuracies lurking.

☎️ Communications channels and additional resources

Frequently asked questions

Is OpenImageIO free to use?

OpenImageIO 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 OpenImageIO do?

Reading, writing, and processing images in a wide variety of file formats, using a format-agnostic API, aimed at VFX applications.

What is OpenImageIO written in?

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