Skip to content

Introduction

Warning

Bip is under active development and is only used by the Blinkink studio team. It is not recommended deploying it yet elsewhere.

For developers, Bip is an API, a framework, and a toolset for automating animation productions.

Client/Server

Bip is built in a client/server architecture.

The server (bop), not yet implemented as a Python API, hosts a Neo4j graph database, and will serve the production data through a RESTful API.

Info

For now, the server side only consists of a Neo4j instance, to which the client (bip), speaks directly.

The client (bip), installed on each user machine with the installer, provides an update system, an environment manager, self-managed dependency system, batch launcher, client-side API and default apps. It comes with a self-managed Python 3.9 virtual environment.

In the future, the client backbone will be a headless agent, but for now, the agent role is handled by one of the Bip apps: the Launcher.

The Launcher is the client entry point. When started, it checks for internal updates as well as dependencies requirements. It also changes the PYTHONPATH so that every application launched with it can import bip from its python runtime, if any.

Who is this documentation for?

  • Core developer: You are working on improving Bip, you will find here the reference for both public and private API, as well as design documents and guidelines.
  • App developer: You want to create a BipApp, the SDK is documented in the toolkit reference.
  • Plugin developer: You want to extend Bip with a new DCC or production tracker, the extension guidelines can be found in the plugin reference.
  • Advanced TD: As a TD, you need to interact with the client API, mostly link, for your scripts. You will find here the reference for the public API.

Features

  • API: Manipulate production data with an object-oriented API
  • SDK: Framework for creating your own application or integrate your own DCC/Production tracker
  • Plugins: DCC and Production trackers handled as plugins
  • Updates: Updates are managed internally with Git
  • Self-contained: Bip runs from its own Python Venv
  • Dependencies: Internal dependencies are automatically managed
  • Login: Safe user authentication and privilege system
  • Batches: API built upon JeanPaulStart for managing DCC deployment, configuration and environment
  • Integration: Default integrations for Modo, Nuke and Maya
  • Builtins: Collection of commands and batches
  • Apps: Collection of BipApps covering basic agnostic CG pipeline steps

Workflow model

In production, the Client is associated with a Content git repository, which contains workflow decisions, through batches, presets, configuration files.

Bip is agnostic by design when it comes to workflow and dataflow, so it is left to the administrators and TD to tune their Bip instance to comply with their practices, habits and conventions, by adapting the content repository.

Info

For more information about how to use the Content, see the TD documentation...

Specifications

Bip is built in Python, the UI is made with Pyside, the data is managed with Neo4j and is tracked with Gitlab.

dev_logos_banner

  • Language: Python 3.9
  • Database: Neo4j 5.10
  • GUI: PySide 2

Because production data is mostly about tracking relationships, it has been chosen to use a Graph database, Neo4j. It allows to have a flexible data model and provides an easy request logic. Read more about Neo4j and graph databases here.

Core applications

Bip comes with builtins BipApps:

  • Brioche: Launcher.
  • Bugne: Updater.
  • Clafoutis: Manager.
  • Kouglof: Scene loader.
  • Moka: Scene editor.

Dependencies

Core

Formats

  • PyYAML: configuration
  • Markdown: documentation

Utils

  • OpenCV: image data reading
  • pynput: shortcut mapping
  • packaging: version parsing

Future

See the development roadmap and milestones.