Manual
Scripting API
unity.com
Version:
2023.2
Versions with this page:
Versions without this page:
Unity 6.1 Alpha
Unity 6
2022.3
2021.3
2023.1
2022.2
2022.1
2021.1
2021.2
2020.3
2020.2
2020.1
2019.4
2019.3
2019.2
2019.1
2018.4
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
中文
日本語
한국어
Unity Manual
Version: 2023.2
Select a different version
Unity 6.1 Alpha - Supported
Unity 6 - Supported
2022.3 - Supported
2021.3 - Supported
2023.1 - Not supported
2022.2 - Not supported
2022.1 - Not supported
2021.1 - Not supported
2021.2 - 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
2019.1 - Not supported
2018.4 - 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
中文
日本語
한국어
Unity User Manual 2023.2
Documentation versions
Offline documentation
Trademarks and terms of use
New in Unity 2023.2
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
Addressables for Android
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 Diagnostics
Cloud Save
Code Coverage
Collections
Deployment
Device Simulator Devices
Economy
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
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
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
ZivaRT Player
Release candidates
Pre-release packages
Cloud Code
Entities
Entities Graphics
Havok Physics for Unity
Moderation
Multiplay
Netcode for Entities
Unity Logging
Unity Physics
Vivox
Core packages
2D Sprite
2D Tilemap Editor
Core RP Library
High Definition RP
Shader Graph
Unity Denoising
Unity UI
Universal RP
Visual Effect Graph
Built-in packages
Accessibility
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 types
Package states and lifecycle
Dependency and resolution
Global cache
Configuration
Solving network issues
Scoped registry authentication
Customize the global cache
Customize the asset package 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
Navigation panel
List panel
Details panel
Features (details panel)
Finding packages and feature sets
Packages list context
Sorting the list
Filtering the list
Search box
Add and remove UPM packages or feature sets
Install a feature set from the Unity registry
Install a UPM package from a registry
Install a UPM package from the Asset Store
Install a UPM package from a local folder
Install a UPM package from a local tarball file
Install a UPM package from a Git URL
Install a UPM package by name
Remove a UPM package from a project
Switch to another version of a UPM package
Add and remove asset packages
Download and import an asset package
Update an asset package
Remove imported assets from a project
Delete an asset package from the cache
Disable a built-in package
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.2
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
Licensing overview
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.2
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
Cameras overlay
Create your own overlay
Position GameObjects
Grid snapping
Scene view navigation
Scene view Camera
Control a camera in first person
Pick and select GameObjects
Scene visibility
Scene view View Options toolbar
Gizmos menu
Scene view context 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
Troubleshoot the Editor
Analysis
Memory in Unity
Managed memory
Garbage collector overview
Incremental garbage collection
Disabling garbage collection
Garbage collection best practices
Native memory
Dynamic heap allocator
Bucket allocator
Dual thread allocator
Thread Local Storage (TLS) stack allocator
Thread-safe linear allocator
Customize allocators
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
Highlights 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
Import images as 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
Essential tilemap steps and tools
Active brush
Active brush shortcuts reference
Create Tilemaps
Create Tiles
Create a Tile Palette
Tile Palette editor tools
Using the Select tool
Select tiles with the Select tool
Grid Selection Properties reference
Modify Tilemap reference
Move selected tiles with the Move tool
Paint tiles with the Paint tool
Use the Box Fill tool to fill an area with duplicated tiles
Select tiles on the tilemap or Tile Palette with the Pick tool
Remove tiles from the tilemap with the Eraser tool
Fill an empty area with tiles with the Flood Fill 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 component reference
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
Tilemap component reference
Grid component reference
Tilemap Renderer component reference
Tile asset reference
Tile Palette preferences reference
Tile Palette editor reference
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 component reference
Box Collider 2D component reference
Polygon Collider 2D component reference
Edge Collider 2D component reference
Capsule Collider 2D component reference
Composite Collider 2D component reference
Custom Collider 2D component reference
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
Rendering order in the Built-in Render Pipeline
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
Lightmapping: Getting started
Preview lightmapping
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
Move Light Probes at runtime
Light Probe Proxy Volume component
Light Probes reference
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
Global Illumination (GI) cache
Debug 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
Make a material transparent
Standard Shader Material Inspector reference
Rendering Mode
Albedo
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
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
Collider types
Introduction to collider types
Interaction between collider types
Collider shapes
Introduction to collider shapes
Primitive collider shapes
Introduction to primitive collider shapes
Box collider component reference
Sphere collider component reference
Capsule collider component reference
Mesh colliders
Mesh colliders
Prepare a Mesh for Mesh colliders
Mesh collider component reference
Wheel colliders
Introduction to Wheel colliders
Wheel collider friction
Wheel collider suspension
Create a car with Wheel colliders
Wheel collider component reference
Terrain colliders
Introduction to Terrain colliders
Terrain collider component reference
Compound colliders
Introduction to compound colliders
Create a compound collider
Collider surfaces
Collider surface friction
Collider surface bounciness
How collider surface values combine
Create and apply a custom Physic Material
Physic Material asset reference
Collider interactions
Use collisions to trigger other events
OnCollision events
OnTrigger events
Create and configure a trigger collider
Example scripts for collider events
Collision detection
Choose a collision detection mode
Discrete collision detection
Continuous collision detection (CCD)
Sweep-based CCD
Speculative CCD
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
Await support
Important Classes
GameObject
MonoBehaviour
Object
Transform
Vectors
Quaternion
ScriptableObject
Time and frame rate management
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
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
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
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
Multiplayer
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
Develop a native DSP audio plug-in
Customize the GUI for your audio plug-in
Use your native audio DSP plug-in and GUI in Unity
Example native audio plug-ins included in the SDK
Audio Spatializer SDK
Audio playlist randomization
Audio Random Container reference
Audio Random Container fundamentals
Create a randomized playlist with the Audio Random Container
Audio Profiler
Ambisonic Audio
Develop an ambisonic audio decoder
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
GameObjects with Multiple Moving Parts
Use 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
Work 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
Customize UXML tag names and attributes
Bind custom controls to data
Define a namespace prefix
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 RenderingLayerMaskField
UXML element ScrollView
UXML element Scroller
UXML element Slider
UXML element SliderInt
UXML element Tab
UXML element TabView
UXML element TagField
UXML element TextElement
UXML element TextField
UXML element TemplateContainer
UXML element Toggle
UXML element ToggleButtonGroup
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 UnsignedLongField
UXML element UnsignedIntegerField
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
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
Create a drag-and-drop list and tree views between windows
Create an aspect ratio 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
Image import settings
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)
Apply masking effects in UI Toolkit
UI Toolkit Debugger
Control behavior with events
Dispatch events
Capture the pointer with a manipulator
Handle event callbacks and value changes
Focus order of elements
Respond to events with custom controls
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 simple transition with UI Builder and C# scripts
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
Parallel tessellation
Data binding
Comparison of the binding systems
Runtime data binding
Get started with runtime binding
Create a runtime binding in C# scripts
Define a data source for runtime binding
Define binding mode and update trigger
Convert data types
Define logging levels
Create custom binding types
Create a custom binding to bind USS selectors
SerializedObject data binding
Introduction to 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
Support for Editor UI
Create a custom Editor window with C# script
Create a Custom Inspector
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
Use usage hints to reduce draw calls and geometry regeneration
Control textures of the dynamic atlas
Platform and mesh considerations
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
Text effects
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
Panel Event Handler
Panel 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
Purchase or download a package from 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
Debug on Android devices
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
Optimize performance for iOS
Optimize for mobile
Measure performance with the built-in profiler
Optimize the size of the iOS Player
Native plug-ins for iOS
Create a native plug-in for iOS
Use your native plug-in for iOS
Call native plug-ins for iOS
Callback from native code
Automated plug-in integration
Bonjour browser sample
Integrating Unity into native iOS applications
Deep linking on iOS
iOS authorizations in Unity
Preparing your application for In-App Purchases (IAP)
Social API
Troubleshooting on iOS devices
Reporting crash bugs on iOS
Building and delivering for iOS
Build an iOS application
iOS build settings
App thinning
On-demand resources
App slicing
Apple’s privacy manifest policy requirements
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
Web
Web introduction
Web browser compatibility
Technical limitations
Web prerequisites
Web development
Web Player settings
Interaction with browser scripting
Code examples: Call JavaScript and C/C++/C# functions in Unity
Set up your JavaScript plug-in
Call JavaScript functions from Unity C# scripts
Call Unity C# script functions from JavaScript
Call C/C++/C# functions from Unity C# scripts
Compile a static library as a Unity plug-in
Create callbacks between Unity C#, JavaScript, and C/C++/C# code
Replace deprecated browser interaction code
Web native plug-ins for Emscripten
Memory in Unity Web
Cache behavior in Web
Web graphics
Audio in Web
Video playback in Web
Texture compression in Web
Embedded resources in Web
Input in Web
Configure a Web Canvas size
Web browser access to device features
Web networking
Cursor locking and full-screen mode in Web
Web performance considerations
Debug and troubleshoot Web builds
Build and distribute a Web application
Web Build Settings
Build your Web application
Optimize your Web build
Recommended Graphics settings to optimize your Web build
Recommended Player settings to optimize your Web build
Recommended Quality settings to optimize your Web build
Use C# code to enable optimization settings
Optimize Web platform for mobile
Reduce load times with AssetBundles
Distribution size and code stripping
Web templates
Deploy a Web 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
Glossary
This version of Unity is unsupported.
Audio
Audio Reference
Develop an ambisonic audio decoder
Audio Clip
Audio Reference
Develop an ambisonic audio decoder
Audio Clip