Unity Manual

• Unity User Manual 2023.1
  • Documentation versions
  • Offline documentation
  • Trademarks and terms of use
• New in Unity 2023.1
• Packages and feature sets
  • Released packages
    • 2D Animation
    • 2D Aseprite Importer
    • 2D Pixel Perfect
    • 2D PSD Importer
    • 2D SpriteShape
    • 2D Tilemap Extras
    • Adaptive Performance
    • Addressables
    • Ads Mediation
    • Advertisement Legacy
    • AI Navigation
    • Alembic
    • Analytics
    • Android Logcat
    • Animation Rigging
    • Apple ARKit XR Plugin
    • AR Foundation
    • Authentication
    • Build Automation
    • Burst
    • CCD Management
    • Cinemachine
    • Cloud Code
    • Cloud Diagnostics
    • Cloud Save
    • Code Coverage
    • Collections
    • Deployment
    • Device Simulator Devices
    • Editor Coroutines
    • FBX Exporter
    • Friends
    • Google ARCore XR Plugin
    • In App Purchasing
    • Input System
    • iOS 14 Advertising Support
    • JetBrains Rider Editor
    • Leaderboards
    • Live Capture
    • Lobby
    • Localization
    • Magic Leap XR Plugin
    • Matchmaker
    • Mathematics
    • Memory Profiler
    • ML Agents
    • Mobile Notifications
    • Multiplay
    • Multiplayer Tools
    • Netcode for GameObjects
    • Oculus XR Plugin
    • OpenXR Plugin
    • Player Accounts
    • Polybrush
    • Post Processing
    • ProBuilder
    • Profile Analyzer
    • Push Notifications
    • Python Scripting
    • Recorder
    • Relay
    • Remote Config
    • Scriptable Build Pipeline
    • Sequences
    • Splines
    • Sysroot Base
    • Sysroot Linux x64
    • System Metrics Mali
    • Terrain Tools
    • Test Framework
    • TextMeshPro
    • Timeline
    • Toolchain Linux x64
    • Toolchain MacOS Linux x64
    • Toolchain Win Linux x64
    • Tutorial Authoring Tools
    • Tutorial Framework
    • Unity Distribution Portal
    • Unity OpenXR Meta
    • Unity Profiling Core API
    • Unity Transport
    • User Generated Content
    • User Generated Content Bridge
    • User Reporting
    • Version Control
    • Visual Scripting
    • Visual Studio Editor
    • WebGL Publisher
    • XR Hands
    • XR Interaction Toolkit
    • XR Plugin Management
  • Release Candidates
  • Pre-release packages
    • Economy
    • Entities
    • Entities Graphics
    • Havok Physics for Unity
    • Moderation
    • Netcode for Entities
    • Unity Logging
    • Unity Physics
    • Vivox
  • Core packages
    • 2D Sprite
    • 2D Tilemap Editor
    • Core RP Library
    • High Definition RP
    • Shader Graph
    • Unity UI
    • Universal RP
    • Visual Effect Graph
  • Built-in packages
    • AI
    • Android JNI
    • Animation
    • Asset Bundle
    • Audio
    • Cloth
    • Director
    • Image Conversion
    • IMGUI
    • JSONSerialize
    • NVIDIA
    • Particle System
    • Physics
    • Physics 2D
    • Screen Capture
    • Terrain
    • Terrain Physics
    • Tilemap
    • UI
    • UIElements
    • Umbra
    • Unity Analytics
    • Unity Web Request
    • Unity Web Request Asset Bundle
    • Unity Web Request Audio
    • Unity Web Request Texture
    • Unity Web Request WWW
    • Vehicles
    • Video
    • VR
    • Wind
    • XR
  • Experimental packages
  • Packages by keywords
  • Deprecated packages
  • Unity's Package Manager
    • How Unity works with packages
    • Concepts
      • Package states and lifecycle
      • Dependency and resolution
      • Global Cache
    • Configuration
      • Solving network issues
      • Scoped registry authentication
      • Customize the global cache location
      • Customize the Asset Store cache location
      • Using private repositories with HTTPS Git URLs
      • Using passphrase-protected SSH keys with SSH Git URLs
        • Loading SSH keys automatically on Windows (OpenSSH)
        • Loading SSH keys automatically on Windows (PuTTY)
        • Loading SSH keys automatically on macOS
    • Package Manager window
      • Access the Package Manager window
      • List view
      • Details view
      • Features (detail) view
      • Finding packages and feature sets
        • Packages list context
        • Sorting the list
        • Filtering the list
        • Search box
      • Adding and removing
        • Install a feature set from the Unity registry
        • Install a package from a registry
        • Install a package from a local folder
        • Install a package from a local tarball file
        • Install a package from a Git URL
        • Install a package from a registry by name
        • Removing an installed package from a project
        • Disabling a built-in package
        • Switching to another package version
        • Importing an Asset Store package
        • Updating your Asset Store package
        • Remove imported assets from a project
        • Delete a package from the Asset Store cache
        • Perform an action on multiple packages
      • Finding package documentation
    • Inspecting packages
      • Package Manifest window
    • Scripting API for packages
      • Accessing package assets
    • Scoped registries
    • Resolution and conflict
      • Lock files
    • Project manifest
      • Embedded dependencies
      • Git dependencies
      • Local folder or tarball paths
    • Troubleshooting
      • Diagnose network issues
  • Creating custom packages
    • Naming your package
    • Package layout
    • Adding tests to a package
    • Creating samples for packages
    • Package manifest
      • Versioning
    • Assembly definition and packages
    • Meeting legal requirements
    • Documenting your package
    • Sharing your package
  • Feature sets
    • 2D feature set
    • 3D Characters and Animation feature set
    • 3D World Building feature set
    • AR feature set
    • Cinematic Studio feature set
    • Engineering feature set
    • Gameplay and Storytelling feature set
    • Mobile feature set
    • VR feature set
• Install Unity
  • System requirements for Unity 2023.1
  • Install Unity from the command line
  • Install Unity offline without the Hub
  • Deploy Unity across your enterprise
    • Enable Unity installation by standard users (Windows)
    • Using Unity through web proxies
      • Enable automatic proxy configuration
      • Store credentials for automatic proxy configuration
      • Trusting the web proxy security certificate
      • Use environment variables to identify your web proxy
      • Create a command file to set environment variables and open applications
      • Define exceptions on your web proxy
• Licenses and activation
  • License activation methods
  • Manage your license through the command line
  • Manual license activation
    • Submit a license request from the Hub
    • Submit a license request from a command line and browser (Windows)
    • Submit a license request from a command line and browser (macOS, Linux)
  • License Troubleshooting
• Upgrade Unity
  • API updater
  • Upgrade to Unity 2023.1
  • Upgrade to Unity 2022 LTS
  • Upgrade to Unity 2022.2
  • Upgrade to Unity 2022.1
  • Upgrade to Unity 2021 LTS
  • Upgrade to Unity 2020 LTS
  • Upgrading to Unity 2019 LTS
