# Oink (0.1.0-alpha.5)

## Install

Download Oink from [oink.megasupersoft.com](https://oink.megasupersoft.com/#download). Each download has everything it needs: its own Python, colour management, fonts and FFmpeg. **You do not need Blender.** Blender is an optional extra, see [Engines and the Blender bridge](https://downloads.megasupersoft.com/oink/docs/concepts/engines).

## What you need

| | |
|---|---|
| Linux | x86-64, glibc 2.34 or newer (Rocky / RHEL 9, Ubuntu 22.04 and later) |
| Windows | Windows 10 or 11, 64-bit |
| macOS | Apple Silicon |
| Graphics card | OpenGL or Vulkan; every node runs on the GPU. The AI tools use an NVIDIA card; each model's graphics memory is listed in [AI models](https://downloads.megasupersoft.com/oink/docs/reference/ai-models) |

## Install

**Linux.** Extract the `.tar.xz` and run `./install.sh` inside it. It adds the menu entries and the `.oink` file type, so you can double-click a comp to open it (each double-click starts a new copy of the app, like Nuke). Nuke's `.nk` files are left alone.

**Windows.** Run the `-setup.exe` installer (it installs for your user, no administrator rights needed), or extract the portable `.zip` anywhere. The builds are not signed yet: if SmartScreen says "Windows protected your PC", choose **More info**, then **Run anyway**.

**macOS.** Open the `.dmg` and drag Oink to Applications. The first time, right-click Oink.app and choose **Open**, then **Open** again.

## Activate

The alpha needs a free licence. [Request one](https://oink.megasupersoft.com/#alpha) and the key comes by email. Paste it into the screen that appears on first launch. A licence covers two machines and keeps working offline for 14 days between check-ins; **Help > License...** shows it and lets you free a machine.

## Updates

The app checks for new builds and offers to install them; **Help > Check for Updates...** checks right away. Each build is checked against a signature before it installs.

## The AI tools

The AI nodes download their packages and models the first time you use them (several GB). See [AI models](https://downloads.megasupersoft.com/oink/docs/reference/ai-models) for sizes and licences.

## Blender (optional)

Opening `.blend` files, EEVEE, Storm and Alembic through Blender need Blender 5.2 LTS. Anything that needs it says so and offers an **Install Blender (optional)** button; the rest of the app works without it.

## Logs

If something goes wrong, the logs are in `~/.cache/opencomp/logs` (Linux), `~/Library/Logs/opencomp` (macOS) or `%LOCALAPPDATA%\opencomp\logs` (Windows). **Help > Report a Bug...** collects them for you; see [Logs & diagnostics](https://downloads.megasupersoft.com/oink/docs/logs-diagnostics).

## Licences

Oink is proprietary software (MegaSuperSoft, all rights reserved). The libraries it ships or downloads keep their own licences: see [Licences and source offer](https://downloads.megasupersoft.com/oink/docs/concepts/licences).

## Getting started

Oink is a node-based compositor. You build a comp by connecting nodes: images come in through Read nodes, pass through colour, merge, filter and transform nodes, and leave through Write nodes. Everything works in 32-bit float, scene-linear colour, on the GPU.

If you have used Nuke, most of this will be familiar: the nodes, knobs, keyboard shortcuts and .nk scripts are the same. See [For Nuke users](https://downloads.megasupersoft.com/oink/docs/nuke-users).

1. [Install and launch](https://downloads.megasupersoft.com/oink/docs/install): `./launch_opencomp.sh` from the repository folder.
2. [The interface](https://downloads.megasupersoft.com/oink/docs/getting-started/interface): the Viewer, Node Graph, Properties and the node toolbar.
3. [Your first comp](https://downloads.megasupersoft.com/oink/docs/getting-started/first-comp): Read, Grade, Viewer, Write, render.

Want to see finished comps first? **Help › Examples…** opens small example comps that use shipped sample media. A node's **?** button in the Properties panel lists the examples that use it.

You can also start with a file: `./launch_opencomp.sh comp.oink` (or a `.nk` script) opens it once the app is ready. Double-clicking a comp in your file manager does the same, and opens a new copy of the app each time, like Nuke. The installer registers the comp file icons and types.

Three things worth knowing early:

- Each Viewer node gets its own tab in the Viewer pane (Viewer1, Viewer2 …). A new Viewer (Ctrl+I) adds a tab; deleting the node removes it.
- **Workspace › Jobs** lists every background job (AI, renders, imports) next to Background Renders. Its *Services* view shows the helper processes the app started, with GPU and memory use per row.
- The highlight colour is Nuke orange by default. Change it in *Preferences › Appearance › UI Colors*.

## Your first comp

This takes about two minutes. Keep the mouse over the **Node Graph** while you press the node keys.

1. **Read the image.** Press **R**. A file browser opens; pick an image or a sequence (sequences show as one entry, like `plate.####.exr`). A [Read](https://downloads.megasupersoft.com/oink/docs/nodes/read) node appears.
2. **Look at it.** With the Read selected, press **1**. A [Viewer](https://downloads.megasupersoft.com/oink/docs/nodes/viewer) node is connected and the image shows in the Viewer. Press **F** over the Viewer to fit it.
3. **Grade it.** With the Read still selected, press **G**. A [Grade](https://downloads.megasupersoft.com/oink/docs/nodes/grade) node is added below it and connected, and its knobs open in Properties. Drag **gain** up and **gamma** a little; the Viewer updates as you drag. Press **1** again with the Grade selected to view it.
4. **Write it out.** With the Grade selected, press **W** to add a [Write](https://downloads.megasupersoft.com/oink/docs/nodes/write) node. Set its **file** knob, for example `/tmp/out/graded.####.exr` (`####` is the frame number). Pick the file type and the **output transform** (colour space) on the same panel.
5. **Render.** Press **F5** (or *Render › Render All…*). Confirm the frame range; a progress box shows each frame and has a Cancel button. **F7** renders only the selected Write.
6. **Save.** Press **Ctrl+S** to save the comp as an `.oink` file. Double-click an `.oink` file in your file manager to open it again. Comps saved before the rename, as `.ocomp`, still open.

## Next

- Press **Tab** in the Node Graph and type a name to add any node.
- Open **Help › Examples…** for small finished comps (keying, merging, 3D, AI tools) on sample media.
- Every node's knobs are listed in the [node reference](https://downloads.megasupersoft.com/oink/docs/nodes). Press **F1** over a node (or click **?** in its Properties panel, then **Documentation**) to jump to its page.
- Coming from Nuke? Read [For Nuke users](https://downloads.megasupersoft.com/oink/docs/nuke-users).

## For Nuke users

Oink is built so that a Nuke artist can sit down and work: the same node names, knob names, defaults, keyboard shortcuts and layout, and it reads and writes .nk scripts.

## The same as Nuke

- **Layout.** The Compositing workspace: Viewer top left, Node Graph bottom left, Properties on the right, node toolbar on the far left, grouped like Nuke's (Image, Draw, Time, Channel, Color, Filter, Keyer, Merge, Transform, 3D, Deep, …).
- **Keys.** Nuke 17's shortcut table, and a key goes to the panel under the mouse. Tab search, R/W/G/B/M/T/C/K/O node keys, 1–9 viewer inputs, D disable, Y splay, Ctrl+G group, F5 render, J/K/L playback. See [Keyboard shortcuts](https://downloads.megasupersoft.com/oink/docs/reference/shortcuts) for exactly which keys work.
- **Nodes and knobs.** Node classes and knob names follow Nuke (Grade's `blackpoint`, `whitepoint`, `multiply`, `gamma`; the standard `channels`, `mask`, `(un)premult by` and `mix` knobs on colour and filter nodes). Where our internal name differs, the .nk mapping translates it (Grade `white` is our `gain`); each [node page](https://downloads.megasupersoft.com/oink/docs/nodes) lists the Nuke knob next to ours.
- **Maths.** Merge operations follow the formulas in Foundry's Merge reference; Grade uses Nuke's formula. Everything is 32-bit float, scene-linear and unclamped until the display.
- **Coordinates.** Nuke's pixel convention: origin bottom left, y up. Bounding boxes, formats and data windows behave like Nuke's (see [Bounding box](https://downloads.megasupersoft.com/oink/docs/concepts/bbox)).
- **Scripts.** `.nk` files open, import and export, including Groups, gizmos, user knobs, expressions and Tcl. See [.nk import and export](https://downloads.megasupersoft.com/oink/docs/nuke-users/nk-import).
- **Python.** A `nuke` module with the familiar API, `menu.py` / `init.py` on the plugin path, and a Script Editor. See [Python](https://downloads.megasupersoft.com/oink/docs/nuke-users/python).
- **BlinkScript and OFX.** Blink kernels run on the GPU; OpenFX plugins load as nodes. See [BlinkScript and OFX](https://downloads.megasupersoft.com/oink/docs/nuke-users/blink-ofx).

## Different from Nuke

| Nuke | Oink |
|---|---|
| comps are `.nk` | comps are `.oink` (plain-text JSON); `.nk` is for exchange (*File › Open / Import / Export Nuke Script*) |
| Qt interface | a web-based interface; Python panels (`nukescripts.PythonPanel`) dock inside the app, while PySide tools open as floating windows from a separate Qt helper (see [Python](https://downloads.megasupersoft.com/oink/docs/nuke-users/python)) |
| Viewer process / input process | the Viewer applies an OCIO display and view chosen in the Viewer header; you can name an *input process* node in the Viewer settings and switch it on with the IP button (Alt+P) |
| NukeX / Studio licences | one app; CameraTracker, LensDistortion, Deep, the AI nodes and 3D are all included. The editorial side (timeline, conform, review) is the separate [Oink Review](https://downloads.megasupersoft.com/oink/docs/concepts/review) app |
| CopyCat, Smart Vector and similar | the AIR group: [Train](https://downloads.megasupersoft.com/oink/docs/nodes/aitrain), [AIVectorGenerator](https://downloads.megasupersoft.com/oink/docs/nodes/aivectorgenerator), [AIRoto](https://downloads.megasupersoft.com/oink/docs/nodes/airoto) and more, running local open models (see [AI tools](https://downloads.megasupersoft.com/oink/docs/concepts/ai)) |
| — | extra renderers in 3D: [CyclesRender](https://downloads.megasupersoft.com/oink/docs/nodes/cyclesrender) (built in, no Blender needed), [EEVEERender](https://downloads.megasupersoft.com/oink/docs/nodes/eeveerender) (optional Blender bridge), [HydraRender](https://downloads.megasupersoft.com/oink/docs/nodes/hydrarender); Cycles, Karma and Storm also render live inside the 3D Viewer (see [3D](https://downloads.megasupersoft.com/oink/docs/concepts/3d)) |
| 3D control type default: Nuke | default: Maya (Alt+left tumbles). Switch to the Nuke, Houdini, Lightwave or Modo scheme in Preferences > Panels > Viewer Handles |
| Blender not involved | no Blender needed; `.blend` files, EEVEE and a few Cycles passes work when you add it (see [Engines](https://downloads.megasupersoft.com/oink/docs/concepts/engines)) |

## Not built yet

Some Nuke features are missing. Their keys and menu items are still there but show "Not available yet" in the status bar. Among them: paint strokes in RotoPaint (its Roto shapes work), saving and deleting custom workspaces, Select Similar, Capture and monitor out, and a few Roto tool modes. Nuke nodes with no equivalent import as **Unsupported** placeholders and are written back unchanged.

Built since earlier versions: Project Settings (S) and Preferences, Precomp, clones, StickyNote, Flipbook, proxy mode, and per-view knob values for scripts with several views.

## Where to look up a Nuke node

The [Nuke node map](https://downloads.megasupersoft.com/oink/docs/nuke-users/node-map) lists every Nuke class that imports as a node here.

## .nk import

Oink reads and writes Nuke's `.nk` script format. Its own comps are `.oink` files; `.nk` is for exchanging work with Nuke.

## Ways in and out

| Action | What happens |
|---|---|
| *File › Open Nuke Script…* | replaces the comp with the script; the script's frame range, fps and format are applied |
| *File › Import Nuke Script…* | adds the script's nodes to the current comp (names made unique) |
| `./launch_opencomp.sh shot.nk` | opens the script at launch |
| *File › Export Nuke Script…* | writes the whole comp, or only the selected nodes |
| Ctrl+C / Ctrl+V | the clipboard holds real Nuke node text: nodes copied in Nuke paste here, and nodes copied here paste into Nuke |

After an import, a summary lists the Nuke classes that had no equivalent.

## How nodes are translated

- Each Nuke class maps to one node; the full list is the [Nuke node map](https://downloads.megasupersoft.com/oink/docs/nuke-users/node-map). Knobs with the same name carry over; renamed knobs are translated both ways (each [node page](https://downloads.megasupersoft.com/oink/docs/nodes) lists them).
- **Unsupported nodes.** A class with no equivalent becomes an [Unsupported](https://downloads.megasupersoft.com/oink/docs/nodes/unsupported) node: drawn red, all its knobs kept, input 0 passed straight through. On export it is written back exactly as it was read, so a round trip through Oink does not lose it.
- A node's `label` that only repeats its own name (an old automatic label) is dropped on paste and import, so a renamed node does not show two names.
- Knobs we do not use are kept and written back unchanged.
- **Groups** become real Group nodes; Ctrl+Enter opens one, Ctrl+Backspace goes back up. Nested groups work.
- **Gizmos.** A class that matches a `.gizmo` file on the plugin path imports as a Group built from that file, and exports as the gizmo class again (without its children, as Nuke writes it). The plugin path, searched in order: `$OPENCOMP_PLUGIN_PATH`, `~/.opencomp/gizmos`, `$NUKE_PATH`, `~/.nuke` (with sub-folders). Gizmos found there also appear in the Tab menu.
- **User knobs** (`addUserKnob`) on any node are shown on their own tabs in Properties, keep their values and animation, and are written back. Link knobs follow their target.
- **Expressions and Tcl.** Knob expressions (including `parent.`, `input0.` and node-name references) and the Tcl that Nuke scripts use are evaluated. `[python ...]` calls go to the [`nuke` Python module](https://downloads.megasupersoft.com/oink/docs/nuke-users/python).
- **Several views.** A script with views (for example left and right) keeps them: the views and their colours are read from the Root settings, and a number, colour or checkbox knob with per-view values (`{default left 1 right 2}`) imports with those values. In Properties, *Split off* and *Unsplit* beside a knob make or remove a per-view value. The values are written back to the `.nk`.
- **Precomp.** A Precomp reads its own `.nk` file; its contents are not written into the parent script.
- **Roto and Tracker.** Classic Roto bezier shapes (with feather and animation) and Tracker4 track tables import. Paint strokes and some per-shape attributes do not; the original shape text is kept and written back.
- **BlinkScript** kernels import with their source and parameter values (see [BlinkScript and OFX](https://downloads.megasupersoft.com/oink/docs/nuke-users/blink-ofx)). **OFX** nodes import when the plugin is installed. Read and Write nodes for movies keep Nuke's `mov64` knob names, so movie settings survive a round trip (see [Movies and web formats](https://downloads.megasupersoft.com/oink/docs/concepts/movies)).

## Round trips

Import, export and import again gives the same graph. Unsupported nodes, unknown knobs and the original Root settings are carried through, so a script can go Nuke → Oink → Nuke without losing what Oink does not understand.

## Command-line render

`render.sh` (Windows: `render.bat`) in the install folder renders a script with no window and no display. It takes Nuke's command-line flags and prints Nuke's progress lines, so a render-farm plugin written for `nuke -x` can call it instead.

```
./render.sh -x -F 1-100 -X Write1 shot.nk
./render.sh -F 1001-1100x5 --cont -m 8 comp.oink
./render.sh --cpu -F 1 comp.oink          # no GPU: software rendering
```

## Flags

| Flag | What it does |
|---|---|
| `<script>` | a `.oink` or `.nk` script (an `.nk` is imported first) |
| `-x` | render. Accepted for Nuke compatibility; rendering is the default |
| `-F <range>` | frames: `1-100`, `1-100x5` (every 5th), `1,5,10`. Repeat `-F` for more ranges. Default: the script's frame range |
| `-X <Write>` | render only this Write node. Repeat it (or use `Write1,Write2`) for several. Default: every enabled Write, in render order |
| `-m <n>` | number of threads |
| `--cont` | keep going after a frame fails |
| `-f` | full size (the default) |
| `-p` | proxy: not supported yet (Write nodes have no proxy file path); exits with code 2 |
| `-V [level]` | more output: `1` script loading and the checks, `2` everything, including the engine's own messages |
| `-q` | quiet: only the progress lines and errors |
| `--view <name>` | views to render; scripts have one view, `main` |
| `-i` | accepted and ignored (there is no interactive licence) |
| `--gpu [N]`, `--gpu-index N` | render on GPU number N (also sets `CUDA_VISIBLE_DEVICES=N`) |
| `--cpu` | render with no GPU, on Mesa's software Vulkan driver (lavapipe). Same pixels, slower |
| `--require-gpu` | fail with exit code 3 if the machine has no working GPU and the engine fell back to a software renderer |
| `--renderer any\|gpu\|cpu` | the same choice as one flag, for farm templates: `gpu` = `--require-gpu`, `cpu` = `--cpu` |
| `--json` | also print machine-readable `OCBG {...}` event lines |
| `--no-verify` | skip reading each written file back |
| `--openjd` | also print Open Job Description progress lines, which AWS Deadline Cloud shows as task progress |
| `--path-map <file>` | remap file paths in the script (Read, Write...) with Open Job Description path-mapping rules (JSON) |
| `--list-writes` | print the script's Write nodes as JSON (name, enabled, order, output path, frame range, dependencies) and exit; for farm submitters |
| `--localize` | read the local copies made by Localization (when they match their source by size and time) instead of the network files. Same as Nuke's `--use-local-file-cache` |
| `--worker` | run this machine as a LAN render-farm worker (see [LAN render farm](https://downloads.megasupersoft.com/oink/docs/nuke-users/lan-render-farm)) |
| `--collect <script> <dest>` | copy the comp and every file it uses into a folder (like File > Collect Files). Options: `--all-frames`, `--proxies`, `--ai-caches`, `--no-ocio`, `--zip` |
| `--prep-show <edl, otio, folder or json> --out <dir>` | analyse every shot of a show (see [Prep Show](https://downloads.megasupersoft.com/oink/docs/concepts/prep-show)). Options: `--shots`, `--chunk i/n`, `--merge-only` |
| `--diag-bundle [--out F.zip]` | write a redacted diagnostic zip (see [Logs and diagnostics](https://downloads.megasupersoft.com/oink/docs/logs-diagnostics)) |
| `--mcp-setup [claude-code\|claude-desktop]` | connect Claude Code or Claude Desktop to the running app's MCP server |
| `--version` | print the version |

Other Nuke flags a farm may pass (`--nukex`, `--priority`, `-c`, …) are accepted and ignored.

## Output

The first line says what it renders on, so a farm log shows at once when a machine lost its GPU:

```
Renderer: GPU, NVIDIA GeForce RTX 4090/PCIe/SSE2 (OPENGL, NVIDIA Corporation)
Renderer: CPU (software: llvmpipe), llvmpipe (LLVM 20.1.8, 256 bits) (OPENGL, Mesa)
```

On a software renderer that you did not ask for (`--cpu`) it also prints `WARNING: no GPU: ...`. Add `--require-gpu` to make that an error instead (exit code 3). The pixels are the same either way: a CPU render matches the GPU one to within float rounding.

For each frame it prints the same lines Nuke does:

```
Frame 1001 (1 of 100)
Writing /shots/sh010/comp/sh010_comp.1001.exr took 0.42 seconds
...
Total render time: 43.18 seconds
```

Each frame is also checked for NaN or infinite pixels and for an all-black frame. A flagged frame is still written, and a line like `WARNING: Write1: frame 1004: black frame (every RGB value is 0)` is printed.

Errors start with `ERROR:`, for example `ERROR: Write1: frame 1004: bad output ... (file removed)`.

## Checks before and after rendering

Before the first frame it stops, listing every problem at once, when:

- input files are missing (the list shows each missing file and the Read node that needs it);
- an OFX plugin or a gizmo the script uses is not installed;
- an output folder does not exist (unless the Write has **create directories** on) or cannot be written to;
- there is no usable GPU (use `--gpu-index` to pick another one, or `--cpu`).

Image frames are written to a hidden temporary file in the same folder and renamed when complete, so nothing sees a half-written frame. After each file is written it is read back: it must exist, be larger than zero bytes, open, have every pixel readable, and have the expected resolution and channels. A partial or broken file counts as a failed frame and is deleted.

## Exit codes

| Code | Meaning |
|---|---|
| 0 | every frame written and checked |
| 1 | a frame failed, or the script could not be loaded, or the preflight check failed |
| 2 | bad command line |
| 3 | no usable GPU (or, with `--require-gpu`, only a software renderer) |
| 130 / 143 | stopped by Ctrl-C / SIGTERM |

## Stopping a render

The first SIGTERM or Ctrl-C lets the frame being rendered finish, then stops. A second one aborts that frame and deletes its partial file. With `--cont`, frames that fail are skipped and the exit code is still 1.

## On a render farm

- Point the farm's Nuke executable at `render.sh` (or `render.bat`) and keep its usual Nuke command line.
- Every GPU render takes the machine's GPU lease, so one GPU job runs at a time on a machine: a second render (or an AI job) waits for the first. Renders with `--cpu` do not need the lease.
- A machine with no GPU can render with `--cpu`.

## AI tools

The **AIR** button on the node toolbar holds nodes that use machine-learning models: rotoscoping, matte refinement, keying, depth and normals, optical flow and retiming, upscaling and denoising, clean plates, generation, and training your own models.

| Task | Nodes |
|---|---|
| Mattes and roto | [AIRoto](https://downloads.megasupersoft.com/oink/docs/nodes/airoto), [AIMatteRefine](https://downloads.megasupersoft.com/oink/docs/nodes/aimatterefine), [AIKeyer](https://downloads.megasupersoft.com/oink/docs/nodes/aikeyer) |
| Depth, normals, materials | [AIDepth](https://downloads.megasupersoft.com/oink/docs/nodes/aidepth), [AINormals](https://downloads.megasupersoft.com/oink/docs/nodes/ainormals), [AIMaterials](https://downloads.megasupersoft.com/oink/docs/nodes/aimaterials), used by [Relight](https://downloads.megasupersoft.com/oink/docs/nodes/relight) |
| Motion | [AIVectorGenerator](https://downloads.megasupersoft.com/oink/docs/nodes/aivectorgenerator), [VectorDistort](https://downloads.megasupersoft.com/oink/docs/nodes/vectordistort), [VectorBlur](https://downloads.megasupersoft.com/oink/docs/nodes/vectorblur), [Retime](https://downloads.megasupersoft.com/oink/docs/nodes/retime) |
| Clean-up | [AIUpscale](https://downloads.megasupersoft.com/oink/docs/nodes/aiupscale), [AIDenoise](https://downloads.megasupersoft.com/oink/docs/nodes/aidenoise), [AICleanPlate](https://downloads.megasupersoft.com/oink/docs/nodes/aicleanplate) |
| Generation | [GenFill](https://downloads.megasupersoft.com/oink/docs/nodes/genfill), [GenVideo](https://downloads.megasupersoft.com/oink/docs/nodes/genvideo), [ComfyUI](https://downloads.megasupersoft.com/oink/docs/nodes/comfyui) |
| Training | [Train](https://downloads.megasupersoft.com/oink/docs/nodes/aitrain) and [Inference](https://downloads.megasupersoft.com/oink/docs/nodes/aiinference) (like Nuke's CopyCat), [SplatTrain](https://downloads.megasupersoft.com/oink/docs/nodes/splattrain) |

## How they run

- Models run in a separate **AI worker** process on your own GPU (CPU if there is no GPU); frames are not sent to any online service. The [ComfyUI](https://downloads.megasupersoft.com/oink/docs/nodes/comfyui) node is the exception by design: it sends work to a ComfyUI server that you run.
- The worker's Python environment is created the first time an AI node needs it, in `~/.cache/opencomp/ai-venv` (several GB).
- Model files are downloaded the first time a node needs them, into `~/.cache/opencomp/models`, and checked against a known size and checksum before use. `OPENCOMP_AI_OFFLINE=1` stops all downloads.
- Heavy jobs take a machine-wide GPU "lease", so two big jobs never fight for GPU memory; a job waiting for the GPU says who holds it and can be cancelled.
- Results are cached per frame, so scrubbing back does not rerun the model.

## AI workflows

These sit on top of the nodes and run on your machine. None of them changes your comp without a click or an approval.

- **Review and fix.** A confidence score per frame for AIRoto mattes (no model needed) puts red ticks on the timeline. **Alt+]** and **Alt+[** jump to the next or previous flagged frame. One correction click re-runs only the frames around it, and stops before the next frame you corrected yourself.
- **Auto QC.** `qc_check` (an Assistant tool) looks for NaN or infinite pixels, black or duplicate frames, flicker, holes and jumps in a matte, and missing files. On 12 real frames a clean sequence gave no flags, and five faults added on purpose were all found.
- **Suggestions.** The Read, AIRoto, AIDepth and CameraTracker panels show up to three suggestion chips, worked out from rules and the shot's [Prep Show](https://downloads.megasupersoft.com/oink/docs/concepts/prep-show) report (for example Fix bad frames, Remove markers, Denoise plate, Roto people, Solve camera). A click runs the recipe as one undo step.
- **Regrain.** The [Grain](https://downloads.megasupersoft.com/oink/docs/nodes/grain) node has a **Match shot** button that measures the plate's grain at the current frame and sets size, intensity and black. GenFill's `regrain` knob adds the plate's grain to the filled area.
- **Whole-show batches** (Assistant tools, one approval each, shown in the Jobs panel and undoable): fix bad frames in every shot, roto all the people, and solve cameras for every shot. Hidden cuts stored on the Read stop FrameFixer and PlateDenoise from reaching across a cut.
- **Pre-compute while idle.** Off by default. When on (a checkbox in the Jobs panel), after 60 seconds with no edits it warms AIRoto's image data for the current frame and the next two, one job at a time, only if the AI worker is already running and the GPU is free. Any edit cancels it at once.

Some of these were built and tested without running the models; the model results are still being checked on the GPU.

## Licence tiers

Every model has a licence tier:

| Tier | Meaning |
|---|---|
| **bundled** | permissive licence (Apache, MIT, BSD). Downloads on first use. |
| **optional** | commercial use is allowed but with extra terms (for example the SAM License or NVIDIA's Open Model License). Nothing downloads until you read and accept the licence in the node's panel. |
| **research** | the [research pack](https://downloads.megasupersoft.com/oink/docs/concepts/research-pack): non-commercial weights, for research and evaluation only, never for paid or delivered work. Each user reads and accepts the licence in the node's panel before anything downloads; a studio AI policy can forbid the pack. |

Oink never redistributes model weights: they come from their publishers to your machine. The full list of models, their licences, sizes and sources is in [AI models and licences](https://downloads.megasupersoft.com/oink/docs/reference/ai-models).

## Privacy

**Alpha and beta builds send crash reports and daily anonymous usage counts by default.** Neither ever includes your footage, file paths, file or node names, or anything you typed. Turn either off in **Help > Privacy...**, which also lists everything that was sent.

## What the app sends

| What | When | Contents |
|---|---|---|
| Crash reports | when the app or engine crashes | what crashed and where in the code; home folder names are masked |
| Usage counts | once a day | launches, minutes used, which nodes and renderers, app version, OS, GPU and RAM size, a random install id |
| Licence check-in | when you activate, then about once a day | your licence key and a machine ID |
| Update check | at launch, or **Help > Check for Updates...** | reads the list of versions; sends nothing about you |

| Build | Crash reports and usage counts |
|---|---|
| Alpha, beta | on by default, turn off in **Help > Privacy...** |
| Stable releases | asks you first |
| Built from source | never sent |

The app also uses the network when you ask it to: downloading AI models or sample media, opening the documentation or a bug report page, a cloud AI provider your administrator allowed, or a render farm you set up.

## What is never collected

- Pixels: no Viewer contents, thumbnails or screenshots.
- File paths, file, folder, project, show, shot or sequence names.
- Node names, knob values, expressions, scripts.
- Your user name, computer name or email (the licence keeps the name and email you gave when you asked for it).

## When you report a problem

You decide, every time. **Help > Copy Diagnostic Bundle...** makes a zip on your computer with paths and names removed, and you can open every file in it before you save it. **Help > Report a Bug...** opens a pre-filled page in your browser; nothing is sent until you submit it. Logs stay on your computer ([Logs & diagnostics](https://downloads.megasupersoft.com/oink/docs/logs-diagnostics)).

## For studios

A studio policy file (`/etc/opencomp/policy.json`) turns everything off: `"offline": true` stops crash reports, usage counts, downloads, the online documentation and cloud AI providers, without even a DNS lookup. `"crash_reports": "local"` and `"usage_counts": "off"` turn off just those two. Machines on your own network (a LAN render farm, a local ComfyUI server) keep working. See [Studio policy](https://downloads.megasupersoft.com/oink/docs/logs-diagnostics#studio-policy).

## Websites

The product site and these docs count page views with PostHog, without cookies: the page, download clicks, and your OS and the version you picked. Form contents are never sent. If your browser sends Do Not Track, nothing is counted.