Overview

Relevant source files

• Assets/YooAsset/CHANGELOG.md
• Assets/YooAsset/CHANGELOG.md.meta
• README.md

Purpose and Scope

This document provides a high-level introduction to the YooAsset resource management system for Unity3D. It covers the overall architecture, major subsystems, and how they interact to provide build-time asset bundling and runtime asset loading capabilities.

For specific information about:

• System initialization and the public API, see YooAssets Static API and System Initialization
• Resource loading mechanisms, see Resource Loading System
• Build configuration and asset collection, see Asset Collection System
• Editor tools and workflows, see Editor Tools and Utilities

What is YooAsset

YooAsset is a comprehensive asset bundle management framework for Unity3D that handles the complete lifecycle of game assets from build-time collection and packaging to runtime loading and memory management. The system is production-ready, having been validated in commercial games with millions of daily active users.

The framework addresses key requirements for modern game development:

• Asset bundling with zero redundancy through automatic dependency analysis
• Multiple deployment scenarios (offline, online, WebGL, mini-games)
• Hot update and version management capabilities
• Memory-efficient reference counting and lifecycle management
• Play-while-downloading functionality for large asset libraries

Sources: README.md1-72 Assets/YooAsset/CHANGELOG.md1-72

System Architecture

YooAsset consists of three primary subsystems that operate at different phases of the game development lifecycle:

Sources: High-level system diagrams (Diagram 1, Diagram 2)

Core Components

Public API Layer

The YooAssets static class serves as the primary entry point for all runtime operations. It manages global initialization, package creation, and system-wide configuration. Individual resource packages are represented by ResourcePackage instances, which encapsulate a collection of assets with their own manifest and file systems.

Key classes:

• YooAssets - Static facade providing system initialization and package management
• ResourcePackage - Represents a single asset package with its own resources and configuration

For detailed API documentation, see YooAssets Static API and System Initialization and Resource Packages and Play Modes.

Sources: High-level system diagrams (Diagram 1)

Build-Time Systems

The build-time systems execute only in the Unity Editor and are responsible for collecting assets, analyzing dependencies, and producing asset bundles along with metadata.

Key components:

• AssetBundleCollector - Configures which assets to include using packages, groups, and collectors with extensible rule systems
• BuildMapContext - Processes collected assets, resolves dependencies, assigns bundle names, and removes unreferenced assets
• Build Pipeline Tasks - Three pipeline implementations: Scriptable Build Pipeline (SBP), Raw File Build Pipeline (RFBP), and Builtin Pipeline
• Manifest Generator - Produces PackageManifest files in multiple formats (JSON for debugging, binary for runtime, hash files for verification)

The build process is highly configurable through BuildParameters and supports features like encryption, compression, and custom naming conventions.

For detailed build system documentation, see Asset Bundle Build System.

Sources: High-level system diagrams (Diagram 1, Diagram 2)

Runtime Systems

The runtime systems manage asset loading, caching, downloading, and memory lifecycle during game execution.

Key components:

• File System Layer - Abstraction over different storage backends (builtin, cache, editor simulation, web servers) through the IFileSystem interface
• ResourceManager - Orchestrates asset loading through a provider-based architecture with reference counting
• OperationSystem - Manages all asynchronous operations with priority handling and time-slicing to prevent frame drops

The runtime architecture supports five operational modes:

1. EditorSimulateMode - Editor-only simulation without building asset bundles
2. OfflinePlayMode - Standalone games using only builtin assets
3. HostPlayMode - Online games with remote asset updates
4. WebPlayMode - WebGL deployments with web-specific loading
5. CustomPlayMode - User-defined file system configurations

For detailed runtime documentation, see Core Runtime Architecture.

Sources: High-level system diagrams (Diagram 1, Diagram 3)

File System Architecture

The file system layer provides a unified interface (IFileSystem) with multiple implementations:

Implementation	Purpose	Primary Use Case
DefaultEditorFileSystem	Editor simulation using AssetDatabase	Development/testing without builds
DefaultBuiltinFileSystem	StreamingAssets access	Read-only resources in the installation package
DefaultCacheFileSystem	Downloaded bundle management	Remote assets with caching and verification
DefaultWebServerFileSystem	Direct web loading	WebGL same-origin deployments
DefaultWebRemoteFileSystem	Cross-domain web loading	WebGL cross-domain scenarios
WechatFileSystem	WeChat Mini Game platform	WeChat-specific file handling
TiktokFileSystem	TikTok Mini Game platform	TikTok-specific file handling
GooglePlayFileSystem	Google Play Asset Delivery	Android dynamic feature delivery

Each file system handles bundle loading, verification, and platform-specific concerns. The cache file system includes sophisticated download management with concurrent downloads, resume support, and integrity verification.

For detailed file system documentation, see File System Architecture.

Sources: High-level system diagrams (Diagram 4), Assets/YooAsset/CHANGELOG.md219-221 Assets/YooAsset/CHANGELOG.md312-317

Build-Time to Runtime Data Flow