• Create with Unity
  • 2D or 3D projects
  • Unity's interface
    • The Project window
    • The Scene view
      • Overlays
        • Default Scene view overlay reference
        • Display or hide an overlay
        • Position an overlay
        • Manage overlay layouts
        • Create and manage overlay configurations
        • Create your own overlay
      • Position GameObjects
        • Grid snapping
      • Scene view navigation
      • Scene view Camera
      • Pick and select GameObjects
      • Scene visibility
      • Scene view View Options toolbar
      • Gizmos menu
      • Custom Editor tools
    • The Game view
    • Device Simulator
      • Device Simulator introduction
      • The Simulator view
      • Simulated classes
      • Adding a device
      • Extending the device simulator
    • The Hierarchy window
    • The Inspector window
      • Working in the Inspector
      • Focused Inspectors
    • Editing properties
    • The Toolbar
    • The status bar
    • The Background Tasks window
    • Console Window
    • Additional windows
    • Undo
    • Search in the Editor
    • Customizing your workspace
    • Unity shortcuts
  • Quickstart guides
    • 3D game development quickstart guide
      • Creating a 3D game
  • Advanced best practice guides
  • Create Gameplay
    • Scenes
      • Creating, loading, and saving Scenes
      • Work with multiple scenes in Unity
        • Set up multiple scenes
        • Bake data in multiple scenes
        • Use scripts to edit multiple scenes
      • Scene Templates
        • Creating scene templates
        • Editing scene templates
        • Customizing new scene creation
        • Scene template settings
    • GameObjects
      • Transforms
      • Introduction to components
      • Use components
      • Primitive and placeholder objects
        • Types of 2D primitive GameObjects
      • Create components with scripts
      • Deactivate GameObjects
      • Tags
      • Static GameObjects
      • Save your work
    • Prefabs
      • Creating Prefabs
      • Editing a Prefab in Prefab Mode
      • Instance overrides
      • Editing a Prefab via its instances
      • Nested Prefabs
      • Prefab Variants
      • Overrides at multiple levels
      • Unused Overrides
      • Unpacking Prefab instances
    • Layers
      • Uses of layers in Unity
      • Create functional layers in Unity
      • Layer-based collision detection
      • Layers and layerMasks
        • Set a layerMask
        • Add a layer to a layerMask
        • Remove a layer from a layerMask
    • Constraints
      • Aim Constraints
      • Look At Constraints
      • Parent Constraints
      • Position Constraints
      • Rotation Constraints
      • Scale Constraints
    • Rotation and orientation in Unity
    • Lights
    • Cameras
    • Cross-Platform Considerations
    • Publishing Builds
      • Reducing the file size of your build
      • Build Player Pipeline
    • Troubleshooting
  • Editor Features
    • 2D and 3D mode settings
    • Preferences
    • Shortcuts Manager
    • Build Settings
    • Incremental build pipeline
    • Project Settings
      • Audio
      • Editor
      • Graphics
      • Package Manager
      • Physics
      • Physics 2D reference
      • Player
        • Splash Image Player settings
      • Preset Manager
      • Quality
      • Script Execution Order settings
      • Tags and Layers
      • Time
      • UI Toolkit project settings
    • Visual Studio C# integration
    • RenderDoc Integration
    • Editor Analytics
    • Check For Updates
    • IME in Unity
    • Version Control
      • Version control integrations
      • Perforce Integration
      • Smart merge
    • Safe Mode
    • Command-line arguments
      • Unity Editor command line arguments
      • Unity Standalone Player command line arguments
      • Batch mode and built-in coroutine compatibility
    • Text-Based Scene Files
      • Format of Text Serialized files
      • UnityYAML
      • An Example of a YAML Scene File
      • YAML Class ID Reference
    • Troubleshooting The Editor
  • Analysis
    • Memory in Unity
      • Managed memory
      • Memory allocator customization
      • Garbage collector overview
        • Incremental garbage collection
        • Disabling garbage collection
        • Garbage collection best practices
    • Profiler overview
      • Profiling your application
      • Common Profiler markers
      • The Profiler window
        • Asset Loading Profiler module
        • Audio Profiler module
        • CPU Usage Profiler module
        • File Access Profiler module
        • Global Illumination Profiler module
        • GPU Usage Profiler module
        • Memory Profiler module
        • Physics Profiler module
        • Physics 2D Profiler module
        • Rendering Profiler module
        • UI and UI Details Profiler
        • Video Profiler module
        • Virtual Texturing Profiler module
      • Customizing the Profiler
        • Creating custom Profiler counters
        • Creating Custom Profiler modules
          • Profiler Module Editor
        • Creating a custom module details panel
      • Low-level native plug-in Profiler API
    • Profiling tools
      • Analyzing profiler traces
    • Log files
    • Understanding optimization in Unity
      • Asset auditing
      • Strings and text
      • The Resources folder
      • General Optimizations
      • Special optimizations
    • Asset loading metrics
• Asset workflow
  • Importing assets
    • Importing assets simultaneously
  • Supported Asset Types
    • Built-in Importers
    • Scripted Importers
    • Importer Consistency
    • Text assets
  • Asset Metadata
  • The Asset Database
    • Refreshing the Asset Database
    • Customizing the Asset Database workflow
    • Batching with the AssetDatabase
  • Special folder names
  • Import Activity window
  • Presets
    • Supporting presets
    • Applying default presets to Assets by folder
  • AssetBundles
    • AssetBundle workflow
    • Preparing Assets for AssetBundles
    • AssetBundle Dependencies
    • Output of the Build
    • Using AssetBundles Natively
    • AssetBundle compression and caching
    • Patching with AssetBundles
    • Troubleshooting
    • AssetBundle Download Integrity and Security
    • Multi-Process AssetBundle Building (Experimental)
  • Scripting with Assets
    • Loading Resources at Runtime
    • Streaming Assets
    • Modifying Source Assets Through Scripting
  • Asset packages
    • Create and export asset packages
    • Importing local asset packages
    • Removing local asset packages
  • Archives
• Input
  • Input Manager
  • Mobile device input
    • Mobile Keyboard
  • Unity XR Input
• 2D game development
  • Introduction to 2D
  • 2D game development quickstart guide
    • Game perspectives for 2D games
    • Art styles for 2D games
    • Initial setup for 2D games
    • Creating a 2D game
  • 2D Sorting
  • Work with sprites
    • Set up sprites
    • Sort sprites
    • Sprite Renderer
    • Sprite Creator
    • Sprite Editor
      • Use the Sprite Editor
      • Automatic slicing
      • Resize polygons
      • Sprite Editor: Custom Outline
      • Sprite Editor: Custom Physics Shape
      • Sprite Editor: Secondary Textures
      • Sprite Editor Data Provider API
    • Sorting Groups
    • 9-slicing Sprites
    • Sprite Masks
    • Sprite Atlas
      • Sprite Atlas properties reference
      • Master and Variant Sprite Atlases
        • Variant Sprite Atlas
      • Sprite Atlas workflow
      • Preparing Sprite Atlases for distribution
        • Methods of distribution
        • Late Binding
        • Resolving different Sprite Atlas scenarios
      • Sprite Packer Modes
      • Sprite Atlas V2
    • Sprite Shape Renderer
  • Tilemaps
    • Tilemap component reference
    • Grid component reference
    • Tilemap Renderer component reference
    • Tile asset reference
    • Tile Palette preferences reference
    • Tilemap workflow
      • Creating Tilemaps
      • Creating Tiles
      • Creating a Tile Palette
      • Painting on Tilemaps
        • Select Tool
      • Brush Picks
        • Introduction to Brush Picks
        • Tile Palette Brush Picks overlay reference
        • Using a Brush Pick
        • Create a Brush Pick asset
        • Customize a scriptable Brush's thumbnail
      • Tilemap Collider 2D
    • Hexagonal Tilemaps
    • Isometric Tilemaps
      • Importing and preparing Sprites for an Isometric Tilemap
      • Creating an Isometric Tilemap
      • Creating a Tile Palette for an Isometric Tilemap
      • Tilemap Renderer Modes
      • Scriptable Brushes
    • Scriptable Tiles
      • TileBase
      • Tile
      • TileData
      • TileAnimationData
      • Other useful classes
      • Scriptable Tile example
    • Scriptable Brushes
      • GridBrushBase
      • GridBrushEditorBase
      • TilemapEditorTool
      • Other useful classes
      • Scriptable Brush example
    • Tile Palette visual elements
  • Physics 2D Reference
    • Rigidbody 2D
      • Introduction to Rigidbody 2D
      • Rigidbody 2D body types
        • Body Type: Dynamic
        • Body Type: Kinematic
        • Body Type: Static
      • Rigidbody 2D properties: Simulated
    • Collider 2D
      • Circle Collider 2D
      • Box Collider 2D
      • Polygon Collider 2D reference
      • Edge Collider 2D
      • Capsule Collider 2D
      • Composite Collider 2D
      • Custom Collider 2D
    • Physics Material 2D
    • 2D joints
      • Constraints of 2D joints
      • Distance Joint 2D
      • Fixed Joint 2D
      • Friction Joint 2D
      • Hinge Joint 2D
      • Relative Joint 2D
      • Slider Joint 2D
      • Spring Joint 2D
      • Target Joint 2D
      • Wheel Joint 2D
    • Constant Force 2D
    • Effectors 2D
      • Area Effector 2D
      • Buoyancy Effector 2D
      • Point Effector 2D
      • Platform Effector 2D
      • Surface Effector 2D
