OpenPype

Introduction

Open-source pipeline for visual effects and animation built on top of the Avalon framework, expanding it with extra features and integrations. OpenPype connects your DCCs, asset database, project management and time tracking into a single system. It has a tight integration with ftrack, but can also run independently or be integrated into a different project management solution.

OpenPype provides a robust platform for your studio, without the worry of a vendor lock. You will always have full access to the source-code and your project database will run locally or in the cloud of your choice.

To get all the information about the project, go to OpenPype.io

Requirements

We aim to closely follow VFX Reference Platform

OpenPype is written in Python 3 with specific elements still running in Python2 until all DCCs are fully updated. To see the list of those, that are not quite there yet, go to VFX Python3 tracker

The main things you will need to run and build OpenPype are:

• Terminal in your OS
  • PowerShell 5.0+ (Windows)
  • Bash (Linux)
• Python 3.9.6 or higher
• MongoDB (needed only for local development)

It can be built and ran on all common platforms. We develop and test on the following:

• Windows 10
• Linux
  • Ubuntu 20.04 LTS
  • Centos 7
• Mac OSX
  • 10.15 Catalina
  • 11.1 Big Sur (using Rosetta2)

For more details on requirements visit requirements documentation

Building OpenPype

To build OpenPype you currently need Python 3.9 as we are following vfx platform. Because of some Linux distros comes with newer Python version already, you need to install 3.9 version and make use of it. You can use perhaps pyenv for this on Linux. Note: We do not support 3.9.0 because of this bug. Please, use higher versions of 3.9.x.

Windows

You will need Python >= 3.9.1 and git. More tools might be needed for installing dependencies (for example for OpenTimelineIO) - mostly development tools like CMake and Visual Studio

Clone repository:

git clone --recurse-submodules git@github.com:ynput/OpenPype.git

To build OpenPype:

1. Run .\tools\create_env.ps1 to create virtual environment in .\venv.
2. Run .\tools\fetch_thirdparty_libs.ps1 to download third-party dependencies like ffmpeg and oiio. Those will be included in build.
3. Run .\tools\build.ps1 to build OpenPype executables in .\build\.

To create distributable OpenPype versions, run ./tools/create_zip.ps1 - that will create zip file with name openpype-vx.x.x.zip parsed from current OpenPype repository and copy it to user data dir, or you can specify --path /path/to/zip to force it there.

You can then point Igniter - OpenPype setup tool - to directory containing this zip and it will install it on current computer.

OpenPype is build using CX_Freeze to freeze itself and all dependencies.

macOS

You will need Python >= 3.9 and git. You'll need also other tools to build some OpenPype dependencies like CMake and XCode Command Line Tools (or some other build system).

Easy way of installing everything necessary is to use Homebrew:

1. Install Homebrew:

    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Install cmake:

   brew install cmake

3. Install pyenv:

   brew install pyenv
   echo 'eval "$(pyenv init -)"' >> ~/.zshrc
   pyenv init
   exec "$SHELL"
   PATH=$(pyenv root)/shims:$PATH

4. Pull in required Python version 3.9.x:

   # install Python build dependences
   brew install openssl readline sqlite3 xz zlib
   
   # replace with up-to-date 3.9.x version
   pyenv install 3.9.6

5. Set local Python version:

   # switch to OpenPype source directory
   pyenv local 3.9.6

To build OpenPype:

1. Run .\tools\create_env.sh to create virtual environment in .\venv
2. Run .\tools\fetch_thirdparty_libs.sh to download third-party dependencies like ffmpeg and oiio. Those will be included in build.
3. Run .\tools\build.sh to build OpenPype executables in .\build\

Linux

Docker

Easiest way to build OpenPype on Linux is using Docker. Just run:

sudo ./tools/docker_build.sh

This will by default use Debian as base image. If you need to make Centos 7 compatible build, please run:

sudo ./tools/docker_build.sh centos7

If all is successful, you'll find built OpenPype in ./build/ folder.

Docker build can be also started from Windows machine, just use ./tools/docker_build.ps1 instead of shell script.

This could be used even for building linux build (with argument centos7 or debian)

Manual build

You will need Python >= 3.9 and git. You'll also need curl on systems that doesn't have one preinstalled.

To build Python related stuff, you need Python header files installed (python3-dev on Ubuntu for example).

You'll need also other tools to build some OpenPype dependencies like CMake. Python 3 should be part of all modern distributions. You can use your package manager to install git and cmake.

Details for Ubuntu

Install git, cmake and curl

sudo apt install build-essential checkinstall
sudo apt install git cmake curl

Note:

