Upgrade to the latest Unity Engine today by downloading Unity 6.6. You can also explore the comprehensive list of improvements and new features in our “What’s New” documentation.
Unity 6.6 is a Supported release, offering the same support, stability and critical updates as our LTS versions until the next release - in this case 6.7 - 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.6.
Highlights in the 6.6 release
This final supported release of the Unity 6 family brings you one step closer to the 6.7 LTS, and realizes essential components of the new CoreCLR foundation that define Unity 7. This release also brings additional improvements to all areas of the development lifecycle, including content management, graphics, and platform reach.
CoreCLR and Foundation for Performance
Fast Enter Play Mode
Enter Play Mode Setting options - select “Do not reload Domain or Scene” for Fast Enter Play Mode
The most significant workflow change in Unity 6.6 is that the default setting for entering playmode is now reload scene only for all new projects. This means code will not be reloaded, and state, such as static variables, is not reset when entering playmode. Making it the standard helps ensure fast transitions going from Edit to Play mode in the Unity Editor.
We’re making this change as part of the complete move to CoreCLR in Unity 7, when traditional domain reloads will go away entirely. If you plan on migrating your project to Unity 7, making the minor code changes to be compatible without having domain reloads now is the best preparation. For a more technical guide to upgrading your project code, please refer to this technical article on discussions!
Native Dictionary Serialization
Unity 6.6 natively serializes Dictionary fields. You can now author and edit dictionary data in the Inspector without writing custom wrapper structures or boilerplate serialization code. Simply apply the [SerializeField] attribute to a dictionary field on a MonoBehaviour, ScriptableObject, or nested [Serializable] type, and Unity will seamlessly persist it across domain reloads, scene saves, and Play mode transitions.
The Inspector now also displays serialized dictionaries as an intuitive, two-column list layout with keys on the left and values on the right. Additionally, a built-in serialization rules analyzer validates your key and value types at compile time to catch unsupported signatures immediately.
Content Directories
Concept illustration for content directories
In this release, we’re introducing content directories for local content, giving you a more flexible way to organize and load game content without having to decide your bundle layout up front.
Your game can now load and hold only the assets it actually needs, rather than everything packaged together in a bundle. You can adjust how your content is organized as your project evolves, without having to lock those decisions in early or maintain custom grouping logic throughout development.
For teams already using Addressables, content directories integrates into the existing workflow while keeping the same Addressables API. This means you can continue using your existing code while benefiting from more granular local content loading. It also removes the need for many of the custom tools teams have traditionally built to manage AssetBundle grouping and duplication.
Converting existing AssetBundle groups is straightforward. Select the groups you want to migrate, right-click a group, and choose Convert Schema(s) to content directories.
You can find more information in the Conversion Workflow Guide.
AssetBundles aren’t going anywhere. You can continue using them in your existing workflows, particularly for projects that rely on remote content. Learn more about content directories.
Build Analysis
Example Build Analysis Window
Unity 6.6 also introduces a new Build Analysis window, designed to make it easier to answer the questions that commonly come up when investigating a build.
You can now review your build history alongside key information such as build type, platform, status, timestamp, size, build time, output path, and compression and cache statistics. The analysis views surface the largest assets and asset types in your build, highlight long dependency chains, and isolate the root cause of build failures from the surrounding build-step noise.
For deeper investigation, the Build Steps view lets you inspect and sort individual steps by duration and see associated warnings, while the Assets tab provides a searchable view of your content together with dependency-chain information.
When building with Content Directories, you can also compare builds to see exactly what changed between them and how those changes affected your build.
Learn more about Build History and the Build Analysis window.
Faster, More Flexible Hierarchy Window
Example New Hierarchy window
The Editor now uses the new Hierarchy window by default. Previously, you had to enable the new Hierarchy window explicitly.
The new Hierarchy window displays extra information about GameObjects and adds the following features: improved performance in large scenes, horizontal scrolling, and customizable, reorderable columns that display information about GameObjects in the scene, configurable visual options, and a full set of public APIs that you can use to customize and extend the window and support for items that aren’t GameObjects, such as entities and UI Toolkit visual elements.
You can also still use the legacy Hierarchy window. To enable the legacy Hierarchy window, refer to Switch to the legacy Hierarchy window documentation.
2D
2D Lighting with Rendering Layer Mask support
For 2D projects in Unity 6.6 2D lights can now use rendering layers in addition to sorting layers, making it easier to decide which lights affect which GameObjects. Discover further details by visiting the 2D light creation guide for URP.
Using Rendering Layers to apply different lights based on the environment conditions to the main character of Bunny Blitz without changing the sorting settings
Unity can also strip unused 2D light shader variants, helping reduce unnecessary shader work in projects that do not use every 2D lighting feature. See Optimize 2D lights in URP for more details.
2D Shadows with GPU skinning
Sprites in projects that use GPU skinning can now cast 2D shadows. Previously, enabling GPU skinning meant giving up 2D shadows on skinned sprites, but now you can keep your lighting and shadow work intact while moving skinning costs off the CPU.
Shadow caster 2D is now compatible with sprites skinned for skeletal animation with 2D Animation
New Profilers for 2D Animation, Tilemaps and 2D Graphics
The Profiler includes new modules so teams can better understand animation deformation, tilemap rendering, light batching, and shadow costs. This includes the following modules for 2D projects:
2D Animation
The 2D Animation module enables live monitoring of performance metrics, such as SpriteSkin deformations, vertex processing, and bone transformations, split by CPU and GPU usage. By using the Sprite Skin Statistics panel to examine individual game objects and their processing methods, developers can easily visualize patterns and identify bottlenecks to optimize animation performance.
The new 2D animation profiler module showing Sprite Skin statistics across CPU and GPU.
Tilemap
The Tilemap module in the Unity Profiler allows you to gain insights into your scene’s complexity by tracking rendered counts for tilemaps, chunks, and meshes, while also breaking down processing time across various operations like system time, rendering, physics, and specific batching modes. Additionally, an asset breakdown panel lists individual tilemaps, enabling you to identify which specific assets are contributing most to your rendering workload and pinpoint potential performance bottlenecks.
The new tilemap profiler module showing tilemaps, chunks and meshes rendered.
2D Graphics
The 2D Graphics module in the Unity Profiler provides comprehensive visibility into rendering performance by tracking key metrics for lights and shadows, such as texture counts, batching, triangle data, and draw calls. It also offers detailed performance timing for specific rendering passes, including normal and shadow operations, allowing you to isolate and analyze time spent to effectively optimize your scene.
The new 2D graphics profiler module showing normal maps, lights, shadows and timing data.
Sprite Editor workflows
The Sprite Editor window now makes it easier to manage multi-layered characters by highlighting individual sprites when you hover over them in the Skinning Editor. This enhancement provides improved visual feedback, allowing you to more efficiently identify and work with complex 2D characters. It also adds configurable zoom ranges to support a wider range of sprite sizes, and default protection against editing source file data that can be overridden in Project settings. Additionally, you can now edit bone colors within an overlay in the Scene view.
Delaunay subdivision for Sprite mesh generation
The Delaunay subdivision method has been added as a way to generate the mesh for a sprite. It creates a tighter fit to the Sprite’s outline. It produces more evenly shaped triangles that are better for interpolation. Deformation by bones or shaders will look better since the vertices are distributed more uniformly. Texture mapping UV coordinates would also blend more appropriately between vertices. Find out more at Sprite (2D and UI) texture Import Settings window reference.
Tilemap workflows
The Tile palette window now includes name-based filtering and the ability to lock brushes and palettes to active tilemaps, while the Grid Brush tab of the Preferences window offers new options to toggle or limit fill area previews and display brush names in the Scene view. Additionally, the Editor Diagnostics Preferences window now allows for a debug display of tilemap chunks in the Scene view for support reporting.
Graphics
Unity Compute Light Baker
With 6.6 we’ve added the Unity Compute Light Baker to Unity’s rendering technology stack.
Unity Compute Light Baker
With this change, Unity’s light baking engine produces lightmaps, light probes and adaptive probe volume data by leveraging the Scriptable Render Pipelines Core package based on Unity Compute shaders, and the Unified Ray Tracing API.
This means that light baking can now benefit from faster generation times through hardware-accelerated ray tracing where available.
How to use and upgrade to the Unity Compute Light Baker: There are a few differences in how the new light baker behaves that may require minor changes to lighting related settings in order to produce the best results. Please see the Unity Compute Light Baker user manual for more details.
Better graphics diagnostics and URP performance tools
This release introduces more ways to understand and optimize rendering performance. Project Auditor now includes a URP Settings Analyzer to help detect misconfigurations earlier in development, and the Profiler reports GPU Resident Drawer activity with details for coverage, culling, LOD, and pipeline timing. The Frame Debugger now displays the names and values of fields in constant buffers, making it easier to inspect what your shaders receive at runtime.
Example of frame debugger in action
URP also adds support for reading the current pixel’s depth directly from GPU memory on supported graphics APIs, which can reduce memory bandwidth for effects such as on-tile fog and depth-based smoke.
Streamlined Shader Graph, Visual Effect Graph, and Shuriken particle workflows
Shader Graph and Visual Effect Graph authoring also receive quality-of-life improvements in Unity 6.6. Visual Effect Graph can now create a compatible Shader Graph directly from a Shader Graph output block, and can expose promoted properties and keywords from Shader Graph subgraphs, making effects easier to configure and reuse.
Shader Graph also adds preprocessor directives in Graph Settings and lets authors mark subgraphs as deprecated to guide migration. For Shuriken Particle Systems, Unity 6.6 adds URP-compatible particle Shader Graph templates, including support for Mesh Particles GPU Instancing, so teams can build particle shaders in Shader Graph without relying on Custom Function nodes for common particle workflows. The node library now includes five particle-specific nodes, which are used in the updated Particle shader graph templates.
Shader Build Settings
Starting with Unity 6.6, we now expose a new setting to compile all of your project’s shaders using DXC (DirectX Shader Compiler) for DX12. Compiling your shaders with DXC unlocks support for the latest HLSL and Shader Model 6 features and optimizations, such as wave intrinsics and native 16 bit support. By using DXC, you can also analyze and optimize our shaders with modern GPU profilers.
The target shader compiler (DXC) is exposed through the new Shader Build Settings, accessible via the Build Profile UI:
Shader Build Settings
The new settings also let you configure the shader compiler and reduce build times. The system can automatically convert shader keywords into dynamic branches, as well as exclude unneeded keywords to greatly reduce the number of compiled shader variants:
We tested the new Shader Build system using the Survival Kids project. By default, a clean build of the project took around 1 hour and 46 minutes to complete. By enabling dynamic branching conversion, the clean build time is drastically reduced to only 32 minutes!
You can also use this system to configure shader compiler flags and set various defines. For example, when using the Quest Shader Build Profile, Unity automatically applies various shader library optimizations to squeeze additional performance on Quest’s GPUs.
UI Systems
uGUI
uGUI new SafeArea
The new SafeArea component adjusts a RectTransform so its content stays inside the region the device reports as safe, keeping UI clear of cutouts, rounded corners, and gesture areas without needing to define per device margins. It drives anchors, so everything parented under it is constrained too. You pick which edges to inset and author them against a reference orientation, so one configuration covers all four.
In addition, Layout elements now support a maximum size alongside minimum, preferred, and flexible. Max Width and Max Height are on LayoutElement and in ILayoutElement, layout groups compute their own maximums from their children so the constraint propagates up the hierarchy, and Content Size Fitter respects maximums with a new Clamped mode that constrains an element without driving its size.
RectTransform gains additive APIs to test whether two RectTransforms are coplanar and fit one inside the other, useful for keeping tooltips and popups within a container. TextMesh Pro’s SetText() now accepts ReadOnlySpan.
UI Toolkit
UI Toolkit now supports the backdrop-filter USS property, which applies filter effects to whatever is rendered behind an element rather than to the element itself. This makes frosted glass panels, dimmed overlays, and similar depth effects possible directly from USS, with no render textures or custom shaders required. Drop shadow has also been added to the list of built-in filters.
Examples using backdrop-filter on UI to apply filter effects to the 3D objects and other UI behind them.
You can now also observe and alter a VisualElement’s generated mesh before it reaches the GPU. Register a callback with VisualElement.AddMeshModifier to inspect or mutate the vertices, indices, and extra vertex channels emitted by mesh generation, attach extra channels the generator didn’t produce, or replace the geometry outright.
Examples of reshaping and restyling elements by intercepting their mesh after generation.
New profiler modules have also been added to help you understand the time and work required to update and render your UI. For example, you can see how long it takes to update layouts and bindings, how many events were dispatched on a panel, and the reasons for a rendering batch break.
Tracking the cost of a UI update from the Profiler window.
Graph Toolkit
Graph Toolkit gains a debugging layer. Tools with a runtime backend can now surface execution state directly in the graph. Animated wires and node accents show what’s running, port previews show the data moving through, and markers report errors and warnings in place. Stable identifiers for graph elements let a debugger correlate what it sees at runtime with the graph the user is looking at.
This release also gives more control over how graphs look and behave, including the ability to fully customize nodes’ visual appearance, configure port connections, add custom toolbar actions, and other quality-of-life improvements.
Wire styles reporting execution state.
Platforms
XR
Unity continues to add new capabilities across our supported XR platforms. In Unity 6.6, we’re bringing new features that make it easy to create even more immersive experiences including support for new OpenXR extensions that help you have more control over hand tracking, support for Spatial Audio in XR, and greater runtime performance on XR platforms.
With Unity 6.6, developers now can access adaptive performance for Quest platforms and adjust application quality based on real-time thermal and power state, ensuring consistent performance. Shader optimizations have also been introduced to help developers get more graphics performance out of platforms.
Web
WebGPU is production ready
Starting in Unity 6.6, developers can target WebGPU as a production graphics API for Web builds, bringing the rendering capabilities of modern desktop and console backends to the browser. WebGPU builds on DirectX 12, Vulkan, and Metal under the hood, which makes compute shaders, GPU skinning, indirect rendering, and VFX Graph available to web projects for the first time. WebGPU supports Universal Render Pipeline projects across 2D, 3D, Forward+, and Deferred rendering, along with the SRP Batcher, DOTS, and BatchRendererGroup, so existing rendering setups carry over without redesign.
WebGL 2 remains the default graphics API, so current projects are unaffected until you opt in. To enable WebGPU, disable Auto Graphics API under Other Settings in the Web Player settings, then add WebGPU above WebGL 2 in the Graphics API list. Unity falls back to WebGL 2 automatically on browsers and devices without WebGPU support. The new WebGPU Device Filter asset offers finer control, letting you specify which browsers, GPUs, and hardware feature levels are allowed to use the WebGPU path.
Progressive Asset Loading
Unity 6.6 introduces Progressive Asset Loading for Web projects, which delivers assets on a per-scene basis instead of downloading the full asset set before startup. Unity splits the build’s asset data into per-scene chunks and downloads only what the first scene requires, streaming in later scenes and their dependencies during play. This reduces the upfront download and shortens the time before players reach an interactive first scene, which has the greatest effect on mobile connections and on web portals where players abandon a slow-loading game within seconds.
Progressive Asset Loading is available under Publishing settings in the Web Player settings and requires no code changes, since SceneManager and Addressables APIs behave exactly as they do today. Keep Brotli or Gzip compression enabled when using it.
WebAssembly64
Web builds in Unity 6.6 can address up to 16 GB of memory through WebAssembly64, lifting the 4 GB heap ceiling imposed by 32-bit WebAssembly pointers. Projects previously constrained by that limit, including those with large scenes, high-density textures and meshes, or simulation-heavy workloads, can now grow past it. Because 64-bit pointers increase code size and add some runtime overhead, 32-bit remains the default and WebAssembly64 is best suited to memory-intensive projects. To enable it, set Maximum Memory Size above 4096 MB under Publishing settings in the Web Player settings. WebAssembly64 requires Chrome or Edge 128 and later, or Firefox 129 and later; Safari does not support 64-bit WebAssembly.
Mobile
Apple - Swift Project Type
In 6.5 we introduced experimental support for Swift Project Type across iOS, iPadOS and tvOS runtime targets.This is the foundation for Unity’s next generation of Apple platform development. In 6.6 we have made it easier and cleaner to access our new public API. The new UnityAPI framework will be added to your projects and through that plugins and customers can access the public API. You can use the API to pause and resume the iOS Unity Player, get information on lifecycle events, and many more native-level actions. You can provide us with feedback in our Discussions post
Consoles/PC
On Windows and XBOX Series X|S, Content Directories is now a supported data type when using Direct Storage. Direct Storage can speed up read speeds for supported data types by up to 40%.
Package signing now available for .unitypackage
The Export window signs the package with the selected organization
Starting in Unity 6.6, package publishers can sign .unitypackage files that they export, bringing trust signals to this format for both existing workflows and new projects. Signing lets developers identify verified content, confirm where a package came from, and confirm its contents haven’t been tampered with after publishing. Using the existing package creation flow, publishers can now sign via organization-aware workflows, tying packages to a verified publishing identity rather than just a file.
This feature is part of Unity Core Standards, Unity’s initiative to bring more transparency and trust to the package ecosystem. Signing .unitypackage files extends the trust experience Unity built for UPM packages to one of the most widely-used distribution formats in the ecosystem.
……..
With the release of Unity 6.6, 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.