• Graphics
  • Render pipelines
    • Render pipelines introduction
    • Render pipeline feature comparison
    • How to get, set, and configure the active render pipeline
    • Choosing and configuring a render pipeline and lighting solution
    • Using the Built-in Render Pipeline
      • Graphics tiers
      • Rendering paths in the Built-in Render Pipeline
        • Forward rendering path
        • Deferred Shading rendering path
        • Vertex Lit Rendering Path
      • Extending the Built-in Render Pipeline with CommandBuffers
      • Hardware requirements for the Built-in Render Pipeline
      • Example shaders for the Built-in Render Pipeline
        • Custom shader fundamentals
        • Visualizing vertex data
    • Using the Universal Render Pipeline
    • Using the High Definition Render Pipeline
    • Scriptable Render Pipeline fundamentals
      • Scriptable Render Pipeline introduction
      • Scheduling and executing rendering commands in the Scriptable Render Pipeline
    • Creating a custom render pipeline
      • Creating a custom render pipeline based on the Scriptable Render Pipeline
      • Creating a Render Pipeline Asset and Render Pipeline Instance in a custom render pipeline
      • Creating a simple render loop in a custom render pipeline
  • Cameras
    • Using more than one camera
    • Using Physical Cameras
    • Cameras and depth textures
    • Camera Tricks
      • Understanding the View Frustum
      • The Size of the Frustum at a Given Distance from the Camera
      • Rays from the Camera
      • Using an oblique frustum
    • Occlusion culling
      • Getting started with occlusion culling
      • Using occlusion culling with dynamic GameObjects
      • Occlusion culling and Scene loading
      • Occlusion Areas
      • Occlusion Portals
      • The Occlusion Culling window
      • Occlusion culling additional resources
    • CullingGroup API
    • Dynamic resolution
      • FrameTimingManager
    • Deep learning super sampling
    • Multi-display
    • Camera component
  • Lighting
    • Introduction to lighting
    • Light sources
      • Lights
        • Types of light
        • Using Lights
        • Light Modes
          • Light Mode: Realtime
          • Light Mode: Mixed
          • Light Mode: Baked
        • Cookies
          • Creating cookies for the Built-in Render Pipeline
      • Emissive materials
      • Ambient light
    • Shadows
      • Shadow mapping
      • Configuring shadows
      • Shadow Distance
      • Shadow Cascades
      • Shadow troubleshooting
    • The Lighting window
    • Lighting Settings Asset
      • Lighting Mode
        • Lighting Mode: Baked Indirect
        • Lighting Mode: Shadowmask
        • Lighting Mode: Subtractive
    • The Light Explorer window
      • Light Explorer extension
    • Lightmapping
      • The Progressive Lightmapper
        • The Progressive GPU Lightmapper (preview)
      • Lightmapping: Getting started
      • Lightmap Parameters Asset
      • Directional Mode
      • Ambient occlusion
      • Lightmaps: Technical information
      • Lightmapping and shaders
      • Lightmap UVs introduction
        • Lightmap UVs introduction
        • Generating lightmap UVs
        • Visualizing lightmap UVs
        • Fixing lightmap UV overlap
      • Lightmap seam stitching
      • Custom fall-off
    • Realtime Global Illumination using Enlighten
      • LOD and Enlighten Realtime Global Illumination
    • Light Probes
      • Light Probes: Technical information
      • Light Probe Groups
      • Placing Light Probes using scripting
      • Light Probes for moving objects
      • Light Probes and the Mesh Renderer
      • Light Probes and Scene loading
      • Light Probe Proxy Volume component
    • Reflection Probes
      • Types of Reflection Probe
      • Using Reflection Probes
      • Advanced Reflection Probe Features
      • Reflection Probe performance
      • Reflection Probe
    • Precomputed lighting data
      • Generating lighting data
      • Lighting Data Asset
      • GI cache
    • Scene View Draw Modes for lighting
  • Models
    • Creating models outside of Unity
      • Model file formats
      • Support for proprietary model file formats
      • Preparing your model files for export
      • Creating models for optimal performance
      • Creating models for animation
    • Importing models into Unity
      • Importing a model
      • Importing a model with humanoid animations
      • Importing a model with non-humanoid (generic) animations
      • Model Import Settings window
        • Model tab
        • Rig tab
          • Avatar Mapping tab
          • Avatar Muscle & Settings tab
          • Avatar Mask window
          • Human Template window
        • Animation tab
          • Euler curve resampling
          • Extracting animation clips
          • Loop optimization on Animation clips
          • Curves
          • Events
          • Mask
          • Motion
        • Materials tab
      • SketchUp Import Settings window
      • SpeedTree Import Settings window
        • Model tab
        • Materials tab
  • Meshes
    • Meshes introduction
    • Mesh data
    • Mesh asset
    • Mesh components
      • Mesh Renderer component
      • Skinned Mesh Renderer component
      • Mesh Filter component
      • Text Mesh component (legacy)
    • Using meshes with C# scripts
      • Using the Mesh Class
      • Example: creating a quad
    • Level of Detail (LOD) for meshes
      • LOD Group
      • Importing LOD Meshes
    • Compressing mesh data
    • Loading texture and mesh data
  • Textures
    • Importing Textures
      • Texture Import Settings
        • Default Import Settings reference
        • Normal map Import Settings reference
        • Editor GUI and Legacy GUI Import Settings reference
        • Sprite (2D and UI) Import Settings reference
        • Cursor Import Settings reference
        • Cookie Import Settings reference
        • Lightmap Import Settings reference
        • Directional Lightmap Import Settings reference
        • Shadowmask Import Settings reference
        • Single Channel Import Settings reference
    • Texture formats
      • Recommended, default, and supported texture formats, by platform
    • Mipmaps
      • Mipmaps introduction
      • The Mipmap Streaming system
      • The Mipmap Streaming system API
      • Streaming Controller component
    • Render Texture
    • Custom Render Textures
    • Movie Textures
    • 3D textures
    • Texture arrays
    • Cubemaps
    • Cubemap arrays
    • Streaming Virtual Texturing
      • Streaming Virtual Texturing requirements and compatibility
      • How Streaming Virtual Texturing works
      • Enabling Streaming Virtual Texturing in your project
      • Using Streaming Virtual Texturing in Shader Graph
      • Cache Management for Virtual Texturing
      • Marking textures as "Virtual Texturing Only"
      • Virtual Texturing error material
    • Sparse Textures
    • Loading texture and mesh data
  • Shaders
    • Shaders core concepts
      • Shaders introduction
      • The Shader class
      • Shader assets
      • Shader compilation
        • Asynchronous shader compilation
      • Branching, variants, and keywords
        • Conditionals in shaders
        • Branching in shaders
        • Shader variants
        • Check how many shader variants you have
        • Shader keywords
        • Using shader keywords with C# scripts
        • Using shader keywords with the material Inspector
        • Shader variant stripping
        • Shader variant collections
      • How Unity loads and uses shaders
      • Replacing shaders at runtime
      • Compute shaders
      • Error and loading shaders
    • Built-in shaders
      • Standard Shader
        • Content and Context
        • Metallic vs. specular workflow
        • Standard Shader Material Inspector reference
          • Rendering Mode
          • Albedo Color and Transparency
          • Specular mode: Specular Property
          • Metallic mode: Metallic Property
          • Smoothness
          • Normal map (Bump mapping)
          • Heightmap
          • Occlusion Map
          • Emission
          • Secondary Maps (Detail Maps) & Detail Mask
          • The Fresnel Effect
        • Material charts
        • Make your own
      • Standard Particle Shaders
      • Autodesk Interactive shader
      • Legacy Shaders
        • Usage and Performance of Built-in Shaders
        • Normal Shader Family
          • Vertex-Lit
          • Diffuse
          • Specular
          • Bumped Diffuse
          • Bumped Specular
          • Parallax Diffuse
          • Parallax Bumped Specular
          • Decal
          • Diffuse Detail
        • Transparent Shader Family
          • Transparent Vertex-Lit
          • Transparent Diffuse
          • Transparent Specular
          • Transparent Bumped Diffuse
          • Transparent Bumped Specular
          • Transparent Parallax Diffuse
          • Transparent Parallax Specular
        • Transparent Cutout Shader Family
          • Transparent Cutout Vertex-Lit
          • Transparent Cutout Diffuse
          • Transparent Cutout Specular
          • Transparent Cutout Bumped Diffuse
          • Transparent Cutout Bumped Specular
        • Self-Illuminated Shader Family
          • Self-Illuminated Vertex-Lit
          • Self-Illuminated Diffuse
          • Self-Illuminated Specular
          • Self-Illuminated Normal mapped Diffuse
          • Self-Illuminated Normal mapped Specular
          • Self-Illuminated Parallax Diffuse
          • Self-Illuminated Parallax Specular
        • Reflective Shader Family
          • Reflective Vertex-Lit
          • Reflective Diffuse
          • Reflective Specular
          • Reflective Bumped Diffuse
          • Reflective Bumped Specular
          • Reflective Parallax Diffuse
          • Reflective Parallax Specular
          • Reflective Normal Mapped Unlit
          • Reflective Normal mapped Vertex-lit
    • Using Shader Graph
    • Writing shaders
      • Writing shaders overview
      • ShaderLab
        • ShaderLab: defining a Shader object
          • ShaderLab: defining material properties
          • ShaderLab: assigning a fallback
          • ShaderLab: assigning a custom editor
        • ShaderLab: defining a SubShader
          • ShaderLab: assigning tags to a SubShader
          • ShaderLab: assigning a LOD value to a SubShader
        • ShaderLab: defining a Pass
          • ShaderLab: assigning a name to a Pass
          • ShaderLab: assigning tags to a Pass
          • ShaderLab: Predefined Pass tags in the Built-in Render Pipeline
        • ShaderLab: adding shader programs
        • ShaderLab: specifying package requirements
        • ShaderLab: commands
          • ShaderLab: grouping commands with the Category block
          • ShaderLab command: AlphaToMask
          • ShaderLab command: Blend
          • ShaderLab command: BlendOp
          • ShaderLab command: ColorMask
          • ShaderLab command: Conservative
          • ShaderLab command: Cull
          • ShaderLab command: Offset
          • ShaderLab command: Stencil
          • ShaderLab command: UsePass
          • ShaderLab command: GrabPass
          • ShaderLab command: ZClip
          • ShaderLab command: ZTest
          • ShaderLab command: ZWrite
          • ShaderLab legacy functionality
            • ShaderLab: legacy fog
            • ShaderLab: legacy lighting
            • ShaderLab: legacy alpha testing
            • ShaderLab: legacy texture combining
            • ShaderLab: legacy vertex data channel mapping
      • HLSL in Unity
        • Preprocessor directives in HLSL
          • include and include_with_pragmas directives in HLSL
          • Provide information to the shader compiler in HLSL
          • Targeting shader models and GPU features in HLSL
          • Targeting graphics APIs and platforms in HLSL
          • Declaring and using shader keywords in HLSL
        • Shader semantics
        • Accessing shader properties in Cg/HLSL
        • Providing vertex data to vertex programs
        • Built-in shader include files
        • Built-in macros
        • Built-in shader helper functions
        • Built-in shader variables
        • Shader data types and precision
        • Using sampler states
      • GLSL in Unity
      • Example shaders
      • Writing Surface Shaders
        • Surface Shaders and rendering paths
        • Surface Shader examples
        • Custom lighting models in Surface Shaders
        • Surface Shader lighting examples
        • Surface Shaders with DX11 / OpenGL Core Tessellation
      • Writing shaders for different graphics APIs
    • Understanding shader performance
      • Optimizing shader runtime performance
      • Debugging shaders using Visual Studio
      • Debugging DirectX 12 shaders with PIX
  • Materials
    • Materials introduction
    • Material Inspector reference
    • Physically Based Rendering Material Validator
    • Using materials with C# scripts
    • Material Variants
      • Material Variant benefits and limitations
      • Material Variant inheritance
      • Create, modify, and apply Material Variants
  • Visual effects
    • Post-processing and full-screen effects
    • Particle systems
      • Choosing your particle system solution
      • Built-in Particle System
        • Using the Built-in Particle System
        • Particle System vertex streams and Standard Shader support
        • Particle System GPU Instancing
        • Particle System C# Job System integration
        • Components and Modules
          • Particle System
          • Particle System modules
            • Main module
            • Emission module
            • Shape module
            • Velocity over Lifetime module
            • Noise module
            • Limit Velocity over Lifetime module
            • Inherit Velocity module
            • Lifetime by Emitter Speed module
            • Force over Lifetime module
            • Color over Lifetime module
            • Color by Speed module
            • Size over Lifetime module
            • Size by Speed module
            • Rotation over Lifetime module
            • Rotation by Speed module
            • External Forces module
            • Collision module
            • Triggers module
            • Sub Emitters module
            • Texture Sheet Animation module
            • Lights module
            • Trails module
            • Custom Data module
            • Renderer module
          • Particle System Force Field
      • Visual Effect Graph
        • Project Settings - VFX
        • Visual Effect Graph Asset
        • Block Subgraph
        • Operator Subgraph
        • Visual Effect
        • Property Binders
    • Decals and projectors
      • Projector component
    • Lens flares and halos
      • Flare asset
      • Lens Flare component
      • Flare Layer component
      • Halo component
    • Lines, trails, and billboards
      • Line Renderer component
      • Trail Renderer component
      • Billboard Renderer component
      • Billboard asset
  • Sky
    • SkyManager
    • Skyboxes
      • Using skyboxes
    • Skybox shaders
      • 6 Sided skybox
      • Cubemap skybox
      • Panoramic skybox
      • Procedural skybox
    • Skybox component reference
  • Color
    • Color space
      • Linear or gamma workflow
      • Gamma Textures with linear rendering
      • Working with linear Textures
    • High dynamic range
      • HDR color picker
  • Graphics API support
    • DirectX
    • Metal
      • Introduction to Metal
      • Metal requirements and compatibility
      • Debug Metal graphics
      • Optimize Metal graphics
    • OpenGL Core
  • Graphics performance and profiling
    • Graphics performance fundamentals
    • Optimizing draw calls
      • GPU instancing
        • Creating shaders that support GPU instancing
      • Draw call batching
        • Static batching
        • Dynamic batching
      • Manually combining meshes
      • Scriptable Render Pipeline Batcher
    • BatchRendererGroup
      • How BatchRendererGroup works
      • Getting started with BatchRendererGroup
      • Creating a renderer with BatchRendererGroup
        • Initializing a BatchRendererGroup object
        • Registering meshes and materials
        • Creating batches
        • Creating draw commands
      • DOTS Instancing shaders
    • The Rendering Statistics window
    • Debug frames in Unity
      • Frame Debugger window reference
      • Frame Debugger Event Hierarchy
      • Frame Debugger event information
