Unity 6.5 (6000.5) introduces several new features and improvements.
To read about all of the changes and known issues in this version of Unity, refer to the Unity 6.5 Release Notes.
To find the release notes for other releases, refer to the Unity download archive.
To read about changes made to packages that were updated as part of this release, refer to the documentation of those packages.
If you’re upgrading existing projects from Unity 6.4 (6000.4), refer to Upgrade to Unity 6.5 for information about how your project might be affected.
Review the new features and improvements for Unity 6.5 in these areas:
This section outlines recent updates to Unity’s 2D system.
You can now do the following:
Light2DProvider API. For example, to create a new light type with a custom shape.ShadowShape2DProvider API. For example, to create a custom shadow shape.You can use the new 2D module in the Unity Profiler to check how many sprites Unity renders and which spriteA 2D graphic objects. If you are used to working in 3D, Sprites are essentially just standard textures but there are special techniques for combining and managing sprite textures for efficiency and convenience during development. More info
See in Glossary atlases it uses in a frame. For more information, refer to 2D Profiler module reference.
The new BlendShape APIs for sprites provide the foundation for FFD-based sprite deformation. You can use these APIs to develop tools to create animated 2D sprite deformations beyond traditional bone-based approaches. For more information, refer to Sprite.AddBlendShape.
The LowLevelPhysics2D API has been renamed to the PhysicsCore2D API, and has moved from the UnityEngine.LowLevelPhysics2D namespace to the Unity.U2D.Physics namespace.
You can now do the following:
There are also improvements to the debug visualization, queries, shaderA program that runs on the GPU. More info
See in Glossary performance and pixelThe smallest unit in a computer image. Pixel size depends on your screen resolution. Pixel lighting is calculated at every screen pixel. More info
See in Glossary accuracy, interpolation syncing, and thread-safety.
For more information, refer to 2D physics with the Physics Core 2D API.
This section outlines recent updates to Unity’s animation system.
Updated the design of the Animation window. The new design includes an improved layout which moves the Animation ClipAnimation data that can be used for animated characters or simple animations. It is a simple “unit” piece of motion, such as (one specific instance of) “Idle”, “Walk” or “Run”. More info
See in Glossary menu, Playback Controls, and Animation Mode menu (Dopesheet or Curves) above the animation view.
The new design also replaces the Filter by selection icon with the Ripple icon. Enable Ripple to perform a ripple move or ripple scale on a selection of keyframesA frame that marks the start or end point of a transition in an animation. Frames in between the keyframes are called inbetweens.
See in Glossary. Previously, Ripple was accessible from either a keyboard shortcut or the More menu.
Added the Require Receiver property to the InspectorA Unity window that displays information about the currently selected GameObject, asset or project settings, allowing you to inspect and edit the values. More info
See in Glossary window for animation events. This property controls error reporting when an animation eventAllows you to add data to an imported clip which determines when certain actions should occur in time with the animation. For example, for an animated character you might want to add events to walk and run cycles to indicate when the footstep sounds should play. More info
See in Glossary isn’t assigned a target method.
Enable this property to check and report an error if the animation event doesn’t have a target method. Disable this option to ignore this check. Previously, there was no option to avoid receiving errors. You would have to implement event callback methods or add importer post processors which impacted performance.
The Require Receiver property maps to AnimationEvent.messageOptions.
Added the AnimationEventInfo ref struct as a non-allocating alternative parameter for animation event callbacks. This new stack-allocated struct removes garbage collection overhead when handling animation events, providing significant performance benefits for animation-heavy scenesA Scene contains the environments and menus of your game. Think of each unique Scene file as a unique level. In each Scene, you place your environments, obstacles, and decorations, essentially designing and building your game in pieces. More info
See in Glossary.
The AnimationEventInfo ref struct provides read-only access to all animation event parameters and state information from both Animator and legacy Animation components. Existing AnimationEvent callbacks are fully backward compatible.
For more information, refer to AnimationEventInfo.
This section outlines recent updates to Unity’s asset and media handling.
If a ParticleA small, simple image or mesh that is emitted by a particle system. A particle system can display and move particles in great numbers to represent a fluid or amorphous entity. The effect of all the particles together creates the impression of the complete entity, such as smoke. More info
See in Glossary System Shape module or TerrainThe landscape in your scene. A Terrain GameObject adds a large flat plane to your scene and you can use the Terrain’s Inspector window to create a detailed landscape. More info
See in Glossary Paint Detail component requires a texture to be readable by the CPU, you must enable the Read/Write property of the texture. Previously, Unity enabled this setting at build time, which contributed to long build times. If you don’t enable the Read/Write property of the texture, Unity displays a warning in the Inspector window, and if you attempt to build, the build process fails.
The preview section of the Texture Import Settings window now displays individual texture channels in grayscale by default. To toggle between grayscale and color, use the new Grayscale/Color button.
For content built using the Addressables system, you can now place an AssetBundle’s TypeTree data in a separate file. This helps reduce the build size of AssetBundles. To use this, enable the Extract TypeTree Data setting. This changes all AssetBundles in already deployed projects, so the recommended best practice is to only use it in new projects.
If you use the Unity AcceleratorThe Unity Accelerator is an external tool that provides an asset cache that keeps copies of a team’s imported assets. The goal of the Accelerator is to speed up teamwork and reduce iteration time by coordinating asset sharing so that you don’t need to reimport portions of your project. More info
See in Glossary cache server, the reliability and determinism of cached results has been improved through the following changes:
These changes improve the reliability and determinism of cached results while maintaining strong performance benefits. For more information, refer to Unity Accelerator caching behavior.
You can now use imported audio clipsA container for audio data in Unity. Unity supports mono, stereo and multichannel audio assets (up to eight channels). Unity can import .aif, .wav, .mp3, and .ogg audio file format, and .xm, .mod, .it, and .s3m tracker module formats. More info
See in Glossary as scriptable generators, which is the standard way to use audio clips within the scriptable audio pipeline.
AudioClip.CreateInstance returns a GeneratorInstance that you can use directly with a RealtimeContext or nest within other generators to facilitate advanced playback behaviors such as sequencing, blending, or looping with custom logic.
For more information, refer to Generators and AudioClip.
This section outlines recent updates to the Unity Editor’s general workflows and user interface.
By default, Unity now writes Editor log messages to a dedicated project-specific log file located in the project’s folder at ProjectName/Logs/Editor.log. To enable the previous default behavior instead and make all projects write to the same global Editor log file, you can enable the new Use Global Editor Log setting in the Preferences window or use the new -useGlobalLog Editor command-line argument. Using the default project-local Editor log is recommended, and provides greater clarity and easier debugging, especially if you regularly switch between projects.
For more information, refer to Log files reference.
The Create menu in the Project window now includes a Create Folder with Selection option. Use it to create a new folder that contains the items you select in the Project window, instead of creating an empty folder and moving the items into it manually.
On Linux Desktop and Embedded Linux, added the IL2CPPA Unity-developed scripting back-end which you can use as an alternative to Mono when building projects for some platforms. More info
See in Glossary LTO Mode Player setting. Use this setting to choose Full and Thin options for IL2CPP builds.
For more information, refer to Linux Player settings or Embedded Linux Player settings.
Added the CreateBuildProfile method to the BuildProfile API to enable creation of a build profileA set of customizable configuration settings to use when creating a build for your target platform. More info
See in Glossary using scripting. Use this method to create a build profile for the specified platform, and automatically install the required platform packages.
Added a full set of public APIs that you can use to customize and extend the new Hierarchy window. The new APIs are in the Unity.Hierarchy namespace, split across the HierarchyModule and HierarchyCoreModule Scripting Reference pages.
The macOS Editor is now signed and notarized by Apple, which removes the need to override macOS security settings before launch.
This section outlines recent updates to the Entities system.
The Hierarchy window can now display entities, entity worlds, and subscenes. To enable this feature, enable the Use new Hierarchy window option in the Preferences window.
For more information, refer to Entity world view in Hierarchy window.
Queries, matching entities, and system dependencies, previously shown in the Inspector window when a System was selected, now appear in a dedicated panel inside the Systems window itself. The window now uses the standard Quick Search bar, including a new filter that lets you narrow systems by namespace, and System Groups are now expanded by default the first time the window is opened. For more information, refer to the Systems window reference.
The orange dropdown Data Mode picker was removed from the Inspector window. The Inspector window now shows data based on what is selected in the hierarchy. You can select an Entity to see entity data or select a GameObjectThe fundamental object in Unity scenes, which can represent characters, props, scenery, cameras, waypoints, and more. A GameObject’s functionality is defined by the Components attached to it. More info
See in Glossary to see GameObject data. The Data Mode picker remains available in the Entities Hierarchy window. For more information, refer to the Entity Inspector reference.
The Components window and the Archetype window were removed. Archetype information is available in the Entities Profiler’s Memory module.
Entities Journaling is deprecated, including both the Journaling window and the journaling API. The feature remains functional in this release.
This section outlines recent updates to Unity’s graphics systems.
The Built-In Render PipelineA series of operations that take the contents of a Scene, and displays them on a screen. Unity lets you choose from pre-built render pipelines, or write your own. More info
See in Glossary is deprecated and will be obsolete in a future release. It remains supported, including bug fixes and maintenance, through the full Unity 6.7 LTS lifecycle.
For more information, refer to:
Dynamic batching is now deprecated and will be removed in a future release. For other optimization methods, refer to Choose a method for optimizing draw calls.
Improvements to PSO tracing and warming with the GraphicsStateCollection API:
traceCacheMisses option to automatically trace missing PSOs.For more information, refer to Trace and manage PSO data collections.
You can also now do the following:
VariantsUploadedToGpuLastFrame API. For more information, refer to Check how many shader variants you have.KEYWORD_TYPE_FLAG flags. For more information, refer to Make shader behavior conditional on keywords.Added on-tile post-processingA process that improves product visuals by applying filters and effects before the image appears on screen. You can use post-processing effects to simulate physical camera and film properties, for example Bloom and Depth of Field. More info post processing, postprocessing, postprocess
See in Glossary for all platforms, which runs supported effects directly on the GPU tile in a single pass. Effects such as HDRhigh dynamic range
See in Glossary, tone mapping, color grading, and vignette no longer require costly readbacks through system memory, reducing bandwidth use on Vulkan and Metal devices. This can result in smoother performance, lower battery drain, and less thermal throttling during longer play sessions.
For more information, refer to On-tile post-processing.
Added a new Tile-Only Mode setting to help you maintain on-tile rendering benefits throughout production. It validates your cameraA component which creates an image of a particular viewpoint in your scene. The output is either drawn to the screen or captured as a texture. More info
See in Glossary, renderer, and URP asset settings, then warns about or automatically disables options that force extra passes and break tile-based rendering. This makes it easier to use mobile-friendly post-processing with consistent visuals, without accidentally losing performance gains late in development.
To enable on-tile rendering in your project:
For more information, refer to Improve performance with on-tile rendering.
Added support in the Render Pipeline Converter to convert shaders from a Built-In Render Pipeline project to HDRP.
For more information, refer to Convert shaders using the Render Pipeline Converter.
Improved the command-line tool to convert Built-In Render Pipeline assets to URP. The batch mode converter now provides helper functions to convert assets easily.
For more information, refer to Convert assets using the command line.
Mesh LODThe Level Of Detail (LOD) technique is an optimization that reduces the number of triangles that Unity has to render for a GameObject when its distance from the Camera increases. More info
See in Glossary is now compatible with the Entities Graphics package. For more information, refer to Introduction to Mesh LOD.
In URP, you can now use the additionalLightsShadowResolutionTier property on UniversalAdditionalLightData to change the shadow resolution tier of an additional light at runtime. This allows you to dynamically control shadow quality for individual point lights and spot lights during Play mode. The resolution tiers (Low, Medium, and High) map to the pixel values configured in the URP asset.
A new Lighting Search window is now available in the Editor to help you accelerate your lighting workflows. It enables lighting-related data search, filtering, and editing in a single location. Use this window to locate and manage lights and lighting settings more efficiently than the Light Explorer window when you deal with complex scenes. The Light Explorer window is still available.
The OptiX denoiser is deprecated in Unity 6.5 and will be removed in Unity 6.7. OIDN replaces it with a broader platform reach and improved performance. Most projects upgrade automatically. If you use the OptiX temporally coherent mode with the HDRP path tracer, this is a breaking change. In this case, switch to OIDN, which provides faster denoising and reduces the need for temporal reproduction because the final frame rate is higher.
You can now use the Renderer Shader User Value (RSUV) to specify per-renderer data for shader customizations on sprites, sprite shapes, and tilemapsA GameObject that allows you to quickly create 2D levels using tiles and a grid overlay. More info
See in Glossary.
Added the following APIs:
SpriteRenderer.SetShaderUserValueSpriteShapeRenderer.SetShaderUserValueTilemapRenderer.SetShaderUserValueThis section outlines recent updates to Shader Graph.
A new shader function reflection API allows you to write custom HLSL functions that become automatically available as nodes in Shader Graph. From the HLSL files containing the functions, you can also further customize the way the generated nodes and their parameters behave and appear in the Editor.
This new feature provides more options and flexibility than the existing Custom Function node, which remains available. For more information, refer to Create custom nodes with HLSL.
Shader Graph now includes an Expression node that lets you compute a custom mathematical expression with multiple terms. This allows you to streamline your calculation process and get a clearer graph view by using a single Expression node instead of combining multiple Math nodes.
Shader Graph now includes a Switch node that lets you branch your graph based on different cases. To define the cases and conditions, you can either specify them within the Switch node or get them from a predefined Float Property in Enum mode used as an input of the Switch node.
The subgraph input connectors now better reflect the value types, support more widgets, and have more flexible settings. This includes the following improvements:
The Shader Graph template browser now includes a set of search, filtering, and ordering tools to help you find the templates that fit your specific needs. These tools are based on the Unity Search feature and include the following for Shader Graph:
The material creation workflows have been improved for the following:
In the Material property for these features, the New dropdown now includes an additional option that lets you select a shader graph template to create a new material. Unity filters the template list to make it relevant to the context you started from, and you can further customize the created shader graph asset from the template you select.
The uGUI Shader sample has been refactored to benefit from the latest Shader Graph features and improvements. The custom nodes it contains are now built with either of the following methods instead of an internal API:
Keywords now have a new Allow Definition Override option in the Graph Inspector to make the keyword’s definition overridable at compile time through the shader build settings.
Enum keywords now have a new Include “none” entry option to allow a “no value selected” state in addition to the enum entry list you define.
Texture based properties now have a new is HDR option to allow any node that samples the texture to automatically decode the sampled value if the texture is stored in an encoded HDR format. This includes Texture 2D, Texture 2D Array, Texture 3D, and CubemapA collection of six square textures that can represent the reflections in an environment or the skybox drawn behind your geometry. The six squares form the faces of an imaginary cube that surrounds an object; each face represents the view along the directions of the world axes (up, down, left, right, forward and back). More info
See in Glossary property types.
This section outlines recent updates to Visual Effect Graph.
The VFX Graph Template window now includes a set of search, filtering, and ordering tools to help you find the templates that fit your specific needs. These tools are based on the Unity Search feature and include the following for Visual Effect Graph:
A new VisualEffectAsset.PrewarmComputeShaders API now allows you to prewarm the compute shaders associated with the VisualEffectAsset to improve rendering performance and get smoother and more reactive gameplay.
This section outlines recent updates to Unity’s Input System.
Added Input Method Editor (IME) support for Linux desktop and Embedded Linux. You can enable IME support on these platforms with either of two input method frameworks:
For more information, refer to IME in Unity.
This section outlines recent updates to Unity’s navigation and pathfinding system.
The new Unity.AI.Navigation.LowLevel namespace enables you to run navigation queries in worker threads. This API has its roots in the old NavMeshQuery experimental API and it is thread-safe and designed to be called from C# jobs.
This section outlines recent optimization updates.
This section outlines recent updates to Unity’s Adaptive Performance features.
Added an Adaptive Performance provider for Apple platforms, including iOS, tvOS, and visionOS. This provider uses Apple’s native thermal APIs to expose the device’s thermal state. Applications can now query for thermal warnings and use all available scalers to adjust performance based on the device’s thermal warning system.
For more information, refer to the Adaptive Performance Apple provider documentation.
Extended the Basic provider to support performance optimization on the following platforms:
You can now use Adaptive Performance features, such as automatic performance scaling and bottleneck detection, on these platforms.
The Unity Profiler now includes the Ask Assistant button to access Unity’s AI assistant. Use it to identify optimization opportunities in your project. For more information, refer to Analyze Profiler data in Assistant.
Use the Project Auditor to find Unity APIs that become obsolete between versions of the Editor, and get advice about which API to use instead. For more information, refer to Identify obsolete API between Unity versions.
Added mimalloc, a new native memory allocator type which lets multiple threads allocate and free memory at the same time.
For more information about mimalloc, refer to the Microsoft documentation on mimalloc. To learn how to use mimalloc in Unity, refer to Mimalloc allocator example.
This section outlines recent updates to Unity’s Package Manager.
Added the All Samples view, making it easier for you to discover samples from packages installed in your project in one place. Browse all available samples at a glance, including those you haven’t imported yet. For more information, refer to Packages and samples discovery.
This section outlines recent updates to Unity’s physics system.
This section outlines recent updates to the Unity Physics package.
The Unity Physics package is now a core package.
The Direct Solver provides stable, accurate simulation of systems with high mass and stiffness ratios, long jointA physics component allowing a dynamic connection between Rigidbody components, usually allowing some degree of movement such as a hinge. More info
See in Glossary sequences and loops, and contacts with friction. Use it for advanced physical setups such as complex gearing, chains and ropes, physics-based puzzles, XR-based object manipulation and stacking, and advanced industrial scenarios such as robotics.
To select the Direct Solver:
Solver Type property in the Physics Body authoring component and in the custom joint authoring components.Solver Type authoring component and the corresponding built-in Rigidbody or Joint authoring components.By default, the Iterative Solver is used. However, you can opt to use the new Direct Solver only for the parts of your project that require the additional accuracy.
To explore a worked example of the Direct Solver, import the Advanced Game Physics Sample - Chain and Gears sample from the Unity Physics package. The sample combines the new Direct Solver for accurate simulation of the stiff chain links and the gears with the Iterative Solver for efficient simulation of all the collisions in the scene.
Added new ScheduleParallel methods for multithreaded execution of event processing jobs (ICollisionEventsJob, ITriggerEventsJob, and IImpulseEventsJob) and callback jobs (IContactsJob, IJacobiansJob, and IBodyPairsJob) to the Unity Physics package. The existing Schedule methods run jobs on a single thread. The new ScheduleParallel methods run on multiple threads for parallel processing. Use these new methods to process large data sets with many events and for jobs with high computational requirements.
This section outlines recent updates to platform-specific tools and settings.
This section outlines recent updates to the Android platform.
The minimum supported Android API level is now 26 (Android 8.0 Oreo).
x86–64 target architecture support is completely removed for Android.
Unity’s Android build tooling is updated to align with the latest Android development tools. Unity now uses GradleAn Android build system that automates several build processes. This automation means that many common build errors are less likely to occur. More info
See in Glossary version 9.1.0 and Android Gradle Plugin (AGP) version 9.0.0.
Unity automatically applies these updates to most projects, however, projects using Custom Gradle Templates or third-party plug-insA set of code created outside of Unity that creates functionality in Unity. There are two kinds of plug-ins you can use in Unity: Managed plug-ins (managed .NET assemblies created with tools like Visual Studio) and Native plug-ins (platform-specific native code libraries). More info
See in Glossary might need manual changes. To upgrade your existing project, refer to Upgrade to Unity 6.5.
The tooling updates introduce the following changes:
targetSdkVersion, minSdkVersion, lintOptions, and packagingOptions are marked deprecated and automatically converted by Gradle Template Updater to their updated versions.proguard-android.txt with the optimized version proguard-android-optimize.txt. Using the old proguard-android.txt file is no longer supported.The recommended Android GameActivity library version is now 4.4.0. This update is backported up to Unity version 6.3. For Unity 6.0, the recommended version is 4.4.2.
Added new APIs to enhance support for Android foldable devices. These APIs provide information about folding features of a device, such as a fold in a flexible display or a hinge between separate physical displays.
AndroidApplication.currentFoldingFeatures provides access to the device’s current folding state and properties.AndroidApplication.onFoldingFeaturesUpdated detects changes in the device’s folding state at runtime.Use these APIs to dynamically adjust your application’s interface to suit various foldable device states for an optimal user experience. For more information, refer to Large screen and foldable device support.
Added the AndroidAssetPacks.ShowConfirmationDialogAsync API for displaying a dialog to request user consent to download Android asset packs. Use this API for the asset packs that need explicit user permission such as when the app isn’t installed through Google Play Store or when the asset packs download is paused due to Wi-Fi unavailability. Users can then choose to proceed with downloading through mobile data or update the app with a valid version. This API replaces the deprecated AndroidAssetPacks.RequestToUseMobileDataAsync API.
Added the Link Time Optimization option in Android build settings. This setting enables precompiled and link time optimized (ThinLTO) Unity engine code (libunity.so) for non-development builds. For more information, refer to the Android build settings reference, and for details on performance benefits, refer to this Discussions post.
Unity now supports improved edge-to-edge display handling for Android with new APIs and settings to control the visibility and behavior of Android system bars. For more information, refer to the Manage the visibility and behavior of Android system bars.
AndroidApplication.currentWindowInsets that provides the current visibility and behavior status of Android system bars at runtime.AndroidApplication.onWindowInsetsChanged to detect and handle changes in system bars visibility and behavior at runtime.Screen.fullScreen has no effect on Android. Use AndroidWindowInsets methods to control status and navigation bar visibility at runtime.unity.launch-fullscreen and replaced it with unity.requested-visible-insets and unity.system-bars-behavior to control insets and their behavior.android:Theme.Holo.Light.NoActionBar.Fullscreen with android:Theme.Holo.Light.NoActionBar.This section outlines recent updates to the Embedded Linux platform.
Added the platform-hmi-gfx-cache-path command-line parameter, which lets you set a custom path for the engine to store the GLES shader cache or Vulkan pipeline cache. For more information, refer to Embedded Linux command line arguments.
This section outlines recent updates to the Embedded Linux and QNX platforms.
The UnityEngine.Windowing API now includes the GameWindowManager API, providing granular, per-window control for multi-window applications on Embedded Linux and QNX platforms.
You can use the GameWindowManager API with the GameWindow class to do the following:
The EmbeddedLinuxGameWindowCreationSettings API provides Embedded Linux-specific options, including transparency mode and IVI (In-Vehicle Infotainment) surface ID support for Wayland and IVI Shell integration.
For more information, refer to Multi-window support on embedded systems.
This section outlines recent updates to the QNX platform.
For QNX applications, the Memory Profiler now displays Resident Memory on Device. This data indicates how much of your application’s committed memory is resident in physical RAM of the target device. Use this information to understand your application’s physical RAM usage at runtime on QNX.
This section outlines recent updates to the iOS platform.
Added experimental support for Swift Xcode projects on iOS, iPadOS, and tvOS. Internally, this is a complete re-architecture of the layer connecting Unity Engine to Apple platforms, written in modern Swift. You can expect:
To enable the new project type, set Xcode Project Type to Swift in the iOS or tvOS Player settings.
For more information, refer to Swift Xcode project type for iOS and tvOS. You can provide feedback in the dedicated Unity Discussions thread.
Removed the ReplayKit API. ReplayKit was marked as obsolete in Unity 6.0 and is no longer available.
Unity can now automatically lower your application’s frame rate when an iOS device overheats, helping prevent GPU timeouts and improve responsiveness under thermal stress.
Enable Adjust iOS FPSSee first person shooter, frames per second.
See in Glossary based on thermal state from the iOS Player settings to set a target frame rate for each of the following states:
For more information, refer to iOS Player Settings.
This section outlines recent updates to the macOS platform.
Added support for CAMetalDisplayLink (Apple Developer) to the macOS Player to improve the reliability of high refresh rates and help reduce stuttering.
For more information, refer to Use MetalDisplayLink.
Moved macOS Standalone support files outside the Unity.app bundle to the sibling PlaybackEngines directory to preserve Apple notarization requirements. This matches the location used for other player support files.
This section outlines recent updates to the Windows platform.
AsyncReadManager now supports DirectStorage API for optimized file I/O operations when enabled in the Player settingsSettings that let you set various player-specific options for the final game built by Unity. More info
See in Glossary. For more information, refer to Optimize performance using DirectStorage.
You can now deploy your Windows application to a remote device directly from the Editor with the Xbox PC Remote Tools without generating the Visual Studio project. Xbox PC Remote Tools are Microsoft tools that support deploying and debugging applications to remote Windows 10 and later devices. For more information, refer to Deploy a Windows application with the Xbox PC Remote Tools.
This section outlines recent updates to the Web platform.
Unity 6.5 and later uses the Emscripten compiler version 4.0.19-unity to compile Unity Web Player builds.
Unity bundles the Emscripten compiler with the Web platform package, so that you don’t have to manually download it. For more information, refer to Web native plug-ins for Emscripten.
The Target WebAssembly 2023 option (in the Publishing Settings) is now enabled by default and is the current standard. The recommended best practice is to not disable this option because it will be required in a future release and the option to disable it will be removed.
Optimized IL2CPP metadata to reduce Web platform build sizes and make your games load faster.
UnityWebRequest is no longer exempt from encryption export regulations when developing for the App Store, due to a change from using NSURLSession to using Mbed TLS as an underlying library. Review your usage of UnityWebRequest if this affects your projects. For more information, refer to Encryption export regulations.
This section outlines recent updates to the Programming system.
The Unity Mathematics package is now a built-in module of the core Editor and Engine. Its APIs are available to user code by default in the Unity.Mathematics namespace, with no package installation required. Accordingly, the Unity Mathematics API documentation is now part of the core Scripting API reference under the Unity.Mathematics namespace, and the user manual is integrated with the core user manual. Implicit conversion operators are available for converting between UnityEngine math types (such as Vector3, Matrix4x4) and their Unity.Mathematics equivalents (float3, float4x4). For more information, refer to Programming with math.
Introduced a new set of public C# attributes to designate static methods as callbacks to invoke at key phases in Unity’s code reload sequence. This provides the opportunity to perform appropriate setup or cleanup work prior to or following the loading or unloading of managed objects and assemblies, and on transition between Edit mode and Play mode.
These new attributes offer a more robust and cohesive alternative to an earlier iteration of APIs that were fragmented and inconsistent. The older generation of APIs is still supported, but the recommended best practice is to adopt the new APIs in your new code.
The new code reload attributes are in the Unity.Scripting.LifecycleManagement namespace and are available in the Editor and in Player builds. They are two symmetrical attribute pairs corresponding to the serialization and deserialization of managed objects and the unloading and loading of code assemblies. The attributes are as follows, and are shown in their execution order during a code reload sequence:
OnCodeDeinitializingAttribute: Objects serialized.OnCodeUnloadingAttribute: Code about to unload.OnCodeLoadedAttribute: Code loaded.OnCodeInitializingAttribute: Objects deserialized.The code deinitializing and unloading attributes give you direct access to previously inaccessible phases of the code lifecycle. A key advantage of the new OnCodeInitializing attribute over its older equivalents, InitializeOnLoad, InitializeOnLoadMethod, and RuntimeInitializeOnLoad, is that OnCodeInitializing executes before assets are fully loaded, making it better for resource pre-allocation than the InitializeOnLoad attributes, which execute after.
The Edit mode and Play mode transition callbacks are in the UnityEditor.Scripting.LifecycleManagement and UnityEngine namespaces respectively. They are two symmetrical attribute pairs that correspond to entry to and exit from Edit mode and entry to and exit from Play mode:
OnEnteringEditModeAttributeOnExitingEditModeAttributeOnEnteringPlayModeAttributeOnExitingPlayModeAttributeThese newer APIs are attributes rather than an event like their older counterpart EditorApplication.playModeStateChanged. This avoids the overhead and risks of subscribing to events, filtering on enum values, and avoiding subscription leaks. The entering and exiting Play mode attributes are also in the UnityEngine namespace, meaning you don’t have to worry about #if defining them out of runtime code.
For more information on how to use both sets of attributes and how they compare to the older generation of APIs, refer to Code reload and the code lifecycle.
In addition to the new lifecycle attributes, and to further support the workflow of entering Play mode with domain reload disabled, a new pair of attributes AutoStaticsCleanup and NoAutostaticsCleanup provide automatic cleanup of static variables through code generation.
An autostatics cleanup code analyzer is also provided to analyze the code in your assembly and offer tips on which static variables need to be reset and how. This is especially useful when you have domain reload disabled and aren’t using the static cleanup attributes, as it helps you identify which static variables need to be reset manually.
By default, code generation is on and the code analyzer is off. These settings can be modified using a .globalconfig file next to an assembly definition. For more information on this and automatic reset of static state, refer to Automatic reset of static state.
Unity now identifies objects with the 64-bit EntityId struct instead of the 32-bit integer InstanceID. EntityId unifies how GameObjects and entities identify Unity objects and removes legacy assumptions about identifier values, such as treating a negative value as a runtime-created object. As part of this change, the obsolete integer-based InstanceID APIs (for example, Object.GetInstanceID, Resources.InstanceIDToObject, and Selection.instanceIDs) now produce compilation errors, and many Unity APIs add EntityId type members alongside the removed integer versions.
In most code, you only need to change the variable type from int to EntityId where you call these APIs. Code that stores, serializes, or performs custom processing on identifier values requires rewriting, because an EntityId is 8 bytes and can’t be represented as a 32-bit integer. For information about the replacement API and migration steps, refer to Upgrade to Unity 6.5.
A set of obsolete GameObject and Component APIs that previously reported obsolete errors was removed and some remaining obsolete warnings were promoted to errors. This includes the old component accessor properties such as GameObject.rigidbody, GameObject.camera, and Component.renderer, and the string-based GameObject.AddComponent(string). Use the GetComponent<T> and AddComponent<T> methods instead. For the list of removed members and their replacements, refer to Upgrade to Unity 6.5.
This section outlines recent updates to Unity’s serialization system.
Unity now includes a serialization rules analyzer: a Roslyn diagnostic analyzer that checks your scripts against Unity’s serialization rules in your IDE and at compile time. It flags common mistakes, such as a serialized field whose type is missing the [Serializable] attribute, [SerializeReference] used on a struct or primitive, unsupported collection types, and so on, before they cause silent data loss at runtime. Each rule reports as a warning or an error, with a suggested fix.
This turns a class of serialization problems that previously appeared only as missing data at runtime into compile-time feedback. For more information, refer to Serialization rules analyzer reference.
The Unity Serialization package is implemented as a core package in Unity 6.5.
This section outlines recent updates to Graph Toolkit.
Added the AsVertical method to the port builder to allow you to place ports on nodes vertically. Input ports on the top and output ports on the bottom of the nodes. You can mix vertical and horizontal ports on the same node. Vertical ports can connect to horizontal ports of the same type, and vice versa. For more information, refer to Implement nodes for your graph tool.
You can now use the Graph.GetVariables(SortMethod.Display) API to retrieve variables in the order they appear in the Blackboard.
Similar to a standard node, you can now define node options for subgraph nodes. Use the Graph.OnDefineSubgraphNodeOptions(IOptionDefinitionContext ctx) callback.
You can now define inputs and outputs without a type for your subgraph.
Note: Untyped ports have their own defined icon and color.
Added node customization options that enable you to do the following:
TextArea
Coroutines/MoveTo.For more information regarding node customization options, refer to the available scripting documentation.
Use new API functionality to programmatically generate graphs. This is particularly useful for scenarios where you need to transform existing data flows into visual graph representations.
You can group these generation methods into a unified, undoable action by using the newly implemented Undo/Redo API functionality.
For additional details on programmatic graph construction, refer to the available scripting documentation.
Added inspectors for lists and arrays. Graph users can now dynamically change the size of a collection and update the value of each entry directly in the graph.
For Blackboard variables, you can now use the Mode dropdown menu to convert a simple variable into a list of the same type. To access this Mode menu, you must have created a port that can support this type of collection.
The Visual Novel Director sample now demonstrates how to use the node customization API. The sample customizes a node’s default icon, color, or title and changes a port’s direction. For more information, refer to the Visual Novel Director sample documentation.
The Graph Toolkit Samples package is an experimental package. In Package Manager, you must add the package by its technical name, com.unity.graphtoolkit-samples, to install the package and access the updated Visual Novel Director sample.
The Dungeon Graph Generator sample uses the new graph creation and modification API to procedurally generate graphs that represent levels for a roguelike dungeon crawler. For more information, refer to the Dungeon Graph Generator documentation.
The Graph Toolkit Samples package is an experimental package. In Package Manager, you must add the package by its technical name, com.unity.graphtoolkit-samples, to install the package and access the Dungeon Graph Generator sample.
This section outlines recent updates to Unity’s UI systems.
This section outlines recent updates to Unity’s uGUI system.
Added the Raycast Receiver component that serves as a non-visual interactable area. It intercepts raycasts from the Graphic Raycaster to detect or block pointer events such as clicks and touches. It does this without rendering any visible geometry, offering better performance than a transparent Graphic.
Added callbacks for loading font materials and color gradients:
They unlock new dynamic loading workflows by implementing custom loading for these asset types. For example, through AssetBundles.
This section outlines recent updates to Unity’s UI Toolkit.
Added the Panel Renderer component that replaces UI Document for adding UI Toolkit content to a scene. The UI Document component continues to work, and you can keep using it in your existing projects. However, Panel Renderer provides the same functionality but adds more features and performance improvements. It has better world-space UI compatibility. For migration steps, refer to Migration to Panel Renderer.
Added support for Panel Renderer to display its elements in the new Hierarchy window. You can also reference runtime visual elements in the Inspector window.
Modified the UI Toolkit Renderer’s meshThe main graphics primitive of Unity. Meshes make up a large part of your 3D worlds. Unity supports triangulated or Quadrangulated polygon meshes. Nurbs, Nurms, Subdiv surfaces must be converted to polygons. More info
See in Glossary management mechanism and algorithm, replacing poorly supported range-based buffer updates with a simpler, direct approach that uses more efficient low-level API calls to cut bandwidth, driver overhead, and CPU–GPU sync. This delivers significantly better rendering performance on WebGLA JavaScript API that renders 2D and 3D graphics in a web browser. The Unity Web build option allows Unity to publish content as JavaScript programs which use HTML5 technologies and the WebGL rendering API to run Unity content in a web browser. More info
See in Glossary and WebGPU, bringing them on par with other platforms, without API changes or visual differences.
The Advanced Text Generator (ATG) is now the default text system for UI Toolkit. It provides full feature parity with TextCore, including comprehensive font features and Unicode support, while delivering significantly better performance with CPU improvements ranging from 10% to 40%, depending on the text benchmark.
For more information, refer to Work with text.
Unity now includes an experimental tool called the USS Stats Profiler. After you enable it in Project Settings > UI Toolkit, you can select a UI panel, similar to other debugging tools, and collect statistics about USS selectors.
This section outlines recent updates to Unity’s XR features.
Added shader optimizations for Meta Quest build targets when you enable the Meta Quest build profile. Meta Quest shader optimizations reduce GPU frame time and shader instruction count, lower memory bandwidth, and provide better GPU occupancy to improve graphics performance in your project.
For more information, refer to Shader optimizations for Meta Quest.
You can also use the new UNITY_PLATFORM_META_QUEST macro to branch in custom shaders. For more information, refer to Branch based on platform or graphics API.