Link Search Menu Expand
ButterStack Documentation
⌘K

5-Stage Asset Lineage Pipeline

The foundation of ButterStack’s asset tracking system.

Table of contents

  1. Overview
  2. Stage 1: Task Assignment
  3. Stage 2: Version Control
  4. Stage 3: CI/CD Build
  5. Stage 4: Game Engine Build
  6. Stage 5: Deployment
  7. Data Flow
  8. Querying Lineage
  9. Getting Started

Overview

ButterStack tracks your game assets through five distinct stages, from initial task creation to production deployment. This complete visibility helps teams understand exactly where any asset is in the development pipeline.

┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐   ┌─────────┐
│ Stage 1 │──▶│ Stage 2 │──▶│ Stage 3 │──▶│ Stage 4 │──▶│ Stage 5 │
│  TASK   │   │   VCS   │   │  CI/CD  │   │ ENGINE  │   │ DEPLOY  │
│         │   │         │   │         │   │         │   │         │
│  Jira   │   │Perforce │   │ Jenkins │   │ Unreal  │   │ Steam   │
│  Linear │   │  Git    │   │         │   │ Unity   │   │ Epic    │
│  Trello │   │Diversion│   │         │   │         │   │ Mobile  │
└─────────┘   └─────────┘   └─────────┘   └─────────┘   └─────────┘

Stage 1: Task Assignment

Purpose: Track which work items are associated with asset changes.

Supported Tools:

  • Jira (full two-way sync)
  • Linear (webhook integration)
  • Trello (board sync)
  • Monday.com (coming soon)
  • Asana (coming soon)

What We Track:

  • Task creation and updates
  • Assignee changes
  • Status transitions
  • Links between tasks and commits

How It Works: When you reference a task in your commit message (e.g., PROJ-123: Updated character texture), ButterStack automatically links that commit to the task.

Stage 2: Version Control

Purpose: Monitor commits, changelists, and file changes across your source control system.

Supported Tools:

  • Perforce (full changelist sync with P4Ruby)
  • Git / GitHub / GitLab (repository integration)
  • Diversion (cloud-native asset management)

What We Track:

  • Commit/changelist metadata
  • File lists and change types
  • Author information
  • Branch associations
  • Binary asset changes

Perforce-Specific Features:

  • Full depot browser
  • Hidden depot path filtering
  • Trigger-based webhooks
  • Changelist to build correlation

Configuration Example:

# Perforce integration
server_url: ssl:perforce.company.com:1666
username: butterstack-service
project_path: //depot/MyGame/...
hidden_depot_paths:
  - spec
  - unload

Stage 3: CI/CD Build

Purpose: Track automated builds and correlate them with source changes.

Supported Tools:

  • Jenkins (full integration)

What We Track:

  • Build triggers (manual, webhook, scheduled)
  • Build status (pending, in progress, success, failed)
  • Build duration
  • Associated changelists/commits
  • Build artifacts
  • Console output

Automatic Build Triggers: Include specific tags in your commit message to trigger builds:

  • #ci - Trigger default build job
  • #build - Trigger default build job
  • #jenkins - Trigger default build job

Example Commit Message:

PROJ-456: Added new weapon models #ci

- Added assault rifle mesh
- Added pistol mesh
- Updated weapon material instances

Stage 4: Game Engine Build

Purpose: Observe game engine-specific build processes including asset cooking, shader compilation, and packaging.

Supported Engines:

  • Unreal Engine 5 (full support)
  • Unity (coming soon)

What We Track:

  • Build phases (cooking, compiling shaders, packaging, archiving)
  • Per-asset cooking metrics
  • Shader permutation counts
  • DDC (Derived Data Cache) hit rates
  • Cook times per asset type
  • PAK file sizes
  • Compression ratios

Build Phases:

initializing → cooking → compiling_shaders → packaging → archiving → completed
                                                                    ↘ failed

Cooked Asset Tracking: For each cooked asset, we capture:

  • Asset path and type (texture, mesh, material, blueprint, audio, animation)
  • Cook time in milliseconds
  • Original and cooked file sizes
  • Compression ratio
  • Success/failure status

Integration Methods:

  1. Log Parsing - Parse Unreal build logs for cooking events
  2. Webhook Callbacks - Send events from build scripts to ButterStack
  3. Jenkins Integration - Receive events via Jenkins build steps

Webhook Endpoints:

POST /webhooks/game_engine/cooking_started
POST /webhooks/game_engine/asset_cooked
POST /webhooks/game_engine/shaders_started
POST /webhooks/game_engine/shaders_completed
POST /webhooks/game_engine/packaging_started
POST /webhooks/game_engine/build_completed
POST /webhooks/game_engine/build_failed

Stage 5: Deployment

Purpose: Track when and where your builds are deployed to distribution platforms.

Supported Platforms:

  • Steam (full API integration)
  • Epic Games Store (coming soon)
  • Google Play (coming soon)
  • Apple App Store (coming soon)
  • Unity Cloud (coming soon)
  • Custom platforms (webhook-based)

What We Track:

  • Deployment submission
  • Upload progress
  • Review status
  • Live/published status
  • Rollback events

Deployment Statuses:

pending → submitted → uploading → in_review → approved → live
                                           ↘ rejected   ↗
                                                    rolled_back

Steam-Specific Features:

  • Build status via Partner Web API
  • Branch/beta information
  • Depot version monitoring
  • Live build detection

Configuration Example:

# Steam integration
steam_app_id: "480"
steam_branch: "public"
steam_poll_interval: 300  # seconds

Data Flow

Here’s how data flows through the 5-stage pipeline:

Developer creates task in Jira
         │
         ▼
Developer commits to Perforce with "PROJ-123: ..." and "#ci"
         │
         ▼
ButterStack receives webhook, links commit to task
         │
         ▼
Perforce/GitHub triggers Jenkins build
         │
         ▼
Jenkins runs Unreal BuildCookRun
         │
         ▼
ButterStack receives game engine build events
         │
         ▼
Build completes, ButterStack creates Asset Manifest
         │
         ▼
Team reviews and approves manifest
         │
         ▼
Approved build manually uploaded to Steam
         │
         ▼
ButterStack polls Steam API, updates deployment status
         │
         ▼
Deployment goes live, full lineage complete

Querying Lineage

With the complete pipeline connected, you can answer questions like:

  • “Which task was this asset created for?”
  • “Who last modified this texture?”
  • “Which build includes change 12345?”
  • “What assets were cooked in this build?”
  • “When did this build go live on Steam?”
  • “Which commits are in production but not yet approved?”

Getting Started

  1. Set up your first integration
  2. Configure Perforce webhooks
  3. Connect Jenkins
  4. Add task management
  5. Enable deployment tracking

Back to top

Copyright © 2026 ButterStack. All rights reserved.