Skip to content
Fluxx

Plugin SDK

The Plugin SDK is the surface that lets external developers (vendors, partners, internal engineers) extend Fluxx without modifying the core. Standard pipeline frameworks have wildly different approaches to plugin SDKs; Fluxx’s plugin path taxonomy is informed by what each framework got right and wrong.

The SDK is the moat. Quality of the SDK determines the ceiling on third-party adoption (Kevin, S124 build phase note). Fluxx’s plugin path taxonomy ports five categories from AYON and adds four Fluxx-native categories for the architectural primitives that have no standard analog.

Per-framework comparative

AYON (Ynput, the strongest reference)

Comparative score 30/35.

  • Declared via package.py manifest at addon repo root.
  • Discovered via launcher reading AYON_LAUNCHER_STORAGE_DIR.
  • Scoped via Pydantic settings models with four scopes (studio, project, site, studio-site).
  • Distributed via bundles (Production, Staging, Development modes) pinned at server tier, server-pushed to client.
  • Versioned via semver in manifest plus compatibility constraints (ayon_required_addons, ayon_compatible_addons).

Strengths: Lifecycle 5/5, Extensibility 5/5, Events 5/5, Community 5/5, Docs 4/5. Weaknesses: DCC Framework 4/5 (per-DCC depth is the thinnest area of the otherwise strong SDK), Hot-reload 2/5 (undocumented; known weak spot of OpenPype lineage).

ftrack Connect Framework (Backlight)

Comparative score 24/35 (low confidence; research pass blocked on details).

2024-2025 rollout covering Photoshop, Maya, Nuke, Houdini, Premiere Pro, and Toon Boom plus native cineSync 5 and iconik integrations. APIs: Python plus REST plus GraphQL. Lifecycle hooks not extracted in research pass. The pattern interest is on the ftrack side (how ftrack reacts to Fluxx-emitted events via the transmitter, per the leecher / processor / transmitter pattern in AYON Port / Reject), not as a pattern to port into Fluxx’s plugin SDK.

ShotGrid Toolkit / Autodesk Flow Production Tracking

Comparative score 27/35 (low confidence; research pass blocked on details post-rebrand).

Three-tier decomposition: Apps (user-facing), Engines (DCC-side), Frameworks (shared libraries). Pipeline Configuration concept per-project (analogous to AYON’s bundle-per-project but more mature). Best DCC coverage in category: Maya, Nuke, Houdini, 3ds Max, Premiere Pro, AE, Avid MC (via Flow Capture, September 2025). Python plus REST plus GraphQL.

Reject as direct reference. Proprietary lock-in, Autodesk-controlled, walled docs post-Flow rebrand. The three-tier decomposition is interesting; everything else is closed.

OpenPype (legacy, archived September 20 2024)

Server-first AYON rewrite resolved OpenPype’s accumulated technical debt: cleaner addon SDK, versioned manifests, bundle-based distribution, more disciplined event spine. GitHub repo carries explicit notice: “OpenPype as a standalone product has reach end of it’s life and this repository has now been archived in favour of ayon-core.”

OpenPype-to-AYON migration tooling: GAP, not located in research pass. Entity rename in the transition: Asset → Folder, Subset → Product. The migration history is the strongest argument that pipeline frameworks need server-first architecture from v0.1 rather than retrofitting it later.

Pyblish (narrow scope)

Comparative score 21/35 (narrow scope).

Validate / extract / integrate three-stage pattern. Used inside OpenPype, AYON, and many studio pipelines. Within its narrow scope highly extensible; outside that scope (load, settings, lifecycle) does not opine.

Verbatim port at the publish-stage tier for Fluxx. Integrate-step substrate diverges (Vault not file system).

Fluxx plugin path taxonomy

Five categories ported from AYON

  • actions, user-triggered operations (menu items, buttons, automations)
  • create, content-creation primitives (new asset, new shot, new task)
  • load, fetch from Vault into the DCC session
  • publish, Pyblish-shaped validate / extract / integrate to Vault
  • inventory, track loaded content within a session

Four categories Fluxx-native

  • provenance, AI provenance handlers (ingest, display, enforcement). Surfaces the schema defined in Pipeline Architecture > Vault primitive 3. Implemented via IProvenancePlugin marker.
  • track-assign, finish-track assignment logic (Near-Time versus Near-Time VFX). Implemented via ITrackAssignPlugin marker. See Pipeline Architecture > primitive 4.
  • stage, stage configuration plus ComposiTrack plus RapidWall configuration. Surfaces stage configuration events (stage.configuration_loaded, stage.wall_repositioned, stage.lighting_recipe_applied). Implemented via IStagePlugin marker.
  • cost-attribution, per-pass cost attribution hooks for the multi-tenant cost ledger.