• World building
  • Terrain
    • Creating and editing Terrains
    • Create Neighbor Terrains
    • Terrain tools
      • Raise or Lower Terrain
      • Paint Holes
      • Paint Texture
      • Set Height
      • Smooth Height
      • Stamp Terrain
    • Terrain Layers
    • Brushes
    • Trees
      • SpeedTree
    • Wind Zones
    • Grass and other details
    • Working with Heightmaps
    • Terrain settings
    • Using Terrain at runtime
  • Terrain Tools
  • Tree Editor
    • Building Your First Tree
    • Tree Basics
    • Branch Group Properties
    • Leaf Group Properties
• Physics
  • Built-in 3D Physics
    • Character control
      • Introduction to character control
      • Character Controller component reference
    • Rigidbody physics
      • Introduction to rigid body physics
      • Configure Rigidbody Colliders
      • Apply constant force to a Rigidbody
      • Apply interpolation to a Rigidbody
      • Rigidbody component reference
      • Constant Force component reference
    • Collision
      • Introduction to collision
      • Continuous collision detection (CCD)
      • Create a vehicle with Wheel Colliders
      • Physics Debug window reference
      • Box Collider component reference
      • Capsule Collider component reference
      • Terrain Collider component reference
      • Wheel Collider component reference
      • Mesh Collider component reference
      • Sphere Collider component reference
      • Physic Material component reference
    • Joints
      • Introduction to joints
      • Character Joint component reference
      • Configurable Joint component reference
      • Fixed Joint component reference
      • Hinge Joint component reference
      • Spring Joint component reference
    • Articulations
      • Introduction to physics articulations
      • Articulation Body component reference
    • Ragdoll physics
      • Create a ragdoll
      • Joint and Ragdoll stability
    • Cloth
    • Multi-scene physics
