Manual
Scripting API
unity3d.com
Version:
2021.2
Versions with this page:
6000.2
6000.1
6000.0
2023.2
2023.1
2022.3
2022.2
2022.1
2021.3
2021.1
2020.3
2020.2
2020.1
2019.4
2019.3
2019.2
2018.4
Versions without this page:
2019.1
2018.3
2018.2
2018.1
2017.4
2017.3
2017.2
2017.1
5.6
5.5
5.4
5.3
5.2
Supported
Legacy
Language :
English
English
中文
日本語
Español
한국어
Русский
Unity Manual
Version: 2021.2
Select a different version
6000.2 - Supported
6000.1 - Supported
6000.0 - Supported
2023.2 - Not supported
2023.1 - Not supported
2022.3 - Supported
2022.2 - Not supported
2022.1 - Not supported
2021.3 - Supported
2021.1 - Not supported
2020.3 - Not supported
2020.2 - Not supported
2020.1 - Not supported
2019.4 - Not supported
2019.3 - Not supported
2019.2 - Not supported
2018.4 - Not supported
2019.1 - Not supported
2018.3 - Not supported
2018.2 - Not supported
2018.1 - Not supported
2017.4 - Not supported
2017.3 - Not supported
2017.2 - Not supported
2017.1 - Not supported
5.6 - Not supported
5.5 - Not supported
5.4 - Not supported
5.3 - Not supported
5.2 - Not supported
Language :
English
English
中文
日本語
Español
한국어
Русский
Unity User Manual 2021.2
Documentation versions
Switching between Unity versions in the documentation
Offline documentation
Terms of use
New in Unity 2021.2
Packages and feature sets
Released packages
2D Animation
2D Pixel Perfect
2D PSD Importer
2D SpriteShape
2D Tilemap Extras
Adaptive Performance
Addressables
Advertisement
Alembic
Analytics Library
Android Logcat
Animation Rigging
AR Foundation
ARCore XR Plugin
ARKit Face Tracking
ARKit XR Plugin
Burst
Cinemachine
Code Coverage
Editor Coroutines
FBX Exporter
In App Purchasing
Input System
iOS 14 Advertising Support
JetBrains Rider Editor
Live Capture
Localization
Magic Leap XR Plugin
Mathematics
ML Agents
Mobile Notifications
Oculus XR Plugin
OpenXR Plugin
Polybrush
Post Processing
ProBuilder
Profile Analyzer
Recorder
Remote Config
Scriptable Build Pipeline
Sequences
Terrain Tools
Test Framework
TextMeshPro
Timeline
Tutorial Authoring Tools
Tutorial Framework
Unity Distribution Portal
Unity Profiling Core API
Version Control
Visual Scripting
Visual Studio Code Editor
Visual Studio Editor
WebGL Publisher
XR Plugin Management
Release Candidates
Pre-release packages
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
Unity's Package Manager
Concepts
Package states and lifecycle
Dependency and resolution
Global Cache
Configuration
Solving network issues
Scoped registry authentication
Customizing the shared cache locations
Package Manager window
List view
Details view
Features (detail) view
Finding packages and feature sets
Packages list context
Sorting the list
Asset Store package filters
Search box
Adding and removing
Installing a feature set
Installing from a registry
Installing a package from a local folder
Installing a package from a local tarball file
Installing from a Git URL
Adding a registry package by name
Removing an installed package
Disabling a built-in package
Importing an Asset Store package
Switching to another package version
Updating your Asset Store package
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
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 World Building feature set
3D Characters and Animation feature set
Gameplay and Storytelling feature set
Mobile feature set
AR feature set
VR feature set
Engineering feature set
Cinematic Studio feature set
Working in Unity
Installing Unity
System requirements for Unity 2021.2
Installing Unity from the command line
Installing Unity offline without the Hub
Licenses and activation
Manage your License through the command line
Offline (manual) license activation
License Troubleshooting
2D or 3D projects
Upgrading Unity
API updater
Upgrading to Unity 2021.2
Upgrading to Unity 2021.1
Upgrading to Unity 2020 LTS
Upgrading to Unity 2019 LTS
Upgrading to Unity 2018 LTS
Legacy Upgrade Guides
Upgrading to Unity 2017.3
Upgrading to Unity 2017.2
Upgrading to Unity 2017.1
Upgrading to Unity 5.6
Upgrading to Unity 5.5
Upgrading to Unity 5.4
5.4 Networking API Changes
Upgrading to Unity 5.3
Upgrading to Unity 5.2
Upgrading to Unity 5.0
AI in Unity 5.0
Animation in Unity 5.0
Audio in Unity 5.0
Baked Data in Unity 5.0
Plugins in Unity 5.0
Physics in Unity 5.0
Shaders in Unity 5.0
Other Upgrade Notes for Unity 5.0
Upgrading to Unity 4.0
Upgrading to Unity 3.5
Unity's interface
The Project window
The Scene view
Scene view navigation
Pick and select GameObjects
Overlays
Create custom Overlays
Position GameObjects
Grid snapping
Using custom Editor tools
Scene visibility
Scene view View Options toolbar
Scene view Camera
Gizmos menu
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
Creating Gameplay
Scenes
Creating, loading, and saving Scenes
Work with multiple scenes in Unity
Setup 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
Using components
Primitive and placeholder objects
Creating components with scripting
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
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
Player
Splash Image Player settings
Preset Manager
Quality
Script Execution Order settings
Tags and Layers
Time
Visual Studio C# integration
RenderDoc Integration
Editor Analytics
Check For Updates
IME in Unity
Version Control
Version control integrations
Perforce Integration
Plastic SCM plugin for Unity
Upgrade from Collaborate to Plastic SCM
Upgrade from Collaborate without moving the history
Create projects
Export Collaborate projects
Plastic SCM plugin for Unity
Add team members
Reconnect Unity Cloud Build
Add integrations
Getting started with Plastic SCM
Using external version control systems with Unity
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
2D Physics 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
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
Building AssetBundles
AssetBundle Dependencies
Using AssetBundles Natively
AssetBundle compression
Patching with AssetBundles
Troubleshooting
Unity Asset Bundle Browser tool
AssetBundle Download Integrity and Security
Scripting with Assets
Loading Resources at Runtime
Streaming Assets
Modifying Source Assets Through Scripting
Asset packages
Creating your own asset packages
Importing local asset packages
Input
Input Manager
Mobile device input
Mobile Keyboard
Unity XR Input
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
Sprites
Sprite Renderer
Sprite Creator
Sprite Editor
Sprite Editor: Custom Outline
Sprite Editor: Custom Physics Shape
Sprite Editor: Secondary Textures
Sorting Groups
9-slicing Sprites
Sprite Masks
Sprite Atlas
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 version 2 (Experimental)
Sprite Packer
Sprite Shape Renderer
Tilemap
Grid
Tilemap Renderer
Tile Assets
Tile Palette Preferences
Tilemap workflow
Creating Tilemaps
Creating Tiles
Creating a Tile Palette
Painting on Tilemaps
Select Tool
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
Physics Reference 2D
Rigidbody 2D
Collider 2D
Circle Collider 2D
Box Collider 2D
Polygon Collider 2D
Edge Collider 2D
Capsule Collider 2D
Composite Collider 2D
Custom Collider 2D
Physics Material 2D
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
Legacy Deferred 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
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 using Enlighten Baked Global Illumination
Lightmapping: Getting started
Lightmap Parameters Asset
Directional Mode
Lightmaps and LOD
Ambient occlusion
Lightmaps: Technical information
Lightmapping and shaders
Lightmap UVs
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
Texture types
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
Shader keywords
Using shader keywords with C# scripts
Using shader keywords with the material Inspector
Shader variant stripping
Shader variant collections
Shader loading
Replacing shaders at runtime
Compute shaders
Error and loading shaders
Built-in shaders
Standard Shader
Content and Context
Metallic vs. specular workflow
Material parameters
Rendering Mode
Albedo Color and Transparency
Specular mode: Specular parameter
Metallic mode: Metallic Parameter
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
pragma directives 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
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
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
The Rendering Statistics window
The Frame Debugger window
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
3D Physics for object-oriented projects
Rigidbody overview
Colliders
Joints
Physics articulations
Character Controllers
Continuous collision detection (CCD)
Multi-scene physics
Physics Debug Visualization
3D Physics Reference
Articulation Body
Box Collider
Capsule Collider
Character Controller
Character Joint
Configurable Joint
Constant Force
Fixed Joint
Hinge Joint
Mesh Collider
Rigidbody
Sphere Collider
Spring Joint
Cloth
Wheel Collider
Terrain Collider
Physic Material
Physics HOWTOs
Ragdoll Wizard
Joint and Ragdoll stability
Wheel Collider Tutorial
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
Important Classes - GameObject
Important Classes - MonoBehaviour
Important Classes - Object
Important Classes - Transform
Important Classes - Vectors
Important Classes - Quaternion
ScriptableObject
Important Classes - Time
Important Classes - Mathf
Important Classes - Random
Important Classes - Debug
Important Classes - Gizmos & 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
Built-in serialization
Custom serialization
Script serialization errors
JSON 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
C# Job System
C# Job System Overview
What is multithreading?
What is a job system?
The safety system in the C# Job System
NativeContainer
Creating jobs
Scheduling jobs
JobHandle and dependencies
ParallelFor jobs
ParallelForTransform jobs
C# Job System tips and troubleshooting
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 AudioMixer
Specifics on the AudioMixer window
AudioGroup Inspector
Overview of Usage and API
Native Audio Plugin 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
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
Create user interfaces (UI)
Comparison of UI systems in Unity
UI Toolkit
Get started with UI Toolkit
Simple UI Toolkit workflow
Create a Custom Inspector
Creating your first runtime UI
The Visual Tree
The Layout Engine
UI Builder
Interface overview
Get started with UI Builder
Workflow overview
Create and manage UI Documents (UXML)
Set up the Canvas
Runtime UI vs Editor Extension Authoring
Inline styles vs style sheets
Structuring UI
Working with elements
Using UXML instances as templates
Structuring UXML attributes
Using custom (C#) elements
Styling UI
Styling individual inline elements
Creating and managing StyleSheets (USS)
Styling USS selectors with UI Builder
USS Variables in UI Builder
Positioning elements
Set background images
Styling text
Testing UI
Debug styles
Testing inside the UI Builder
Structure UI with UXML
Write UXML Templates
Load UXML from C# scripts
UXML elements reference
UQuery
Style UI with USS
USS selectors
Simple selectors
Complex Selectors
Pseudo-classes
USS properties data types
USS properties reference
USS properties syntax
USS transform
USS transition
USS custom properties (variables)
Built-in Unity variables
Write style sheets
Apply styles with C# scripts
Control behavior with Events
Dispatching events
Handling events
Synthesizing 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
Panel events
Pointer events
Tooltip event
IMGUI events
Controls
Controls reference
Bindings
ViewData persistence
Manage UI asset references from C# scripts
Examples
Create a custom Editor window
Create a tabbed menu for runtime
Create a drag-and-drop UI inside a custom Editor window
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
Editor Windows
Property Drawers
Custom Editors
TreeView
Navigation and Pathfinding
Navigation Overview
Navigation System in Unity
Inner Workings of the Navigation System
Building a NavMesh
NavMesh building components
Advanced NavMesh Bake Settings
Creating a NavMesh Agent
Creating a NavMesh Obstacle
Creating an Off-mesh Link
Building Off-Mesh 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
Nav Mesh Obstacle
Off-Mesh 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
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
Working with Unity Teams
Unity Ads
Legacy Analytics
Legacy Analytics Overview
Setting Up Legacy Analytics
Legacy Analytics Dashboard
Overview page
Data Explorer
Funnel Analyzer page
Segment Builder
Remote Settings page
Raw Data Export page
Event Manager
Configure page
Market Insights
Legacy Analytics Events
Core Events
Standard Events
Custom Events
Custom Event scripting
Analytics Event Tracker
Analytics event parameters
Analytics Event limits
Funnels
Remote Settings
Creating and changing Remote Settings
Using Remote Settings in a Unity project
Remote Settings network requests
Enabling Remote Settings
Managing Remote Settings in the Unity Editor
Remote Settings component
Remote Settings scripting
Testing Remote Settings
Unity Analytics A/B Testing
Monetization
Receipt Verification
User Attributes
Unity Analytics Raw Data Export
Data reset
Upgrading Unity Analytics
Upgrade Unity Analytics 4.x-5.1 (SDK) to 5.2 onwards
Upgrade Unity Analytics 5.1 to 5.2 onwards
Unity Analytics Re-integrate SDK to 5.1
What to Do if Project IDs Don't Match
COPPA Compliance
Unity Analytics and the EU General Data Protection Regulation (GDPR)
Unity Analytics DataPrivacy API
Unity Analytics and PIPL
Analytics Metrics, Segments, and Terminology
Unity Cloud Build
Setting up Cloud Build
Using the Unity Developer Dashboard to configure Cloud Build for Git
Using the Unity Developer Dashboard to configure Cloud Build for Mercurial
Using Apache Subversion (SVN) with Unity Cloud Build
Using the Unity Developer Dashboard to configure Cloud Build for Perforce
Using the Unity Developer Dashboard to configure Unity Cloud Build for Plastic
Building for iOS
Advanced options
Development builds
Pre- and post-export methods
Xcode frameworks
Custom scripting #define directives
Including specific Scenes
Using Addressables in Unity Cloud Build
Build manifest
Build manifest as JSON
Build manifest as ScriptableObject
Scheduled builds
Cloud Build REST API
Unity Cloud Content Delivery
Cloud Content Delivery interfaces
Unity CCD Command-line interface (CLI)
Unity CCD Develop Dashboard
Using CCD via the command-line interface
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 Collaborate
Setting up Unity Collaborate
Adding team members to your Unity project
Viewing history
Enabling Cloud Build with Collaborate
Managing Unity Editor versions
Reverting files
Resolving file conflicts
Excluding Assets from publishing to Collaborate
Publishing individual files to Collaborate
Restoring previous versions of a project
In-Progress edit notifications
Managing cloud storage
Moving your Project to another version control system
Unity Accelerator
Collaborate troubleshooting tips
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
XR
Getting started with AR development in Unity
Getting started with VR development in Unity
XR Plug-in Framework
Configuring your Unity Project for XR
Universal Render Pipeline compatibility in XR
Unity VR project template
Unity AR project template
XR API reference
Single Pass Stereo rendering (Double-Wide rendering)
Single Pass Instanced rendering
Single-Pass Stereo Rendering for HoloLens
VR Audio Spatializers
VR frame timing
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
Open-source repositories
How to contribute to Unity
Step 1: Get a Bitbucket account
Step 2: Fork the repository you want to contribute to
Step 3: Clone your fork
Step 4: Apply modifications to your fork
Step 5: Open a pull request on Bitbucket
Step 6: Wait for feedback
Further Reading
FAQ
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
Platform development
Using Unity as a Library in other applications
Deep linking
Xcode frame debugger Unity integration
Android
Introducing Android
Unity for 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
Android keystores in Unity
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
Create the main APK expansion file
Create the patch 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
Single-pass stereo rendering for Android
Vulkan swapchain pre-rotation
Testing and debugging
Debugging on an Android device
Android symbols
Unity Remote
Application patching
Building and using plug-ins for Android
AAR plug-ins and Android Libraries
JAR plug-ins
Extending the UnityPlayerActivity Java Code
Native (C++) plug-ins for Android
Using Java or Kotlin source files as plug-ins
Integrating Unity into Android applications
Deep linking on Android
Android thread configuration
Device features and permissions
Android permissions in Unity
Declare permissions for an application
Request runtime permissions
Building and delivering for Android
Gradle templates
Override the Android App Manifest
Android Build Settings
Building for Android
Exporting an Android project
Digital distribution services for Android
Delivering to Google Play
Troubleshooting Android development
Gradle troubleshooting
Reporting crash bugs under Android
Chrome OS
Requirements and compatibility
Getting started with Chrome OS
Preparing your development environment for Chrome OS
Chrome OS Player Settings
Developing for Chrome OS
Support user input on Chrome OS devices
Debugging on a Chrome OS device
Building your Chrome OS application
iOS
Integrating Unity into native iOS applications
Getting started with iOS development
Unity iOS Basics
iOS account setup
Inside the iOS build process
Structure of a Unity Xcode Project
iOS build settings
iOS Player settings
iOS Advanced Topics
Deep linking on iOS
Unity Remote
iOS Scripting
iOS Game Controller support
Advanced iOS scripting
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
Preparing your application for In-App Purchases (IAP)
App thinning
Managed stack traces on iOS
Social API
Troubleshooting on iOS devices
Reporting crash bugs on iOS
Linux
Linux Player settings
Build Settings
macOS
MacOS Player settings
macOS Player: IL2CPP Scripting Backend
macOS Player: C++ source code plugins for IL2CPP
Deep linking on macOS
Delivering your macOS application
Building your macOS application
Notarizing your macOS application
Digital distribution services for macOS applications
Delivering 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
Introducing WebGL
WebGL browser compatibility
WebGL Graphics
Audio in WebGL
Embedded Resources on WebGL
Getting started with WebGL development
Advanced overview
WebGL Player settings
Developing for WebGL
Memory in WebGL
Interaction with browser scripting
WebGL performance considerations
Debugging and troubleshooting WebGL builds
Cursor locking and full-screen mode in WebGL
Input in WebGL
WebGL Networking
Building and distributing a WebGL project
Building your WebGL application
Reduce load times with AssetBundles
Distribution size and code stripping
WebGL templates
Configure a WebGL Canvas size
Compressed builds and server configuration
Server configuration code samples
Windows
Integrating Unity into Windows and UWP applications
Windows General
Windows Player build binaries
Visual Studio project generation for Windows Standalone
Windows Debugging
WindowsLowIntegrity
Windows Player: IL2CPP Scripting Backend
Windows Player: IL2CPP build files
Windows Player: C++ source code plugins for IL2CPP
Universal Windows Platform
Getting Started
Universal Windows Platform: Deployment
Universal Windows Platform (UWP) build settings
Windows Device Portal Deployment
Universal Windows Platform: Profiler
Universal Windows Platform: Command line arguments
Universal Windows Platform: Association launching
AppCallbacks class
Universal Windows Platform: WinRT API in C# scripts
Universal Windows Platform Player Settings
Deep linking on Universal Windows Platform
Universal Windows Platform: IL2CPP scripting back end
Universal Windows Platform: Generated project with IL2CPP scripting backend
Universal Windows Platform: Plugins on IL2CPP Scripting Backend
Universal Windows Platform: Debugging on IL2CPP Scripting Backend
FAQ
Universal Windows Platform: Examples
Universal Windows Platform: Code snippets
Known issues
Unity Search
Search usage
Filter searches
Search query operators
The Index Manager
Search tables
Search Object Picker
Search Providers
Search Project Assets
Search the current Scene
Search the Unity main menu
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 Topics
Asset Server (Team License)
Setting up the Asset Server
Cache Server
Legacy Asset Bundles
Creating Asset Bundles in Unity 4
Managing Asset Dependencies in Unity 4
Legacy Animation System
Animation
Animation Scripting (Legacy)
Legacy Unity Analytics (SDK Workflow)
Basic Integration (SDK)
Import SDK
Create Game Script
Attach Game Script
Play To Validate
Advanced Integration (SDK)
Custom Events
Monetization
Receipt Verification
User Attributes
Glossary
This version of Unity is unsupported.
Unity User Manual 2021.2
Packages and feature sets
Packages by keywords
Experimental packages
Unity's Package Manager
Packages by keywords
Packages contain the following keywords:
Keyword:
Matching packages:
2d
2D Sprite
2D Tilemap Editor
2D
2D Pixel Perfect
3d
ProBuilder
abc
Alembic
adapt
Remote Config
adaptive
Adaptive Performance
ads
Advertisement
aim
Cinemachine
alembic
Alembic
analytics
Analytics Library
Android
Android Logcat
Mobile Notifications
android
Unity Distribution Portal
animation
2D Animation
Alembic
FBX Exporter
Recorder
Timeline
Animation
Animation Rigging
AOV
Recorder
ap
Adaptive Performance
api
Unity Profiling Core API
app update
Remote Config
ar
AR Foundation
ARCore XR Plugin
ARKit XR Plugin
Magic Leap XR Plugin
XR Plugin Management
arcore
ARCore XR Plugin
arkit
ARKit XR Plugin
asset
Addressables
assetbundles
Addressables
Scriptable Build Pipeline
assetimporter
2D PSD Importer
augmented
AR Foundation
ARCore XR Plugin
ARKit XR Plugin
Magic Leap XR Plugin
backup
Version Control
blender
ProBuilder
block
ProBuilder
boost
Adaptive Performance
Brush
Terrain Tools
build
Scriptable Build Pipeline
XR Plugin Management
bundle
Addressables
Scriptable Build Pipeline
bundles
Addressables
Scriptable Build Pipeline
cache
Scriptable Build Pipeline
camera
Cinemachine
Canvas
Unity UI
capture
Recorder
cinemachine
Cinemachine
cinematic
Cinemachine
cinematography
Cinemachine
clay
Polybrush
clearshot
Cinemachine
clip
Recorder
cloth
Alembic
cloud
Version Control
cluster
Adaptive Performance
clusterinfo
Adaptive Performance
collab
Version Control
collaborate
Version Control
collaboration
Version Control
collision
Cinemachine
compose
Cinemachine
composition
Cinemachine
conditional
Remote Config
condtions
Remote Config
config
Remote Config
configuration
Remote Config
connect
WebGL Publisher
Constraints
Animation Rigging
continuous delivery
Remote Config
control
Version Control
core
AR Foundation
ARCore XR Plugin
Adaptive Performance
coroutine
Editor Coroutines
coroutines
Editor Coroutines
coverage
Code Coverage
cube
ProBuilder
cutscene
Cinemachine
deploy
Remote Config
design
ProBuilder
dolly
Cinemachine
editor
Editor Coroutines
Timeline
effect
Visual Effect Graph
events
Input System
experiment
Remote Config
experimentation
Remote Config
facial
Alembic
fbx
FBX Exporter
ProBuilder
feature flagging
Remote Config
Filter
Terrain Tools
firebase
Remote Config
follow
Cinemachine
foundation
AR Foundation
fps
Cinemachine
framing
Cinemachine
freelook
Cinemachine
gamepad
Input System
geometry
ProBuilder
graph
Visual Effect Graph
graphics
High Definition RP
Universal RP
graybox
ProBuilder
greybox
ProBuilder
handheld
Cinemachine
iap
In App Purchasing
Unity Distribution Portal
images
Recorder
impulse
Cinemachine
indexer
Adaptive Performance
input
Input System
iOS
Mobile Notifications
keyboard
Input System
language
Localization
layer
Recorder
lens
Cinemachine
level
ProBuilder
live capture
Live Capture
locale
Localization
localization
Localization
Logcat
Android Logcat
magicleap
Magic Leap XR Plugin
management
XR Plugin Management
Mask
Terrain Tools
max
FBX Exporter
ProBuilder
maya
FBX Exporter
ProBuilder
mesh
ProBuilder
mobile
Universal RP
Mobile
Android Logcat
Mobile Notifications
model
ProBuilder
modeling
FBX Exporter
Polybrush
ProBuilder
mouse
Input System
noise
Cinemachine
Noise
Terrain Tools
Notifications
Mobile Notifications
obj
ProBuilder
oculus
Oculus XR Plugin
opencover
Code Coverage
openxr
OpenXR Plugin
orbit
Cinemachine
override
Remote Config
parameter
Remote Config
particles
Visual Effect Graph
pass
Recorder
perfect
2D Pixel Perfect
performance
High Definition RP
Universal RP
pipeline
High Definition RP
Universal RP
pixel
2D Pixel Perfect
plastic
Version Control
plasticscm
Version Control
plugin
XR Plugin Management
probuilder
ProBuilder
profiler
Unity Profiling Core API
profiles
Adaptive Performance
profiling
Unity Profiling Core API
prototype
ProBuilder
provider
Adaptive Performance
psdimporter
2D PSD Importer
purchasing
In App Purchasing
Unity Distribution Portal
push
Polybrush
quest
Oculus XR Plugin
reality
AR Foundation
ARCore XR Plugin
ARKit XR Plugin
Magic Leap XR Plugin
OpenXR Plugin
recorder
Recorder
recording
Recorder
remote
Remote Config
remote config
Remote Config
remote settings
Remote Config
render
High Definition RP
Universal RP
rendering
High Definition RP
Universal RP
resources
Addressables
rift
Oculus XR Plugin
rig
Cinemachine
Rigging
Animation Rigging
roll-out
Remote Config
rules
Remote Config
samsung
Adaptive Performance
scaler
Adaptive Performance
sculpting
Polybrush
SDF
TextMeshPro
sdk
XR Plugin Management
segment
Remote Config
segmentation
Remote Config
segmenting
Remote Config
server
Scriptable Build Pipeline
settings
Remote Config
shape
2D SpriteShape
ProBuilder
share
WebGL Publisher
simulation
Alembic
smartsprite
2D SpriteShape
source
Version Control
spline
2D SpriteShape
sprite
2D Sprite
sprite editor window
2D Sprite
spriteshape
2D SpriteShape
staged rollouts
Remote Config
subsystem
Adaptive Performance
taget
Remote Config
tailor
Remote Config
targeting
Remote Config
team
Version Control
teams
Version Control
terrain
Polybrush
Terrain
Terrain Tools
terrain2d
2D SpriteShape
test
Code Coverage
Remote Config
Test
Test Framework
TestFramework
Test Framework
testing
Code Coverage
Text
TextMeshPro
TextMesh Pro
TextMeshPro
TextMeshPro
TextMeshPro
Tilemap
2D Tilemap Editor
timeline
Timeline
TMP
TextMeshPro
Toolbox
Terrain Tools
tools
Timeline
touch
Input System
track
Cinemachine
tune
Remote Config
tutorials
Tutorial Authoring Tools
Tutorial Framework
ugui
Unity UI
UI
Unity UI
unity
Advertisement
Analytics Library
In App Purchasing
Mathematics
Recorder
Timeline
Unity UI
Unity UI
utilities
AR Foundation
Adaptive Performance
utility
AR Foundation
Adaptive Performance
variants
Remote Config
variation
Remote Config
vcam
Live Capture
vcs
Version Control
version
Version Control
vfx
Visual Effect Graph
video
Recorder
virtual
Oculus XR Plugin
virtual camera
Live Capture
virtual production
Live Capture
visualeffect
Visual Effect Graph
vr
Input System
Oculus XR Plugin
XR Plugin Management
vrr
Adaptive Performance
webgl
WebGL Publisher
whitebox
ProBuilder
xr
AR Foundation
ARCore XR Plugin
ARKit XR Plugin
Input System
Magic Leap XR Plugin
Oculus XR Plugin
OpenXR Plugin
XR Plugin Management
xreditorsubsystem
Magic Leap XR Plugin
Oculus XR Plugin
OpenXR Plugin
Experimental packages
Unity's Package Manager