Unity 7 Roadmap: Everything Coming Next!

Unity 7 / roadmap highlights (condensed)

Editor & workflow improvements (Hierarchy, extensibility, Core CLR path)

New Scene Hierarchy (roadmap item)

• Performance & scalability: efficiently handles millions of objects.
• Quality-of-life: visual indicators for game object types, customizable columns, and horizontal scrolling.
• Extensibility: improved editor extension support so custom tooling fits production needs.
• Hierarchy unification: in Unity 6.6, hierarchy support for Entities becomes the default, aiming for a single streamlined hierarchy showing GameObjects, Subscenes, and Entities.
• Entity filtering by component type.

Editor toolbar extensibility

• The main toolbar can use any visual element (not just predefined controls).
• Existing menu items can be surfaced as toolbar actions.
• The Editor Tools API works in any editor window for consistent custom tool UI.

Serialization modernization

• Native dictionary serialization in the Inspector.

---

Rendering roadmap (URP focus + major lighting/tech features)

Render pipelines

• The Legacy Built-in Render Pipeline is deprecated in Unity 6.5, but still supported in Unity 6.7 LTS.
• HDRP is available for Switch 2 in Unity 6.5.
• Overall emphasis shifts to URP (“single unified render pipeline”).

Universal Render Pipeline (URP) upgrades

• Surface Cache GI (Unity 6.7 alpha)
  • Adds dynamic real-time global illumination.
  • Avoids lightmap baking/probes.
  • Supports dynamic objects and runtime geometry (including user-generated content and runtime construction/deconstruction).
  • Designed to be fast and scale down to mobile.
• Screen Space Reflections (SSR) for better reflections in dynamic environments and reduced baking needs.
• Ground Truth Ambient Occlusion
  • Improved SSAO-style approach for subtle ambient shadowing where objects/surfaces are close.
• Physically based rendering additions (URP-native)
  • Physical light units (e.g., lumens) for consistent real-world intensity across scenes.
  • Auto exposure to adapt brightness like human-eye adaptation.
  • Physically based sky system using real atmospheric scattering (instead of a static skybox).
  • Atmospherics/fog color responds to the environment for better coherence in dynamic scenes.
• Upscaler framework
  • Runtime querying/selection of the best upscaler:
    • DLSS4 (NVIDIA)
    • FSR (AMD)
    • PSSR (PS5 Pro)
    • fallback: Unity STP (spatial-temporal post-processing upscaler)

Shader performance & build time improvements (Unity 6.6–6.7)

• Graphics state collections upgraded with cache-miss tracing to improve shader/PSO coverage.
• Automation for pre-caching shaders to reduce runtime stutter.
• Advanced shader delivery for DX12: pre-cache shaders before game start to reduce warm-up time.
• Compiler modernization: moving to DXC (starting with DX12, then other platforms)
  • Access to the latest HLSL and Shader Model 6
  • Improved debugging/optimization with modern GPU profiling tools
• Fast build profile: reported >80% reduction in clean build times for example project “Survival Kits”.
• Quest shader build profile: adds GPU-oriented optimizations automatically.

---

ML / neural rendering (neural texture compression first)

Neural Texture Compression (first ML focus)

• Compress material textures into a compressed material matrix.
• Train a small neural network to decode the matrix and reconstruct near lossless textures.
• Upload heavily compressed data at runtime to save VRAM.
• Reported result: about 40% reduction in texture memory.

Neural features built on Unity’s neural rendering framework

• Train/optimize using URP render data and your content.
• Integrates into the URP render graph.
• Runs efficiently via GPU inference (“Centus” mentioned).

---

UI / UGUI / UI Toolkit upgrades

Unity 6.6

• Improved text performance and flexibility (fewer allocations, better batching) for scalable UI.
• More layout capabilities (e.g., safe area support and layout constraints).

Unity 6.7

• Advanced text shaping pipeline, including right-to-left improvements.
• Additional upgrades around layout querying and rendering integration.

Unity 7 (UI system modernization + tooling)