The following diagram illustrates how data flows from editor-time configuration through the build process to runtime consumption:

The data transformation pipeline:

1. Configuration Phase: YooAssetSettings and CollectorSettings define global settings and asset collection rules
2. Collection Phase: CollectResult contains all assets matching the configured rules with metadata
3. Build Map Phase: BuildMapContext assigns bundle names, resolves dependencies, and applies packing rules
4. Build Execution: Build pipeline tasks execute platform-specific builds producing asset bundles
5. Manifest Generation: PackageManifest is serialized in multiple formats containing all asset and bundle metadata
6. Runtime Deployment: Manifests and bundles are deployed to file systems (builtin/remote)
7. Runtime Loading: ResourcePackage loads manifests and creates AssetInfo and BundleInfo objects for queries

Sources: High-level system diagrams (Diagram 2, Diagram 5)

Runtime Initialization and Loading

The runtime lifecycle follows this sequence:

Key initialization parameters determine the operational mode:

• EditorSimulateModeParameters - For editor simulation
• OfflinePlayModeParameters - For offline/standalone games
• HostPlayModeParameters - For online games with updates
• WebPlayModeParameters - For WebGL deployments
• CustomPlayModeParameters - For custom file system configurations

Sources: High-level system diagrams (Diagram 3), Assets/YooAsset/CHANGELOG.md634-648

Operation System and Async Management

All asynchronous operations in YooAsset are managed by the OperationSystem, which provides:

• Unified async interface: All operations derive from AsyncOperationBase with consistent status, progress, and completion callbacks
• Time-slicing: Prevents frame drops by distributing work across multiple frames
• Priority handling: Critical operations can be prioritized over background tasks
• Lifecycle management: Automatic cleanup and reference tracking

Common operation types:

• InitializeOperation - Package initialization
• UpdatePackageVersionOperation - Version checking
• UpdatePackageManifestOperation - Manifest updates
• ResourceDownloaderOperation - Multi-file downloads
• Asset loading operations (AssetHandle, SceneHandle, RawFileHandle)
• UnloadSceneOperation - Scene cleanup

Sources: High-level system diagrams (Diagram 1, Diagram 5), Assets/YooAsset/CHANGELOG.md277-292

Service Interfaces and Extension Points

YooAsset provides pluggable service interfaces for customization without modifying core code:

Interface	Purpose	Configuration Phase
IEncryptionServices	Bundle encryption at build time	Build parameters
IDecryptionServices	Bundle decryption at runtime	File system parameters
IManifestProcessServices	Manifest compression/encryption	Build parameters
IManifestRestoreServices	Manifest decompression/decryption	Runtime parameters
IRemoteServices	Custom CDN URL resolution	File system parameters
ICopyLocalFileServices	Custom file copy logic	File system parameters

These interfaces enable scenarios like:

• Custom encryption schemes for asset protection
• CDN failover and load balancing
• Manifest compression to reduce download sizes
• Platform-specific file handling

For implementation examples, see Service Interfaces and Extension Points and Custom Service Implementation Examples.

Sources: High-level system diagrams (Diagram 4, Diagram 5), Assets/YooAsset/CHANGELOG.md376-408

Package Structure and Dependencies

YooAsset is distributed as a Unity package with the following structure:

• Runtime assembly (YooAsset.Runtime.dll) - Core runtime systems, no editor dependencies
• Editor assembly (YooAsset.Editor.dll) - Build systems, collector windows, analysis tools
• Scriptable Build Pipeline dependency - Optional, required for SBP build mode

The system integrates with Unity's build pipeline and supports Unity versions 2019.4 and newer. Platform support includes Windows, macOS, Linux, iOS, Android, WebGL, and console platforms.

For detailed package structure and installation instructions, see Package Structure and Unity Integration.

Sources: README.md1-72 Assets/YooAsset/CHANGELOG.md1-50

Version and Compatibility

YooAsset uses semantic versioning. The current major version (2.x) represents a significant architecture evolution from 1.x with the introduction of the file system abstraction layer. The manifest format has also evolved, with version 2.2.5+ manifests incompatible with older runtime versions.

Key version features:

• 2.3.x - Latest stable with mini-game support, asset dependency database optimization
• 2.2.x - File system layer introduction, custom play modes
• 2.1.x - Shared resource packing, improved download system
• 2.0.x - Major architecture refactor from 1.5.x

For migration guidance between versions, see Migration Guide.

Sources: Assets/YooAsset/CHANGELOG.md5-1130 Assets/YooAsset/CHANGELOG.md196-198

Summary

YooAsset provides a complete asset management solution for Unity with:

1. Flexible build system - Multiple pipelines with extensible rules and zero redundancy
2. Robust runtime loading - Reference counting, async operations, play-while-downloading
3. Platform adaptability - File system abstraction supporting diverse deployment scenarios
4. Production-ready - Validated in commercial games with millions of users

The architecture cleanly separates build-time and runtime concerns while maintaining data flow through the PackageManifest as the central contract between these phases.

Sources: README.md1-72 High-level system diagrams (All diagrams)