• Scripting
  • Setting Up Your Scripting Environment
    • Integrated development environment (IDE) support
    • Debug C# code in Unity
    • Stack trace logging
    • Unit Testing
    • Roslyn analyzers and source generators
  • Scripting concepts
    • Creating and Using Scripts
    • Variables and the Inspector
    • Instantiating Prefabs at run time
    • Order of execution for event functions
    • Event Functions
    • Coroutines
    • Namespaces
    • Attributes
    • UnityEvents
    • Null Reference Exceptions
  • Important Classes
    • GameObject
    • MonoBehaviour
    • Object
    • Transform
    • Vectors
    • Quaternion
    • ScriptableObject
    • Time
    • Mathf
    • Random
    • Debug
    • Gizmos and Handles
  • Unity architecture
    • Overview of .NET in Unity
      • .NET profile support
      • Stable scripting runtime: known limitations
      • Referencing additional class library assemblies
      • C# compiler
    • Scripting backends
      • Mono overview
      • IL2CPP Overview
        • Handling platform specific settings for IL2CPP additional arguments
        • Linux IL2CPP cross-compiler
        • Windows Runtime support
        • Managed stack traces with IL2CPP
      • Scripting restrictions
      • Managed code stripping
      • The Unity linker
    • Code reloading in the Unity Editor
      • Configurable Enter Play Mode
        • Domain Reloading
        • Scene Reloading
        • Details of disabling Domain and Scene Reload
      • Running Editor Script Code on Launch
    • Script serialization
    • Script compilation
      • Special folders and script compilation order
      • Conditional Compilation
        • Custom scripting symbols
      • Assembly definitions
        • Assembly Definition properties
        • Assembly Definition Reference properties
        • Assembly Definition File Format
  • Plug-ins
    • Import and configure plug-ins
    • Managed plug-ins
    • Native plug-ins
    • Building plug-ins for desktop platforms
    • Low-level native plug-in interface
      • Low-level native plug-in rendering extensions
      • Low-level native plug-in Shader compiler access
      • Memory Manager API for low-level native plug-ins
        • IUnityMemoryManager API reference
  • Job system
    • Job system overview
    • Jobs overview
    • Thread safe types
      • Implement a custom native container
      • Copying NativeContainer structures
      • Custom NativeContainer example
    • Create and run a job
    • Job dependencies
    • Parallel jobs
  • Unity Properties
    • Property bags
    • Property visitors
    • Property paths
    • Use `PropertyVisitor` to create a property visitor
    • Use low-level APIs to create a property visitor
• Multiplayer and Networking
  • Multiplayer Overview
  • Setting up a multiplayer project
  • Using the Network Manager
  • Using the Network Manager HUD
  • The Network Manager HUD in LAN mode
  • The Network Manager HUD in Matchmaker mode
  • Converting a single-player game to Unity Multiplayer
  • Debugging Information
  • Multiplayer Component Reference
    • Network Animator
    • Network Discovery
    • Network Identity
    • Network Lobby Manager
    • Network Lobby Player
    • Network Manager HUD
    • Network Manager
    • Network Proximity Checker
    • NetworkStartPosition
    • Network Transform
    • Network Transform Child
    • Network Transform Visualizer
  • Multiplayer Classes Reference
    • NetworkBehaviour
    • NetworkClient
    • NetworkConnection
    • NetworkServer
    • NetworkServerSimple
  • Multiplayer Encryption Plug-ins
  • UnityWebRequest
    • Common operations: using the HLAPI
      • Retrieving text or binary data from an HTTP Server (GET)
      • Retrieving a Texture from an HTTP Server (GET)
      • Downloading an AssetBundle from an HTTP server (GET)
      • Sending a form to an HTTP server (POST)
      • Uploading raw data to an HTTP server (PUT)
    • Advanced operations: Using the LLAPI
      • Creating UnityWebRequests
      • Creating UploadHandlers
      • Creating DownloadHandlers
• Audio
  • Audio overview
  • Audio files
  • Tracker Modules
  • Audio Mixer
    • An overview of the concepts and Audio Mixer
    • Specifics on the Audio Mixer window
    • AudioGroup Inspector
    • Overview of Usage and API
  • Native audio plug-in SDK
    • Audio Spatializer SDK
  • Audio Profiler
  • Ambisonic Audio
  • Audio Reference
    • Audio Clip
    • Audio Listener
    • Audio Source
    • Audio Mixer
    • Audio Filters
      • Audio Low Pass Filter
      • Audio High Pass Filter
      • Audio Echo Filter
      • Audio Distortion Filter
      • Audio Reverb Filter
      • Audio Chorus Filter
    • Audio Effects
      • Audio Low Pass Effect
      • Audio High Pass Effect
      • Audio Echo Effect
      • Audio Flange Effect
      • Audio Distortion Effect
      • Audio Normalize Effect
      • Audio Parametric Equalizer Effect
      • Audio Pitch Shifter Effect
      • Audio Chorus Effect
      • Audio Compressor Effect
      • Audio SFX Reverb Effect
      • Audio Low Pass Simple Effect
      • Audio High Pass Simple Effect
    • Reverb Zones
    • Microphone
    • Audio Settings