In case you run in error about xcb when running OpenPype, you'll need also additional libraries for Qt5:

sudo apt install qt5-default

or if you are on Ubuntu > 20.04, there is no qt5-default packages so you need to install its content individually:

sudo apt-get install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools

Details for Centos

Install git, cmake and curl

sudo yum install qit cmake

Note:

In case you run in error about xcb when running OpenPype, you'll need also additional libraries for Qt5:

sudo yum install qt5-qtbase-devel

Use pyenv to install Python version for OpenPype build

You will need bzip2, readline, sqlite3 and other libraries.

For more details about Python build environments see:

https://github.com/pyenv/pyenv/wiki#suggested-build-environment

For Ubuntu:

sudo apt-get update; sudo apt-get install --no-install-recommends make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev libffi-dev liblzma-dev

For Centos:

yum install gcc zlib-devel bzip2 bzip2-devel readline-devel sqlite sqlite-devel openssl-devel tk-devel libffi-devel

install pyenv

curl https://pyenv.run | bash

# you can add those to ~/.bashrc
export PATH="$HOME/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

# reload shell
exec $SHELL

# install Python 3.9.x
pyenv install -v 3.9.6

# change path to OpenPype 3
cd /path/to/openpype-3

# set local python version
pyenv local 3.9.6

To build OpenPype:

1. Run .\tools\create_env.sh to create virtual environment in .\venv
2. Run .\tools\build.sh to build OpenPype executables in .\build\

Running OpenPype

OpenPype can by executed either from live sources (this repository) or from "frozen code" - executables that can be build using steps described above.

If OpenPype is executed from live sources, it will use OpenPype version included in them. If it is executed from frozen code it will try to find latest OpenPype version installed locally on current computer and if it is not found, it will ask for its location. On that location OpenPype can be either in directories or zip files. OpenPype will try to find latest version and install it to user data directory (on Windows to %LOCALAPPDATA%\pypeclub\openpype, on Linux ~/.local/share/openpype and on macOS in ~/Library/Application Support/openpype).

From sources

OpenPype can be run directly from sources by activating virtual environment:

poetry run python start.py tray

This will use current OpenPype version with sources. You can override this with --use-version=x.x.x and then OpenPype will try to find locally installed specified version (present in user data directory).

From frozen code

You need to build OpenPype first. This will produce two executables - openpype_gui(.exe) and openpype_console(.exe). First one will act as GUI application and will not create console (useful in production environments). The second one will create console and will write output there - useful for headless application and debugging purposes. If you need OpenPype version installed, just run ./tools/create_zip(.ps1|.sh) without arguments and it will create zip file that OpenPype can use.

Building documentation

Top build API documentation, run .\tools\make_docs(.ps1|.sh). It will create html documentation from current sources in .\docs\build.

Note that it needs existing virtual environment.

Running tests

To run tests, execute .\tools\run_tests(.ps1|.sh).

Note that it needs existing virtual environment.

Developer tools

In case you wish to add your own tools to .\tools folder without git tracking, it is possible by adding it with dev_* suffix (example: dev_clear_pyc(.ps1|.sh)).

Contributors ✨

Thanks goes to these wonderful people (emoji key):

Milan Kolar 💻 📖 🚇 💼 🖋 🔍 🚧 📆 👀 🧑‍🏫 💬	Jakub Ježek 💻 📖 🚇 🖋 👀 🚧 🧑‍🏫 📆 💬	Ondřej Samohel 💻 📖 🚇 🖋 👀 🚧 🧑‍🏫 📆 💬	Jakub Trllo 💻 📖 🚇 👀 🚧 💬	Petr Kalis 💻 📖 🚇 👀 🚧 💬	64qam 💻 👀 📖 🚇 📆 🚧 🖋 📓	Roy Nieterau 💻 📖 👀 🧑‍🏫 💬
Toke Jepsen 💻 📖 👀 🧑‍🏫 💬	Jiri Sindelar 💻 👀 📖 🖋 ✅ 📓	Simone Barbieri 💻 📖	karimmozilla 💻	Allan I. A. 💻	murphy 💻 👀 📓 📖 📆	Wijnand Koreman 💻
Bo Zhou 💻	Clément Hector 💻 👀	David Lai 💻 👀	Derek 💻 📖	Gábor Marinov 💻 📖	icyvapor 💻 📖	Jérôme LORRAIN 💻
David Morris-Oliveros 💻	BenoitConnan 💻	Malthaldar 💻	Sven Neve 💻	zafrs 💻	Félix David 💻 📖	Alexey Bogomolov 💻

This project follows the all-contributors specification. Contributions of any kind welcome!