OpenPype as a standalone product has reach end of it's life and this repository has now been archived in favour of ayon-core. You can read more details about the end of life process here https://community.ynput.io/t/openpype-end-of-life-timeline/877
Thank you all for years of amazing contributions and see you in AYON!
Please refer to https://github.com/ynput/OpenPype/blob/develop/CONTRIBUTING.md for more information about the current PR process.
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
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
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.
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
git clone --recurse-submodules [email protected]:ynput/OpenPype.git- Run
.\tools\create_env.ps1to create virtual environment in.\venv. - Run
.\tools\fetch_thirdparty_libs.ps1to download third-party dependencies like ffmpeg and oiio. Those will be included in build. - Run
.\tools\build.ps1to 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.
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:
-
Install Homebrew:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" -
Install cmake:
brew install cmake
-
Install pyenv:
brew install pyenv echo 'eval "$(pyenv init -)"' >> ~/.zshrc pyenv init exec "$SHELL" PATH=$(pyenv root)/shims:$PATH
-
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
-
Set local Python version:
# switch to OpenPype source directory pyenv local 3.9.6
- Run
.\tools\create_env.shto create virtual environment in.\venv - Run
.\tools\fetch_thirdparty_libs.shto download third-party dependencies like ffmpeg and oiio. Those will be included in build. - Run
.\tools\build.shto build OpenPype executables in.\build\
Easiest way to build OpenPype on Linux is using Docker. Just run:
sudo ./tools/docker_build.shThis will by default use Debian as base image. If you need to make Centos 7 compatible build, please run:
sudo ./tools/docker_build.sh centos7If 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)
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 curlsudo apt install build-essential checkinstall
sudo apt install git cmake curlIn case you run in error about xcb when running OpenPype,
you'll need also additional libraries for Qt5:
sudo apt install qt5-defaultor 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-toolsDetails for Centos
Install git, cmake and curlsudo yum install qit cmakeIn case you run in error about xcb when running OpenPype,
you'll need also additional libraries for Qt5:
sudo yum install qt5-qtbase-develUse 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-devFor Centos:
yum install gcc zlib-devel bzip2 bzip2-devel readline-devel sqlite sqlite-devel openssl-devel tk-devel libffi-develinstall 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
- Run
.\tools\create_env.shto create virtual environment in.\venv - Run
.\tools\build.shto build OpenPype executables in.\build\
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).
OpenPype can be run directly from sources by activating virtual environment:
poetry run python start.py trayThis 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).
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.
To 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.
To run tests, execute .\tools\run_tests(.ps1|.sh).
Note that it needs existing virtual environment.
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)).
Thanks goes to these wonderful people (emoji key):
This project follows the all-contributors specification. Contributions of any kind welcome!