• Video overview
  • Video Player component
    • Migrating from MovieTexture to VideoPlayer
    • Video Clips
    • Video sources
    • Video file compatibility
    • Clock management with the Video Player component
    • Understanding video files
    • Video transparency support
    • Panoramic video
• Animation
  • Animation System Overview
  • Rotation in animations
  • Animation Clips
    • Animation from external sources
      • Humanoid Avatars
    • Animation Window Guide
      • Using the Animation view
      • Creating a new Animation Clip
      • Animating a GameObject
      • Using Animation Curves
      • Editing Curves
      • Key manipulation in Dopesheet mode
      • Key manipulation in Curves mode
      • Objects with Multiple Moving Parts
      • Using Animation Events
  • Animator Controllers
    • The Animator Controller Asset
    • The Animator Window
    • Animation State Machines
      • State Machine Basics
      • Animation Parameters
      • State Machine Transitions
      • State Machine Behaviours
      • Sub-State Machines
      • Animation Layers
      • Solo and Mute functionality
      • Target Matching
      • Inverse Kinematics
      • Root Motion - how it works
        • Tutorial: Scripting Root Motion for "in-place" humanoid animations
    • Blend Trees
      • 1D Blending
      • 2D Blending
      • Direct Blending
      • Additional Blend Tree Options
    • Working with blend shapes
    • Animator Override Controllers
  • Retargeting of Humanoid animations
  • Performance and optimization
  • Animation Reference
    • Animator component
    • Animator Controller
      • Creating an AnimatorController
      • Animation States
      • Animation transitions
  • Animation FAQ
  • Playables API
    • The PlayableGraph
    • ScriptPlayable and PlayableBehaviour
    • Playables Examples
  • A Glossary of animation terms
  • Legacy Animation System
    • Animation
    • Animation Scripting (Legacy)
• User interface (UI)
  • Comparison of UI systems in Unity
  • UI Toolkit
    • Get started with UI Toolkit
    • UI Builder
      • UI Builder interface overview
      • Get started with UI Builder
      • Work with elements
      • Use UXML instances as templates
      • Style UI with UI Builder
      • Assign USS variables in UI Builder
      • Test UI
    • Structure UI
      • The visual tree
        • Introduction to visual elements and the visual tree
        • Panels
        • Draw order
        • Coordinate and position systems
      • Structure UI with UXML
        • Introduction to UXML
        • Add styles to UXML
        • Reuse UXML files
        • Reference other files from UXML
        • Load UXML and USS C# scripts
        • Instantiate UXML from C# scripts
        • Find visual elements with UQuery
      • Structure UI with C# scripts
      • Custom controls
        • Create a custom control
        • Expose custom control to UXML and UI Builder
        • Customize UXML tag names and attributes
      • Best practices for managing elements
      • Encapsulate UXML documents with logic
      • UXML elements reference
        • UXML element BindableElement
        • UXML element VisualElement
        • UXML element BoundsField
        • UXML element BoundsIntField
        • UXML element Box
        • UXML element Button
        • UXML element ColorField
        • UXML element CurveField
        • UXML element DoubleField
        • UXML element DropdownField
        • UXML element EnumField
        • UXML element EnumFlagsField
        • UXML element FloatField
        • UXML element Foldout
        • UXML element GradientField
        • UXML element GroupBox
        • UXML element Hash128Field
        • UXML element HelpBox
        • UXML element IMGUIContainer
        • UXML element Image
        • UXML element InspectorElement
        • UXML element IntegerField
        • UXML element Label
        • UXML element LayerField
        • UXML element LayerMaskField
        • UXML element LongField
        • UXML element ListView
        • UXML element MaskField
        • UXML element MinMaxSlider
        • UXML element MultiColumnListView
        • UXML element MultiColumnTreeView
        • UXML element ObjectField
        • UXML element PopupWindow
        • UXML element ProgressBar
        • UXML element PropertyField
        • UXML element RadioButton
        • UXML element RadioButtonGroup
        • UXML element RectField
        • UXML element RectIntField
        • UXML element RepeatButton
        • UXML element ScrollView
        • UXML element Scroller
        • UXML element Slider
        • UXML element SliderInt
        • UXML element TagField
        • UXML element TextElement
        • UXML element TextField
        • UXML element Toggle
        • UXML element Toolbar
        • UXML element ToolbarBreadcrumbs
        • UXML element ToolbarButton
        • UXML element ToolbarMenu
        • UXML element ToolbarPopupSearchField
        • UXML element ToolbarSearchField
        • UXML element ToolbarSpacer
        • UXML element ToolbarToggle
        • UXML element TreeView
        • UXML element TwoPaneSplitView
        • UXML element UnsignedIntegerField
        • UXML element UnsignedLongField
        • UXML element Vector2Field
        • UXML element Vector2IntField
        • UXML element Vector3Field
        • UXML element Vector3IntField
        • UXML element Vector4Field
      • Structure UI examples
        • Create list and tree views
        • Create a complex list view
        • Create a list view runtime UI
        • Wrap content inside a scroll view
        • Create a tabbed menu for runtime
        • Create a pop-up window
        • Use Toggle to create a conditional UI
        • Create a custom control with two attributes
        • Create a slide toggle custom control
        • Create a bindable custom control
        • Create a custom style for a custom control
    • Style UI
      • Introduction to USS
      • USS selectors
        • Type selectors
        • Name selectors
        • Class selectors
        • Universal selectors
        • Descendant selectors
        • Child selectors
        • Multiple selectors
        • Selector lists
        • Pseudo-classes
        • Selector precedence
      • USS properties
        • USS data types
        • USS common properties
        • Position element with the layout engine
        • Relative and absolute positioning
        • Set background images
          • Set background images with an image asset
          • Image import settings
          • 9-Slice images with UI Toolkit
        • USS transform
        • USS transition
        • USS properties reference
        • USS color keywords
      • USS custom properties (variables)
        • Create USS variables
        • Introduction to USS built-in variables
        • USS built-in variable references
      • Apply styles in C# scripts
      • Best practices for USS
      • Theme Style Sheet (TSS)
    • UI Toolkit Debugger
    • Control behavior with events
      • Dispatch events
      • Handle events
      • Manipulators
      • Synthesize and send events
      • Event reference
        • Capture events
        • Change events
        • Click events
        • Command events
        • Drag-and-drop events
        • Layout events
        • Focus events
        • Input events
        • Keyboard events
        • Mouse events
        • Navigation events
        • Panel events
        • Pointer events
        • Tooltip event
        • Transition events
        • Contextual menu events
        • IMGUI events
      • Event examples
        • Create a transition in a custom Editor window
        • Create a drag-and-drop UI inside a custom Editor window
        • Create a drag-and-drop UI to drag between Editor windows
        • Create a transition event
        • Create looping transitions
    • UI Renderer
      • Generate 2D visual content
      • Create a pie chart in the Editor and runtime UI
      • Use Vector API to create a radial progress indicator
      • Use Mesh API to create a radial progress indicator
    • Support for Editor UI
      • Create a custom Editor window
      • Create a Custom Inspector
      • SerializedObject data binding
        • Bindable elements reference
        • Bindable data types and fields
        • Binding system implementation details
        • Binding examples
          • Bind with binding path in C# script
          • Bind without the binding path
          • Bind with UXML and C# script
          • Create a binding with the Inspector
          • Bind to nested properties
          • Bind to a UXML template
          • Receive callbacks when a bound property changes
          • Receive callbacks when any bound properties change
          • Bind to a list with ListView
          • Bind to a list without ListView
          • Bind a custom control
          • Bind a custom control to custom data type
      • View data persistence
    • Support for runtime UI
      • Get started with runtime UI
      • Render UI in the Game view
      • Panel Settings properties reference
      • Runtime UI event system
      • Performance consideration for runtime UI
      • FAQ for input and event systems with UI Toolkit
    • Work with text
      • Get started with text
      • Style text with USS
      • Style text with rich text tags
      • Supported rich text tags
      • Font assets
        • Introduction to font assets
        • Font Asset properties reference
        • Font Asset Creator properties reference
      • Style sheets
      • Include sprites in text
        • Sprite Asset properties reference
      • Color gradients
      • Panel Text Settings assets
      • Fallback font
    • Examples
    • Migration guides
      • Migrate from Unity UI (uGUI) to UI Toolkit
      • Migrate from Immediate Mode GUI (IMGUI) to UI Toolkit
  • Unity UI
    • Canvas
    • Basic Layout
    • Visual Components
    • Interaction Components
    • Animation Integration
    • Auto Layout
    • Rich Text
    • Event System
      • Messaging System
      • Input Modules
      • Supported Events
      • Raycasters
    • UI Reference
      • Rect Transform
      • Canvas Components
        • Canvas
        • Canvas Scaler
        • Canvas Group
        • Canvas Renderer
      • Visual Components
        • Text
        • Image
        • Raw Image
        • Mask
        • RectMask2D
        • UI Effect Components
          • Shadow
          • Outline
          • Position as UV1
      • Interaction Components
        • Selectable Base Class
          • Transition Options
          • Navigation Options
        • Button
        • Toggle
        • Toggle Group
        • Slider
        • Scrollbar
        • Dropdown
        • Input Field
        • Scroll Rect
      • Auto Layout
        • Layout Element
        • Content Size Fitter
        • Aspect Ratio Fitter
        • Horizontal Layout Group
        • Vertical Layout Group
        • Grid Layout Group
      • Event System Reference
        • Event System Manager
        • Graphic Raycaster
        • Physics Raycaster
        • Physics 2D Raycaster
        • Standalone Input Module
        • Touch Input Module
        • Event Trigger
      • Font assets
    • UI How Tos
      • Designing UI for Multiple Resolutions
      • Making UI elements fit the size of their content
      • Creating a World Space UI
      • Creating UI elements from scripting
      • Creating Screen Transitions
  • Immediate Mode GUI (IMGUI)
    • IMGUI Basics
    • Controls
    • Customization
    • IMGUI Layout Modes
    • Extending IMGUI
    • GUI Skin (IMGUI System)
    • GUI Style (IMGUI System)
    • Extending the Editor with IMGUI
      • Editor Windows
      • Property Drawers
      • Custom Editors
      • TreeView