• Upgrade UGUI for stronger rendering and better 2D integration.
• UI authoring workflow changes:
  • Advanced text generator as an alternative backend for TextMeshPro/Text Pro, enabling advanced text/input field features.
• UI Toolkit keyframe animation support
  • Integrated into the animation window.
  • Enables animating UI visual elements and GameObjects together in a single timeline.
• Scene view workflow improvements:
  • UI Builder authoring tools moved into Scene View for in-context iteration while animating UI.
• UI VFX improvements:
  • Filters like drop shadows and background blur with quick integrated workflow.
• Profiler support:
  • Performance analysis improvements surfaced directly in Unity Profiler.

---

2D & physics roadmap

Unity 6.6

• 2D lights extended with rendering layer masks for granular control (lights affect chosen layers).
• Physics Core 2D: modern multi-threaded 2D physics built on Box2D 3.0.

Unity 6.7

• Higher-level components as an intuitive interface for Physics 2D Core.
• New 2D profiling suite
  • 2D sprite skin profiler
  • 2D tile map profiler
  • 2D graphics profiler (2D lights/shadows + mesh/texture data)
  • Physics core 2D metrics profiler

Unity 7

• “High-control surface” for agent-driven 2D authoring
  • Abstracts low-level spatial math, hierarchy wiring, and component setup (LLM agents struggle with these).
• 2D animation improvements
  • Control rigs and physics-powered secondary motion to avoid manual posing.
• Integration of game objectless physics framework into 2D features
  • Faster/lighter workflows
  • Improved collision generation for tile maps and sprite shapes

---

Core CLR & Unity 7 runtime/editor architecture

Move away from Mono and full domain reloads

• Unity 6.6: faster “play mode” enabled by default for new projects (part of Core CLR transition runway).
• Unity 7: Core CLR becomes full direction
  • Mono removed
  • no domain reloads

Migration tooling

• Project Auditor added to the editor to find/resolve issues
  • e.g., static fields and memory leaks in preparation for Unity 7.

Validation releases

• Core CLR desktop player experimental in 6.7 LTS (and earlier core CLR desktop player referenced for validation).
• Experimental-to-CVP player forwarded into 6.7 LTS.

Unity 7 editor/player capabilities (Core CLR)

• Native .NET access with .NET 10 and C# 14.
• MSBuild support.
• Customizable C# SDK-based build pipeline.
• Desktop experience: streamlined editor/player with no Mono and no domain reloads.
• Graph Toolkit becomes a core editor extensibility API
  • Node-based tools with runtime visualization (animate wires/node progress)
  • Port previews
  • Inline errors/warnings with actionable fixes
• New API concept for state machines (custom states/transitions/conditions).

Agentic tooling in Unity 7

• Agents for game testing, authoring, and parallel tasks (setup, coding, asset generation).
• Integrates with “Frontier models” via an orchestration layer to reduce token costs.
• Agents connect to Unity pipeline/CLI/services to automate tasks.
• “Knowledge base” for consistent workflows/style/design guidelines.
• Live-tweak and save game changes back into the project.

---

Production pipeline & Unity CLI (beyond the editor)

New production pipeline foundation

• Mentions: API dashboard, Unity CLI, and an app ecosystem for access/review/automation/integrations.
• A single API supports deep links and non-editor context.
• Pluggable source control and compute compatible with Unity 6.0+.

Unity CLI

• Automation-first approach:
  • Drive editor/pipeline from the terminal
  • Use Roslyn directly
  • Avoid editor main recompiles/domain reload workflows
• Supports “MC mode” for direct connections.
• Defines custom commands in a pipeline package.
• Said to be available without subscription; closed beta adds more features.

Unity pipeline automation

• Node-based editor + REST API
• Initially limited closed beta (trusted partners), expanding later; full launch end of year.

Annotation package/API

• Comments/tags across the editor, Unity web dashboard, and custom tools.

---

Platform & runtime improvements (mobile/web/XR/console/windows)

Apple (iOS/macOS)

• Modernized Unity-to-Apple OS API layer with a Swift-first approach.
• Swift project type supports Swift-native plugin workflows and better alignment with Apple standards.