Six settings scopes (vs AYON’s four)

Pydantic settings models with BaseSettingsModel and SettingsField. Fluxx extends AYON’s four-scope hierarchy:

  1. tenant (Fluxx-native, multi-tenant scope)
  2. production (Fluxx-native, per-production overrides)
  3. studio (ported from AYON)
  4. project (ported from AYON)
  5. site (ported from AYON)
  6. tenant-site (Fluxx-native, per-tenant per-site overrides)

Lifecycle extended with VM lifecycle hooks

Five AYON-style hooks plus two Fluxx-native:

  • on_session_start (ported)
  • on_session_end (ported)
  • on_context_change (ported)
  • on_vm_provisioned (Fluxx-native, fires when the pipeline service finishes provisioning a VM)
  • on_vm_teardown (Fluxx-native, fires before VM release; flush state, emit final events, release locks)

What Fluxx explicitly does not take

The Reject catalogue in AYON Port / Reject affects SDK shape directly:

  • LAN-and-file-system substrate. SDK load paths resolve cloud object storage URLs, not file system paths. Plugin authors do not see local paths; they see Vault content hashes that the bridge translates.
  • Local-launcher distribution. SDK distribution is via VM image baking at provision time, not artist-side pip install. The fluxxd in-VM daemon replaces the desktop launcher.
  • Single-tenant data model. Every settings scope carries tenant. Plugin authors who fail to scope are caught at the schema layer.

Vendor integration story

A vendor like Norman / GlassBox writes a Fluxx plugin and gets the following out of the box:

  1. Authentication and tenant isolation via FLUXX_TENANT_ID and FLUXX_API_KEY injected at VM provision time.
  2. Vault access via the SDK’s load and publish paths. Vendor plugins never touch file system directly; they go through Vault content-addressed APIs. Storage backend is transparent (s3://, gs://, az://).
  3. Event spine subscription to the persistent and fire-and-forget streams, including tenant-scoped events.
  4. VM lifecycle hooks for pre-warming caches, registering services, flushing state on teardown.
  5. AI provenance attachment via IProvenancePlugin; the vendor’s generated content gets the full schema attached at integrate-time.
  6. Cost attribution. The vendor’s render passes emit cost.attributable_event events; the multi-tenant cost ledger picks them up automatically.
  7. C2PA Content Credentials pass-through. Frame.io and IPTC Digital Source Type are format-standard read-write surfaces Fluxx supports without vendor implementation.

The vendor integrates via the SDK; the vendor does not need to integrate the Vault, the cost ledger, the event spine, or the C2PA pipeline separately. Those come with the SDK.

See Documents > Process Docs > Vendor Integration Path for the operational layer above the SDK.

AI-side integrations are inputs, not pipeline-surface integrations

Most upstream AI generators (Runway, Autodesk Flow Studio / Wonder Dynamics, Krea AI, Move.ai, Beeble AI, Cuebric) are input layers to Vault rather than pipeline-surface integrations. Their output feeds Vault as AI-derived asset provenance (full schema attached). The bounding line from Q-G33 holds: every final delivered pixel passes through V-Ray, Nuke, or Houdini; human actors never re-rendered generatively (Q-G50).

cineSync and SyncSketch are integration targets at the review-surface tier, not pattern-port targets. Coreweave-shape GPU clouds and Conductor-style multi-cloud abstractions are substrate options for Fabrixx; the cost-attribution layer above is Fluxx-owned and provider-agnostic.

Source dependencies

  • 02_Working/Pipeline_Research/Plugin_SDK_Comparative.md (primary)
  • 02_Working/Pipeline_Research/AYON_Architecture_Deep_Dive.md (AYON SDK reference)
  • 02_Working/Pipeline_Research/Fluxx_Pipeline_Architecture_v0.1.md (Fluxx plugin path taxonomy origin)
  • 02_Working/Pipeline_Research/sources/ayon_core.md, ayon_tracker_addons.md

Synthesis gap

Plugin SDK scope at v0.1 is not locked per Fluxx_Pipeline_Architecture_v0.1.md §10 gap item 5: “Public SDK for third-party studios from v0.1, or internal-only with public SDK at v1.0? Affects governance, distribution, security review surface, marketing.” Kevin call.

Audience visibility

industry, vendor, counsel.