• Unity Services
  • Setting up your project for Unity services
    • Using the developer dashboard
  • Unity Organizations
    • Subscriptions and seats
    • Managing your Organization
    • Managing your Organization’s Projects
    • Transfer a Project to a new Organization
  • Unity Ads
  • Unity Analytics
  • Unity Cloud Content Delivery
  • Unity Build Automation (formerly Cloud Build)
  • Unity IAP
    • Setting up Unity IAP
      • Configuring for Apple App Store and Mac App Store
      • Configuring for Google Play Store
      • Configuring for Windows Store
      • Configuration for the Amazon Appstore
    • Cross Platform Guide
      • Codeless IAP
      • Defining products
      • Subscription Product support
      • Initialization
      • Browsing Product Metadata
      • Initiating Purchases
      • Processing Purchases
      • Handling purchase failures
      • Restoring Transactions
      • Purchase Receipts
      • Receipt validation
      • Store Extensions
      • Cross-store installation issues with Android in-app purchase stores
    • Store Guides
      • iOS & Mac App Stores
      • Universal Windows Platform
      • Google Play
      • Amazon Appstore and Amazon Underground Store
    • Implementing a Store
      • Initialization
      • Retrieving products
      • Handling purchases
      • Store Modules
        • Registering your store
        • Store Configuration
        • Store Extensions
  • Unity Cloud Diagnostics
  • Unity Integrations
  • Multiplayer Services
  • Unity Distribution Portal
    • Getting started with UDP
    • Distributing your game with UDP
    • Implementing IAP products
    • Testing your game in the UDP sandbox
    • Managing and publishing your game on the UDP console
    • Using UDP with other services
      • Using Firebase with UDP builds
    • UDP reference
      • UDP API
      • UDP SDK data collection
    • UDP troubleshooting
  • Unity Accelerator
• XR
  • Overview
    • XR packages
    • AR development in Unity
    • VR development in Unity
    • XR architecture
  • XR Project set up
    • Choose XR provider plug-ins
    • Create an XR project
    • Set up an XR scene
    • XR input options
    • XR Origin
    • XR Plug-in Management settings
  • Run an XR application
  • XR graphics
    • Universal Render Pipeline compatibility in XR
    • Stereo rendering
      • Single-pass instanced rendering and custom shaders
    • VR frame timing
  • XR audio
    • Audio Spatializers
  • XR API reference
  • Unity XR SDK
    • Provider setup
      • Creating an XR provider
      • UnitySubsystemsManifest.json
    • Runtime discovery and activation of subsystems
    • Subsystems
      • XR SDK Input subsystem
      • XR SDK Display subsystem
      • XR SDK Meshing subsystem
    • Interfaces
      • XR SDK PreInit interface
      • XR SDK Stats interface
• Unity's Asset Store
  • Asset Store packages
    • Purchasing or downloading a package on the Asset Store
    • Finding your Asset Store packages
    • Using labels to organize "My Assets"
  • Publishing to the Asset Store
    • Creating your Publisher Account
    • Creating a new package draft
    • Deleting a package draft
    • Uploading assets to your package
    • Filling in the package details
    • Submitting your package for approval
    • Viewing the status of your Asset Store submissions
    • Collecting revenue
    • Providing support to your customers
    • Adding tags to published packages
    • Connecting your account to Google Analytics
    • Promoting your Assets
    • Refunding your customers
    • Upgrading packages
    • Deprecating your Assets
    • Issuing vouchers
    • Managing your publishing team
    • Asset Store Publisher portal
  • Verified Solutions
    • Decentralized technology Verified Solutions
