Upgrade to the latest Unity Engine today by downloading Unity 6.5. You can also explore the comprehensive list of improvements and new features in our “What’s New” documentation.
Unity 6.5 is a Supported release, offering the same support, stability and critical updates as our LTS versions until the next release arrives. Upgrading regularly ensures you get immediate access to the latest features and bug fixes while making the eventual transition to the next LTS smoother.
Ready to update? Use our upgrade guide to help transition from your current version to 6.5.
Highlights in the 6.5 release
Our commitment for Unity 6 is to provide a faster, more reliable, and more stable Engine. Building on 6.3 LTS and progressing towards the 6.7 LTS, Unity 6.5 delivers foundational improvements and exciting new features for developers and artists looking to improve their workflows.
Unification and Foundation for Performance
We’re making progress towards our goals of Entity Unification to bring the power of Entities to all users and features without having to change familiar GameObject workflows. This shift has been started by replacing InstanceID with EntityID. Read more in our documentation or on this discussions post.
We are also making excellent progress along the path to a Core CLR Editor for Unity. This begins in Unity 6.5 with the Editor Lifecycle API for more control of code reloading in preparation for a CoreCLR Editor without domain reloads.
We’ve introduced a Profiler AI Assistant Integration to help troubleshoot many common problems encountered during development. Project Auditor updates have been made to help with migrating projects to Unity 6.5, and Performance Metric Signals added to collect high level runtime performance metrics.
2D Graphics, Physics and Performance Improvements
Unity 6.5 comes with several exciting 2D updates for customizing 2D lighting & shadows, improvements to Physics Core 2D and more.
In this release, we’re making it easier to create lighting effects in your 2D games, with custom 2D Lights as well as custom 2D Shadows. We’ve also introduced a new RenderSprite API that allows you to render Sprites without the overhead of GameObjects. Even better, these sprites still work with 2D lights, Sprite Masks and SRP Batcher.
2D Profiler, Tilemaps with Entity ID tiles, and Blend Shape API for Sprites
To help you optimize your graphically rich 2D games across a wider range of devices, the 2D module in the Profiler window has been improved to provide data on sprite rendering counts and which sprite atlases are being used. We’ve also introduced Entity ID tiles to improve the performance of setting tiles on a tilemap.
We’ve also introduced new BlendShape APIs for Sprites, providing the foundation for FFD-based sprite deformation. These APIs are especially useful for tool developers who want to create animated 2D sprite deformations beyond traditional bone-based approaches.
The PhysicsCore2D and RenderSprite APIs perform well together to simulate and render thousands of Sprites.
And lastly, in this release we’ve also introduced a new Physics Core 2D built-in module for Physics Core 2D API. Physics Core 2D has dedicated Project Settings too, offering a dedicated space for configuration. Disabling the older physics module, if not needed, reduces memory and build size.
This release of Physics Core 2D introduces new Transform Writing options, enabling custom transform writing and tweening. These transform feature updates let you write simulation results to your own targets, including ECS components, with pose-tweening handled automatically. If you’re writing to Unity Transform components, a new Parallel or Sequential setting lets you pick the writing strategy that best fits your Transform hierarchy.
Join the Physics Core 2D discussion here for more details.
Visual Effects & Shaders Authoring Improvements
Improved Graph Template Workflows
This release introduces a new “from Template” menu item available on Decal Projectors and Fullscreen Renderer Feature, and allows you to explore graph templates categorized by material types like Fullscreen and Decal. This makes it easier for you to create a new shader graph from a context, such as a Decal Project.
This workflow leverages the Template Window’s updated sorting and filtering capabilities, which now support graph metadata and favorites. Read more about this here.
Shader Subgraph Improvements and Switch Node
Shader graph switch node
We’ve also introduced enhancements to provide subgraph authors with capabilities similar to those available in custom nodes. Key improvements include:
- Inline Editors: Constant value fields now better reflect value types and support additional widgets, such as Color Fields for color inputs and specific constraints for float inputs (Enum, Integer, and Sliders).
- Input Constraints: Input connectors can now be disabled to enforce constant-only editing.
- Switch Node: A new node that allows for manual configuration of multiple conditions or automatic matching when an Enum input is connected as the predicate.
You can learn more about these updates here.
Shader Function Reflection API
We are introducing a new Shader Function Reflection API, which allows programmers and technical artists to write custom shader functions in HLSL files and see them automatically reflected and exposed in Shader Graph. This means that you no longer have to manually adjust the node topology to match the function signature, and you’re less limited in how a function could be defined.
This aims at eventually replacing both Custom Function Nodes and Custom Node internal API. More details on this update can be found here.
3D Graphics Optimization
PSO Tracing
To ensure smooth gameplay, we recommend using Pipeline State Object (PSO) tracing and caching to minimize shader compilation performance issues. Building upon previous introductions of PSO Tracing and Pre-Caching, Unity 6.5 elevates the workflow: Caching miss tracing will address any gaps in the PSO collection, helping you build a more robust cache. The Editor UI has been refined to enable codeless and automatic tracing, warming, and inspection of Pipeline State Objects. VFX Graph also features a new API to prewarm the compute shaders used by VFX Assets. More information about this update can be found here.
More Effects and HDR Rendering on Mobile
On-Tile Post Processing in Unity 6.5 makes supported mobile post-processing effects more practical by running them directly on the GPU tile in a single pass. Effects such as HDR, tone mapping, color grading, and vignette no longer need the same costly round trip through system memory, which can reduce bandwidth usage on Vulkan and Metal devices. For players, this can mean smoother performance, lower battery drain, and less thermal throttling during longer sessions.
Rendering Settings new Tile-Only Mode
The new Tile-Only mode helps teams keep those benefits throughout production. It validates the camera, renderer, and URP asset settings, then warns about or automatically disables options that would force extra passes and break tile-based rendering. This makes it easier to use mobile-friendly post-processing with consistent visuals, without accidentally losing the performance gains late in development.
Lighting Search - New Light Explorer
In this release we’re introducing Lighting Search, a new workflow in the Unity Editor designed to make it easier to manage lighting-related data in complex scenes.
Lighting Search brings powerful search, filtering, and editing capabilities into one place.
By bringing powerful search, filtering, and editing capabilities into one place, Lighting Search is intended to help you iterate faster and work more confidently at scale. It also addresses several long-standing pain points in Light Explorer, such as incomplete categorization of lighting objects, and the inability to save filters or selections.
Built on Unity’s Search framework, Lighting Search provides a table-based interface for finding, inspecting, and batch-editing lighting-related objects and data.
Graph Toolkit - Enhanced Authoring and Graph Customization
In 6.4, Graph Toolkit became a core part of the Editor. In 6.5, we’ve introduced advanced capabilities, such as the ability to create and manipulate graphs programmatically, enabling deeper integration with your workflows. The data model is also more flexible, with support for untyped variables and collections. On the visual side, you have more control to define how your graphs look and feel, with customizable icons, colors, and styling for your data types.
UI Systems
uGUI - Usability and API improvements
In 6.5, we’re enabling better control over UI interactions with a new RaycastReceiver component, new callbacks in TextMesh Pro for custom asset loading, and a small set of new APIs for GridLayoutGroups and Selectables. These are quality-of-life updates that make it easier to build and maintain UI without changing existing workflows.
UI Toolkit - Performance and Foundation Improvements
In 6.5, we’ve improved performance and profiling in UI Toolkit by allocating Computed Style and related data using unmanaged memory to lower Garbage Collection (GC) pressure while also reducing overhead when passing data to native code. We’ve also enabled the Advanced Text Generator by default for more consistent text rendering, and evolved UIDocument into the new PanelRenderer component for a more flexible runtime foundation.
Platforms
Apple Swift Project Type
In 6.5 we introduced experimental support for Swift Project Type across iOS, iPadOS and tvOS runtime targets. Under the hood, this is a complete re-architecture of the layer connecting the Unity Engine to Apple platforms, delivered in modern Swift language. It represents our foundation for Unity’s next generation of Apple platform development.
This means you now get a cleaner, Swift-first approach and Swift-native plug-in workflows, improved alignment with Apple platform standards, a future-proof development architecture, and a dedicated Unity public API for plug-ins.
Android Performance Improvements
For Android, our focus has been on improving startup and runtime performance. First, in 6.5 we are making available a ThinLTO version of the Unity Engine library across all Android targets. You can enable it for your production builds for improved runtime performance and reduced memory usage especially across CPU-bound games. Secondly, we have improved the runtime performance when choosing to build with IL2CPP Compiler Master Configuration. If you already use Master configuration for your production builds you should see benefits out of the box, otherwise you can switch between Release and Master and decide which is best for your project.
We have worked closely with the Production Verification team to understand the potential benefits you are likely to get, trying our optimizations across different games, devices, and over hundreds of runs. Enabling both thinLTO and the master IL2CPP configuration consistently improves Android runtime performance across multiple areas: startup time, scene load times, CPU thread frame time. Expect a gain of 5% on average for each area. Larger gains will be observed on more complex projects and squeezing better performance from lower end devices. Which is a fantastic win for those of you targeting lower end Android devices as it means you can squeeze even better performance from them and provide a smoother experience for your customers. Read more in our Discussions post
Averages across different runtime metrics when compared non-LTO builds with thinLTO and Master IL2CPP configuration enabled
Android : Making it Easier to Adapt to Multiple Screen Configurations
Android is moving towards a screen-fluid world, where experiences can launch in foldable devices, resized, or made to fill up the extent of the screen estate. In 6.5 we re-architected Android support for Screen APIs to bring more stability and modern capabilities to you. New APIs are now available to manage System Bars visibility and behavior, enabling configuration during application setup as well as understanding changes during runtime. We have also launched APIs to offer detailed understanding of a folding device’s features - such as its folded state, orientation, or if it has a hinge versus a fold. This empowers developers like you to further customize your game’s interface to adapt to these premium devices, react dynamically to any real-time changes, and offers possibilities for novel ways of interaction.
HDRP for Nintendo Switch™ 2
HDRP is now officially available for Nintendo Switch™ 2 , bringing a wide range of advanced features like physical light units, physical sky, volumetrics, and advanced shadows to reach high-end visuals. Check out PGA Tour 2K25, the first game leveraging HDRP on Nintendo Switch 2.
*Nintendo Switch is a trademark of Nintendo.
Web Assembly 2023 on by Default
In an effort to optimize the web development pipeline, we are making WebAssembly 2023 the default setting in this release. This transition reduces the complexity of our playback engine variations, freeing up resources to focus on advancements like Wasm64. Additionally, enabling Wasm2023 by default remedies a persistent bug related to enhanced code stripping, delivering noticeably faster build times for web developers.
DirectStorage using AsyncReadManager C# API on Windows
Starting from Unity 6.5, our C# AsyncReadManager interface has been rewritten to use a new low level I/O architecture on Windows. This allows you to make use of DirectStorage for your own custom reads without having to adopt any new APIs.
Xbox PC Remote Iteration support in Windows Build Profile
Unity 6.5 Adds Xbox PC Remote Tools support, enabling one-click remote build deployment to any Windows machine. Developers need to install Xbox PC Toolbox on both their development machine and their remote devkit, then pair the two devices. In the Unity Editor, they select Xbox PC Remote Iteration as the deploy method in the Windows Build Profile and enter the IP address of the remote machine. Unity handles the rest — deploying the build directly to the paired devkit. This works with both full and incremental builds.
Audio Workflows - Generators Access to clip data
Building on the modernization of our audio foundations in 6.3, in the 6.5 release we’re now allowing generators to access clip data.
Scriptable Generators
In 6.5 you’ll be able to use Scriptable generators to sample/stream audio clip data, with the Scriptable Audio Pipeline being extended to provide Audio Clip support for Generators - implementing IAudioGenerator and ICapabilities, meaning you can use them as leaf nodes in nested scriptable generator trees.
Under the hood, each AudioClip generator is backed by a streaming pipeline that decodes samples asynchronously in chunks, whether the clip lives in memory or is streamed from disk. To see it in action, we’ve rebuilt a simplified Audio Random Container using a nested generator tree, which shows a practical example of what this pattern makes possible.
Experimental Enhanced Audio Foundation (EAF) to mobile platforms
This foundation will eventually allow for superior integration of hardware-specific tech, such as native endpoint spatializers and haptics, and multiple audio device output, alongside exciting advancements the future may bring.
EAF is currently available as a transparent substitute for our existing audio backend across Windows, Mac, iOS, Android, and XBox for those on the 6.5 release. By launching the Editor using the -showAudioFoundationUI flag, you can reveal the new options in the Audio section of Project Settings.
Package Manager - Samples View
Example of a sample preview in Package Manager
As part of Unity Core Standards, we’re consistently investing in improving the Unity Package Manager experience. In 6.5, we’re introducing a new All Samples view within PacMan, where all available samples across installed packages, including dependency packages, can be discovered. Developers can search, filter, view example images, see descriptions and source package information, and import the samples they need much faster.
Cloud Code - Experimental Package for Stateful Cloud Code and Local Server
In 6.5, we’ve added experimental packages for Stateful Cloud Code and Local Cloud Code.
Stateful Cloud Code introduces scopes, a mechanism that allows server-side state to persist across calls — either for an individual player or shared across all participants in a multiplayer session. Where Cloud Code was previously stateless, resetting with each call, scopes now make it possible to retain data for the lifetime of a player or a multiplayer session. In practice, this means games that depend on persistent state — card games, idle games, turn-based multiplayer — no longer require a dedicated server to function. Stateful Cloud Code can handle multiplayer sessions and ensure your game scales with minimal cost, replacing the use of dedicated servers. For smaller teams especially, this significantly lowers the infrastructure barrier for building session-based or persistent gameplay systems.
The Local Cloud Code Server addresses a longstanding friction point in backend development: the feedback loop. Rather than pushing to a remote environment for every change, you can now deploy your C# modules to a local server and iterate directly from the Editor. Server calls made in Play mode are automatically redirected to the local instance, keeping the workflow self-contained. Beyond faster iteration, the local server also brings proper diagnostic support to backend development: you can attach a debugger to the local process, set breakpoints, step through execution, and inspect memory to resolve complex server issues at runtime. Combined, these two features close a meaningful gap between client and server development experience in Unity.
Check out this post for details and documentation.
……..
With the release of Unity 6.5, we’re continuing our commitment to providing a faster, more reliable, and more stable Engine. Please let us know here if you have questions, feedback, or excitement about how these updates will improve your experience with the Unity Editor.
I can’t tell how many packages there are left to be installed in this screenshot, as an example