Android

• More runtime performance visibility in C:
  • application startup info/exit info (loading times, reasons, entry/exit points)
• Adaptive performance exposes CPU/GPU headroom signals (select SoCs first).
• Expanded controller support:
  • digital triggers
  • basic rumble haptics in input system

Windows/Xbox asset compression

• Support for Zstandard (Zstd) compression to reduce disk space and improve read speed.

Web (Unity 6.6+)

• Wasm 64: memory increase from 4 GB to 16 GB for larger browser projects (digital twins, heavy visualizations).
• WebGPU production readiness in 6.6
  • graphics device filtering falls back to WebGL2
  • PSO tracing for pre-caching shaders/PSOs
• Progressive asset loading in 6.7
  • load per scene instead of full project before anything starts
  • example load-time reduction: 9s → ~5s (~40%)
  • described as a player setting (no restructuring or addressables required)

XR

• Improved migration from controllers to XR hands in 6.6.
• Shader optimizations across supported XR platforms.
• Quest 3 / Quest 3S: platform toolkit coming.
• Improved spatial audio.
• Project Aura XR glasses:
  • officially supported (mentions “XRE Aura” as first pair)
• Single APK deployment
  • one build across Android XR devices with feature enablement based on hardware support.
• Project Aura puck trackpad input support via Unity Input + XR Interaction Toolkit.

---

Version control & content delivery pipeline

Unity Version Control

• Branch explorer in Unity editor (history, branches, merges, commits in one view).
• Unity-built diff viewer (text, images, scenes, prefabs, materials) in inspector-like UI.
• Build automation: artifact retention policies (delete by build age or build count).

Content directories (Unity 6.6+)

• Incremental system for building/loading/distributing content.
• Works with local content first; opt-in with Addressables/local content without code changes (if using addressables).
• Unity 6.6: local foundation + unified build analysis UI.
• Unity 6.7 LTS: faster builds, improved dependency analysis, clearer build failure errors.
• Unity 7: expands to remote distribution for smaller post-launch updates.

Cloud behaviors (Unity 6.7 LTS)

• Cloud behavior = a script running in cloud (server-authoritative logic by default) without a dedicated server/backend to manage.
• Focus: event-driven games and progression systems (card games, puzzles, board/idle, progression/inventory/rewards, guilds/clans, session recovery).
• Iteration loop: edit/reload/deploy/play; debug locally with breakpoints.
• Pricing: free tier then scaling with minimal cost at scale.

Networking simplification (Unity 7)

• Merge networking for game objects + entities into a unified package.
• Introduces ghost object API for high-performance networking for game objects without code rewrites.
• Mentions client prediction, delta compression, massive scale.

---

Trust, packaging, and monetization tooling (Unity Core Standards + Unity IAP)

Unity Core Standards

• Trust signals for package sources (trusted vs risky/non-compliant).
• Unity 6.6 extends trust signals to package files.
• Unity 6.7: project-wide settings enforce allowed package policies.
• Unity 7: UPM-powered samples and deeper package/component visibility.

Unity IAP 5.4 (direct-to-consumer)

• In-game payments and web shop access with minimal SDK juggling.
• Web shop availability described as free of charge (GA).
• Agentic chat in editor for branding/customization.
• Commerce features:
  • daily quests, rewards, loyalty programs
  • custom cart/checkout UI
  • deep targeting and routing offers
• Dashboard:
  • developer data framework, normalized transaction views (native vs direct-to-consumer)
  • player metrics, revenue trends, funnel visibility, segmentation, exports
  • benchmarks (market-level insights vs peers)
• Campaign orchestration with offer selection and timing using control groups.
• Mentioned integration with agents for automation and live ops without client updates.

---

Main speaker(s) / sources

• Matt (intro: “Hey guys, it’s Matt. Welcome to Speed Too.”)
• Unity roadmap sources referenced throughout:
  • “road map Unity released for Soul Unite 2026” (as stated in subtitles)
  • Multiple announcements across Unity 6.5 / 6.6 / 6.7 LTS / Unity 7 (as described by Matt)