• Platform development
  • Using Unity as a Library in other applications
  • Deep linking
  • Xcode frame debugger Unity integration
  • Android
    • Introducing Android
      • Android requirements and compatibility
      • Gradle for Android
      • Android App Manifest
      • Unity Launcher Manifest
      • Unity Library Manifest
      • How Unity builds Android applications
    • Getting started with Android
      • Android environment setup
      • Android Player settings
      • Android keystores
        • Keystore Manager window reference
        • Create a new keystore
        • Add keys to a keystore
        • Load a keystore
    • Developing for Android
      • Android mobile scripting
      • Input for Android devices
      • Android application size restrictions
        • Introduction to asset splitting
        • APK expansion files
          • APK expansion files in Unity
          • Manually install an APK expansion file
          • Host APK expansion files
        • Play Asset Delivery
          • Asset packs in Unity
          • Set up Play Asset Delivery
          • Create a custom asset pack
          • Manage asset packs at runtime
      • Graphics for Android
        • Screen configuration
        • Single-pass stereo rendering for Android
        • Framebuffer orientation
      • Testing and debugging
        • Debugging on an Android device
        • Android symbols
        • Simulate an Android device
        • Profile on an Android device
        • Unity Remote
        • Application patching
      • Optimization for Android
        • Android thread configuration
        • Optimize application startup times
        • Game state hinting
        • Optimize for user preferences
      • Create and use plug-ins in Android
        • Android plug-in types
          • Android Library Projects and Android Archive plug-ins
            • Introducing Android Library Projects and Android Archive plug-ins
            • Import an Android Library Project
            • Import an Android Archive plug-in
          • JAR plug-ins
          • Native plug-ins for Android
            • Introducing native plug-ins for Android
            • Create a native plug-in for Android
            • Import a native plug-in for Android
            • Call native plug-in for Android code
          • Java and Kotlin source plug-ins
        • Call Java and Kotlin plug-in code from C# scripts
      • Integrating Unity into Android applications
      • Android application entry points
        • The Activity application entry point
          • Activity requirements and compatibility
          • Extend the default Unity activity
            • Create a custom activity
            • Specify Android Player command-line arguments
        • The GameActivity application entry point
          • GameActivity requirements and compatibility
          • Modify GameActivity bridge code
          • Update the GameActivity library
        • Set the application entry point for your Android application
      • Deep linking on Android
      • Device features and permissions
        • Android permissions in Unity
        • Declare permissions for an application
        • Request runtime permissions
      • Handle Android crashes
      • Quit a Unity Android application
    • Building and delivering for Android
      • Gradle templates
      • Modify Gradle project files
        • Modify the Gradle project files for a Unity application
        • Modify Gradle project files with Gradle template files
        • Modify Gradle project files with the Android Project Configuration Manager
        • Modify Gradle project files with Android Studio
        • Android Templates Upgrader window reference
      • Android Build Settings
      • Build your application for Android
      • Export an Android project
      • Optimize distribution size
      • Digital distribution services for Android
        • Delivering to Google Play
    • ChromeOS
      • Requirements and compatibility
      • Getting started with ChromeOS
        • Preparing your development environment for ChromeOS
        • ChromeOS Player Settings
      • Developing for ChromeOS
        • Support user input on ChromeOS devices
        • Debugging on a ChromeOS device
      • Build for ChromeOS
  • Dedicated Server
    • Introduction to Dedicated Server
    • Get started with Dedicated Server
      • Dedicated Server requirements
      • Dedicated Server Player settings
      • Dedicated Server optimizations
    • Build your application for Dedicated Server
    • Dedicated Server AssetBundles
    • Desktop headless mode
  • iOS
    • Introducing iOS
      • iOS requirements and compatibility
      • How Unity builds iOS applications
      • Structure of a Unity Xcode Project
    • Getting started with iOS
      • iOS environment setup
      • iOS Player settings
    • Developing for iOS
      • iOS Scripting
      • Input for iOS devices
        • iOS input overview
        • Game Controller support
          • Detect Game Controllers
          • Handle Game Controller input
      • Unity's Device Simulator for iOS
      • Unity Remote
      • Managed stack traces on iOS
      • Optimizing Performance on iOS
        • iOS-specific optimizations
        • Measuring performance with the built-in profiler
        • Optimizing the size of the built iOS Player
        • Optimizing Physics Performance
      • Building plug-ins for iOS
      • Integrating Unity into native iOS applications
      • Deep linking on iOS
      • iOS authorizations in Unity
      • Preparing your application for In-App Purchases (IAP)
      • Social API
    • Building and delivering for iOS
      • iOS build settings
      • Build for iOS
      • App thinning
    • Troubleshooting on iOS devices
    • Reporting crash bugs on iOS
  • Linux
    • Linux Player settings
    • Linux Build Settings
    • Troubleshooting the Linux Editor issues
  • macOS
    • macOS player settings
    • macOS development
      • Deep linking for macOS
      • Use IL2CPP with macOS
    • Build and distribute a macOS application
      • Build a macOS application
      • macOS build settings
      • Code sign and notarize your macOS application
        • Code sign your application
        • Notarize with Xcode and command-line tools
        • Notarize with altool
      • Deliver applications to the Mac App Store
  • tvOS
    • Requirements and compatibility
    • tvOS Player Settings
    • Developing for tvOS
      • Supporting input devices on tvOS
      • Setting up app navigation from the Unity UI
      • Debugging Your Application
    • Building your application for tvOS
  • WebGL
    • WebGL introduction
      • WebGL browser compatibility
      • Advanced overview
      • WebGL prerequisites
    • WebGL development
      • WebGL Player settings
      • Interaction with browser scripting
      • WebGL native plug-ins for Emscripten
      • Memory in Unity WebGL
      • Cache behavior in WebGL
      • WebGL graphics
      • Audio in WebGL
      • Video playback in WebGL
      • Texture compression in WebGL
      • Embedded resources in WebGL
      • Input in WebGL
      • Configure a WebGL Canvas size
      • WebGL browser access to device features
      • WebGL networking
      • Cursor locking and full-screen mode in WebGL
      • WebGL performance considerations
      • Debug and troubleshoot WebGL builds
    • Build and distribute a WebGL application
      • Build your WebGL application
        • Reduce load times with AssetBundles
        • Distribution size and code stripping
      • WebGL templates
      • Deploy WebGL application
      • Server configuration code samples
  • Windows
    • Integrating Unity into Windows applications
    • Windows Player settings
    • Develop for Windows
      • Visual Studio project generation for Windows
      • Windows debugging
      • Windows integrity control
      • Windows Player: IL2CPP Scripting Backend
    • Windows Build Settings
  • Universal Windows Platform
    • Introduction to Universal Windows Platform
      • UWP requirements and compatibility
      • Integrate Unity into UWP applications
    • Get started with Universal Windows Platform
      • Set up your environment for UWP
      • UWP Player settings
    • Develop for Universal Windows Platform
      • Use deep linking on UWP
      • Connect the profiler to UWP
      • UWP scripting symbols
      • IL2CPP scripting backend for UWP
        • Use UWP plug-ins with IL2CPP
          • Use managed UWP plug-ins
          • Call and implement native UWP plug-ins
          • Author native UWP plug-ins
          • Use P/Invoke
        • Debug UWP applications with IL2CPP
          • Debug C# code
          • Debug generated C++ code
      • WinRT API in C# scripts for UWP
      • AppCallbacks class reference
      • Command line arguments for UWP
      • Association launching for UWP
    • Build and deliver for Universal Windows Platform
      • UWP build settings
      • Generate your Visual Studio C++ solution
      • Package a UWP app in Visual Studio
      • Deploy a UWP application
      • Deploy a Windows or UWP app with the Windows Device Portal
• Unity Search
  • Search usage
    • Filter searches
    • Search query operators
    • The Index Manager
  • Search tables
  • Search Providers
    • Search Project Assets
    • Search the current Scene
    • Search the Unity main menu
    • Search Object Picker
    • Search Settings and Preferences
    • Help Search Provider
    • The calculator
    • Search for files
    • Execute API methods
    • Search for packages
    • Search the Unity Asset Store
    • Search saved queries
    • Additional Search filters
  • Search expressions
    • Functions reference
  • Creating a custom Search Provider
    • The SearchProvider class
    • Registering a Search Provider
    • Performing a search
    • Registering an Action Handler
• Legacy navigation and pathfinding
  • Navigation Overview
    • Navigation System in Unity
    • Inner Workings of the Navigation System
    • Building a NavMesh
    • Advanced NavMesh Bake Settings
    • Creating a NavMesh Agent
    • Creating a NavMesh Obstacle
    • Creating an OffMesh Link
    • Building OffMesh Links Automatically
    • Building Height Mesh for Accurate Character Placement
    • Navigation Areas and Costs
    • Loading Multiple NavMeshes using Additive Loading
    • Using NavMesh Agent with Other Components
  • Navigation Reference
    • NavMesh Agent
    • NavMesh Obstacle
    • OffMesh Link
  • Navigation How-Tos
    • Telling a NavMeshAgent to Move to a Destination
    • Moving an Agent to a Position Clicked by the Mouse
    • Making an Agent Patrol Between a Set of Points
    • Coupling Animation and Navigation
• Glossary