Unity Roadmap

Archive

Get insight into our future plans, and when you can expect new features and functionality in Unity to be released. Please note that our primary goal is to provide you with stable and reliable releases. As such, any indications of target release dates and features listed are subject to change.

  • On Track
  • At Risk
  • Delayed

Release: 5.3.x

2D: Buoyancy Effector

A new 2D physics effector that provides 2D buoyancy and fluid-flow forces.

2D: New Joints

  • FrictionJoint2D
  • TargetJoint2D
  • FixedJoint2D
  • RelativeJoint2D

2D: Placeholder Asset Creation Tool

Easily create primitives like diamonds, n-sided polygons, for 2D game prototyping.

Animation: Additive animation workflow improvements

Provide workflow where users specify a reference frame for additive animation. We also allow authoring of additive animation clips.

Animation: Euler animation curve import

Support for direct import and evaluation of Euler rotation curves in the engine. This is useful for some animation - like Camera cuts - where quaternion baking can't reproduce the exact behaviour of euler curves.

Animation: HumanPoseHandler API

Allows to map the pose of a Humanoid Avatar into another Avatar

Deploy: LZ4 data compression

Introduces realtime LZ4 decompression for AssetBundles

Editor: Basic Multi-scene Editing

Allows you to open and edit multiple scenes in the editor. Ideal for creating large world

Graphics: Async Texture Upload

A new feature that enables asynchronous loading of Texture Data from disk and enables time-sliced upload to GPU on the Render-thread. This reduces wait for texture GPU uploads in the main thread.

Graphics: Frame Debugger Improvements

  • Remote frame debugger: run it on the remote device (e.g. Android).
  • Displays shader properties used by the draw calls.

Graphics: Multi-threaded Rendering Phase 1

  • Move off main thread:
    • Particles
    • Sprites
    • Flares, Halos, Lines, Trails

Graphics: OpenGL 4.x support

  • OpenGL 4.5 support in Windows & Linux Standalone and Editor
  • OpenGL 4.1 support in Mac Standalone and Editor
  • OpenGL ES 3.1 AEP support on Windows for emulation
  • Threaded OpenGL rendering on Windows

Graphics: Render to multiple displays on PC

Graphics: Shader Optimizations

  • Shader data size / load time / memory improvements for large shaders

JSON Serializer

UnityEngine.JsonUtility is a runtime API for serializing and deserializing objects to JSON format.

MonoDevelop 5.9

Upgrading MonoDevelop to version 5.9

Networking: Host Migration

Support for migrating the "host" of a network game to be one of the non-host clients when the host is disconnected or crashes. This should allow the game to continue with only a slight interruption for the other players.

This will work with the network HLAPI for LAN games.

Particles: System Upgrade

  • Custom pivot points
  • Render in world, view or local space
  • 3D rotation
  • System scaling
  • Skinned mesh emitter shape source
  • New 3D collision parameters
  • 2D collision support
  • All module properties can now be set from script, including curves and gradients.
    • Emission, Shape, Velocity over Lifetime, Force over Lifetime, Color over Lifetime, Color by Speed, Size over Lifetime, Size by Speed, Rotation over Lifetime, Rotation by Speed, External Forces, Collision, Sub Emitters and Texture Sheet Animation.
  • Inherit Velocity module: new options for inheriting emitter velocity, including curve support

Platform: Apple TV

Platform: IL2CPP for Windows Store Apps

Platform: WebGL Improvements

  • Soft Shadow support ​- Better quality for Standard shaders
  • Automatic decompression of downloads if the server does not handle compression

Services: In-App Purchases (IAP) Basic Integration

  • Support for transaction APIs to implement In-App Purchases in your application across the most popular App Stores
  • Supported platforms include: iOS App Store, Mac App Store, Google Play, and Universal Windows Apps
  • Support for consumable, non-consumable, and subscription items
  • Aggregate, cross-platform revenue reporting and spender analytics through the Unity Analytics dashboard

SpeedTree: Billboard Improvements

  • Can Cast and receive real-time shadows
  • Performance improvements via batching

Test: Editor Test Runner

Release: 5.4.x

Editor: Localization of Editor UI

Localization of the Editor UI. (No runtime or building localized assets)

Editor: Retina/HDPI Support

  • Crisp fonts and 3D views on retina displays on OS X.
  • Most existing editor code will just support retina without changes.

Update: Zoomable game view complete, but late found issue on dependent OpenGL legacy backend prevents making 5.3.

Editor: Zoomable Game View

  • Better ability to view resolutions larger than what the Game View can fit.
  • Ability to scroll with scroll bars or zoom out until it fits in the view.

Update: Late found issue on dependent OpenGL legacy backend prevents making 5.3.

Global Illumination: Light probe grids for large objects(Light Probe Proxy Volumes)

The Light Probe Proxy Volume component will offer the possibility to get better ambient lighting information for large dynamic objects that cannot use baked lightmaps. A good fit for this feature would be large particle systems or skinned meshes.

Graphics: Basic GPU Instancing Support

  • Use GPU instancing to draw a large amount of identical geometries with very few draw calls.
  • Works with BillboardRenderers and MeshRenderers that use the same material and the same mesh.
  • Enhanced Standard shader & SpeedTree shader with instancing support.
  • Only needs a few changes to your own shader to enable it for instancing.
  • Set per-instance shader properties from script via MaterialPropertyBlock.
  • Supported platforms:
    • Windows: DX11 / DX12 with SM 4.0 and up.
    • OS X and mobile platforms support might come in 5.4.
    • Console platforms support will come later.

Graphics: Depth of Field Image Effect

Improved depth of field, more performant, better quality. Supports multiple aperture shapes, and bokeh textures.

Graphics: DX12

Graphics: Motion Vector rendering

  • Cameras can render motion vectors for dynamic objects, including skinned meshes
  • Useful for motion blur, temporal anti-aliasing and other post-processing effects
  • Built-in motion vector shaders handle majority of cases; possible to write custom motion vector passes for shaders too

Graphics: Multi-threaded Rendering Phase 2

  • Parallel command list generation

Graphics: OpenGL2 legacy support removal on Windows

Graphics: SSRR (Screen Space Raytraced Reflections)

  • Screen space raytraced reflections (SSRR) image effect is in development, that would provide more accurate reflections where possible, and fallback to reflection probes where screenspace information is missing.

Update: SSRR was split off from 5.2 work. This should just be an asset with the Standard Asset package, so it may still function with 5.2.

Update 2: Feedback is showing that it needs further work, delaying official release while considering a separate experimental release.

Update 3: Available here and on the asset store (when 5.3 is released)

Graphics: Texture Array support

Expose ability to use DX10/GL3/Metal 2D texture arrays in shaders, with a scripting API to manipulate them.

Graphics: Tonemapping and Color Grading

Improved color grading with support for LUT, exposure, gamma, and other filmic settings in one post process effect.

Particles: Improvements

  • Performance optimization
  • Non uniform scaling
    • Change the width and height of individual particles independently
  • Scriptable trigger system
    • Detect when particles are inside or outside a collection of physics colliders, and use a script callback to react to the trigger
  • Expose all properties to animation

Platform: IL2CPP for Android

Official support, removing experimental label.

Platform: Substance for Windows Store Apps

Platform: Sunsetting iOS 6.x support

Platform: Sunsetting WebPlayer for all OSes

Platform: WebGL Improvements

  • Option for fast build iteration times for development builds

Services: In-App Purchases (IAP) Advanced Integration

  • FakeBillingService to allow testing in sandbox environment
  • Support for client-side receipt verification and backend support for unified receipts
  • Export facilities for bulk upload to the iOS App Store and Google Play
  • Advanced revenue reporting and spender analytics through the Unity Analytics dashboard

VR: Single Pass VR

Improves performance across PC and PS4 integrated VR platforms by drawing to both eyes at the same time.

VR: Native SteamVR support

Integrated VR support for the HTC Vive.

Alpha: 5.5

Usability and Functional Feedback

Join Feedback Panel

Graphics: Exposed Meshes and ComputeBuffers to native code plugins

  • Mesh.GetNativeIndexBufferPtr
  • Mesh.GetNativeVertexBufferPtr
  • ComputeBuffer.GetNativeBufferPtr

Graphics: Full Binary Shader Serialization

  • faster load times - no parsing at runtime
  • smaller memory footprint

Graphics: HDR texture improvements

  • “HDRI” texture importing type
  • BC6H compressed and FP16 uncompressed texture import formats on PC/consoles
  • Reflection probes and lightmaps use BC6H/FP16 too on PC/consoles now

Graphics: Improve shadows precision for large worlds

Use reverse-float depth buffer for improved depth buffer precision on modern GPUs. Particularly improves directional light shadowing for large view distances.

Graphics: Line/Trail Renderer Upgrade

  • Use a curve to define the widths
  • Use a gradient to define the colors
  • Fully exposed to script
  • Sharp corners handled more gracefully
  • Add extra vertices to create rounded corners and ends

Graphics: Low-level functionality improvements

  • Per-render target blend modes in shaders
  • Manual render texture mipmap generation
  • Increased amount of shader keywords (from 128 to 256)
  • DX9 half-pixel rasterization issues are gone; now completely matches DX11/GL

Graphics: OpenGL2 legacy support removal on MacOSX and Linux

Graphics: PBR viewer/validation tool

  • LookDev editor window for viewing & validating meshes and materials in various HDRI lighting environments.

Particle System Upgrade

  • Send customisable vertex data to your shaders
    • Also allows for Normal Mapping and Standard Shader support
  • Rotate particles based on initial direction of travel
  • Align particles to the eye position, instead of simply facing the camera plane
  • Fully expose main particle settings to script
  • Add lights to your particles with the new Lights Module
  • Add noise to particle movement with the new Noise Module
  • Add ribbonized trails to your particles with the new Trails Module
  • New Color Gradient options

Physics2D: Collision Detection

  • New CapsuleCollider2D is a collider primitive that can be elongated in either the vertical or horizontal directions.
  • New EdgeRadius property adds a radius around the edges for BoxCollider2D and EdgeCollider2D providing expandable edges with rounded corners.

Physics2D: Rigidbody2D Improvements

  • New BodyType property allows the explicit selection of the body type of Static, Kinematic or Dynamic showing only the appropriate properties for each body type in the inspector.
  • New UseFullKinematicCollisions property allows Kinematic body types to collide with other Kinematic and Static bodies complete with collision/trigger callbacks.
  • New Simulated property allows the Rigidbody2D and any attached colliders and joints to be temporarily ignored by the simulated to be changed in the inspector.
  • New Material property allows a physics material to be assigned to the Rigidbody2D overriding the global physics material but applying to all attached colliders that do not have their own physics material specified.

Platform: WebGL 2.0

Use the upcoming WebGL 2.0 API to take rendering in the browser up a level (and on par with OpenGL ES 3.0).

Scripting: C# Compiler Upgrade

Upgrade Mono C# compiler against our current .Net 2.0 and 2.0 Subset profiles. Note that this is an upgrade of the C# compiler only, not the full Mono runtime

Alpha

Usability and Functional Feedback

Join Feedback Panel

AI: NavMesh workflow and bake API

  • Workflow: the workflow is now based on components
    • NavMesh Surface component describes a volume where the navmesh will be build, you can have multiple volumes, in any orientation
    • NavMesh Portal is a new component which allows to connect two NavMeshes with a wide link
    • NavMesh Modifier allows to change the area type of the NavMesh which falls inside the volume
    • NavMesh Markup allows fine grained control of area types per Game Object, replaces static flags
  • Bake API: everything above is built on top of a simple API which allows you to pass in the geometry that will contribute to the NavMesh building method to quickly collect render or physics geometry

Animation: AnimationPlayable.ProcessAnimation

Generates poses in Playable graph. This will allow user to write custom IK, prodedural animation, live mocap, bones-based mixer etc.

Director: Sequencer

Cinematic sequencer tool. Allows the authoring and playback of sequences of animation and audio clips.

Editor: Redesigned asset and component icons

  • The icons are getting a stylistic update, while being designed for greater consistency.

Global Illumination: Progressive Lightmap Baking (Experimental)

Use PowerVR ray tracing to provide progressively updated lightmap bakes. This aims to reduce baking times and improve iteration on lighting. Video

Graphics: Image Effect updates

Update important effects to be more intuitive, more physically based, and add dedicated mobile optimizations where relevant.

  • Exposure Adaptation
  • Temporal anti-aliasing

MonoDevelop and Unity REST Integration

Provide tighter integration between MonoDevelop and Unity by having them talk to each other through HTTP REST.

Features

  • File-less project/solution synchronization between MonoDevelop and Unity.
  • For instant synchronization of file add/delete/move operations in the assets folder, both ways.
  • Always build your scripts in Unity and providing build results in MonoDevelop. For consistent build behavior.
  • Entering play mode and/or attaching the debugger when hitting the play button in MonoDevelop.

Networking: Server Library

Update: Delayed for improvements based on feedback

Physics: Collision Geometry Visualization

Physics: Update PhysX to 3.3.3

  • Update to the latest patch release PhysX 3.3.3
  • Better performance on Android expected

Services: Collaborate

Unity splash screen improvements

  • Customise unity splash screen with logo, background and animation.
  • Preview splash screen in editor.
  • Uniform across all platforms

Video: New API

Deprecating MovieTexture and providing a new video playback engine API targeting hardware decoding on platforms

Development

In-progress, timelines long or uncertain

Development

2D: 9-Slice Sprites

Tiles the sprite's texture using the 9-slice technique when the size of the sprite increased beyond the size of the texture.

2D: Atlas

  • Create an atlas asset within the editor
  • Query the list of sprites in Atlas
  • Runtime swap atlases and automatically rebind with loaded sprite renderers

2D: Masking

Easily mask multiple sprite objects to create various game play visibility effects.

Update: Workflow concerns delaying feature

2D: SmartSprite

Procedural creation of 2d levels. Users could define control points that are then tessellated and textured with sprites. The control points can be used to define simple straight edges or curved edges for more organic looking levels.

Update: Addressing concerns with user experience after feedback. Update 2: Workflow concerns delaying further.

2D: Sprite Mesh Tessellation Quality Control

Fine grained control on the quality of the sprite mesh. Tune accuracy and various other tessellation parameters.

Update: Re-assessing our work shows that we need to go back to the drawing board.

2D: Sprite Editor Update

Animation: Generic IK

User definable IK chains

Animation: Generic Retargeting

Retargeting for non humanoid.

Build Reporting

Deeper, more prominent reporting of information about the player build process and outputs.

Deploy: Binary Reproducibility

Make build results consistent between builds as long as no assets are changed. This helps with various binary patching systems. There were several cases where assets were not consistenty ordered, or had uninitialized random data occasionally.

Editor: DPI Emulation

  • Extend Game View resolutions by also emulating a given DPI.
  • Particularly useful for getting accurate representations of UI layouts on target devices.

Editor: IMGUI Debugger

Gives the users ability to easily view all the draw calls for the IMGUI, with the option to open the source file in the right location, view all the data used to render the item.

Editor: Improve Component Dragging Usability

Drag component headers to reorder, move, copy them around. Suggestion on Feedback

Editor: Mac Editor on Metal

Editor: Save Play Mode Changes

  • Make it possible to selectively persist changes made during Play Mode so they are not lost.

Editor: Update build settings window

Global Illumination: Distributed LAN lighting builds

Polish the Hackweek X project on distributing lighting builds (precompute/baking) across machines on a LAN. The aim is to make a system that will automatically discover available machines and use them for time consuming lighting builds. No setup should be required. Video.

Graphics: Linear space lighting support on mobile platforms

Graphics: PBR Mobile Optimizations

Standard shader needs optimizations for low-end mobile/PC platforms. Some of these need to be GPU specific (for very popular GPU families)

  • Optimizations for Apple/PowerVR GPUs
  • Approximate/simplify for low-end GPUs like Mali-400
  • Automatic switching between "do math in shader" vs "texture lookup table" depending on GPU
  • Procedural Skybox shader optimizations

Graphics: OpenGL ES 2.0 support on Mac for emulation

IL2CPP deployment improvements

This is an ongoing task that we are actively rolling out in updates to Unity; we're heavily investing in reduced memory consumption, reduced distribution size and reduced buildtimes.

IL2CPP: Windows Runtime projections

Making IL2CPP understand Windows Runtime projections will enable C# scripts and plugins to consume Windows Runtime APIs directly on Windows Desktop, Windows Store and XBOX One platforms.

Input System

Create a better, more adaptable input system for Unity.

  • Event-based, framerate-independent input delivery
  • Custom device creation
  • More consistency between platforms and input devices
  • Better integration of variety of input types
  • Better support for multiple control schemes
  • Better separation between input and game logic
  • Deeper API access
  • More customizability

Scripting: Mono Runtime Upgrade

Upgrade Mono Runtime against our current .Net 2.0 and 2.0 Subset profiles. This includes many fixes and improvements, but does not include an upgrade to the .Net 4.6 profile.

Nested Prefabs

Nested prefabs will introduce a new workflow for prefabs which allows you to do nesting and inheritance of prefabs as well as allowing you to control which part of the prefab is exposed to the level designers.

Networking: Standalone Simulation Server

Physics: Automatic convex decompositions

  • Integrate V-HACD
  • A single mesh can be automatically decomposed into a set of convex MeshColliders
  • Helps with collision detection performance and accuracy
  • Enables sophisticated meshes on dynamic bodies and triggers

Physics: Cloth Improvements

  • Better in-editor tools for authoring Cloth
  • More of PhysX internals exposed (more options for collisions, self-collisions, etc)
  • Better integration with Mecanim

Physics2D: Collision Detection

  • New CompositeCollider2D allows other colliders to be merged together producing a single collider that can either be an outline or a decomposed concave polygon.
  • New TileMapCollider2D produces colliders per-tile for the 2D Tilemap.
  • New Contacts API allows any contacts to be retrieved per Collider2D or Rigidbody2D. Also provides more information on contacts.

Physics: Optional PhysX debug configuration

  • Select debug configuration to get more internal information/warnings/errors/performance advice from the physics engine

Platform: Apple Watch Basic Compatibility

Platform: Compute Shaders for Metal

Platform: New Nintendo 3DS

Platform: Microsoft HoloLens

Platform: Recording API for iOS and Android (experimental)

Recording API provides a high-performance thin-layer audio and screen and front-camera recording functionality to Unity engine on iOS and Android platforms.

Recording API allows developers to record their gameplay moments so that can be shared to different audiences.

Research

Investigations & design work

Research

2D: Character Animation

Redesigned 2D character animation workflow with IK posing support

2D: Standard Shader for Various Image Effects

Extended 2D shaders that provides various image effects including 2D lighting and shadow.

Animation: Physics-based animation

Editor: Focus Modes

  • Streamlined and unified structure for the increasing number of windows, tools, and visualisations in the editor.

Editor: YAMLMerge GUI

  • Front end for existing YAMLMerge tool.
  • Allows faster merging and easier conflict handling when merging e.g. scenes and prefabs.

Graphics: Scriptable Rendering Pipelines

  • Complete rendering pipelines constructed & driven from C# code
  • Similar to CommandBuffers, but operate on whole sets of objects, with efficient implementations in native code
  • Can imagine something like “deferred shading” just being a C# script that you can also modify to your needs (change G-buffer layout etc.)

Graphics: Vulkan Support

Platform: Apple Watch Improved Integration

Platform: WebGL multi-threading (Shared Array Buffers)

Implement multi-threading support in WebGL using the upcoming Shared Array Buffers feature in JavaScript.

Platform: WebGL SIMD (via SIMD.js)

Use the upcoming SIMD.js JavaScript features to get SIMD performance improvements in WebGL

Platform: WebGL support for WebAssembly

Use the upcoming WebAssembly format to distribute our WebGL build output for smaller builds which can load faster and using less memory.

Profiler: Improving GPU profiling on mobile

Traditional timer query based GPU profiling is not working on many mobile GPU architectures. Figure out better ways to achieve some GPU profiling. Develop new OpenGL ES extensions if needed.

Scripting: .NET Profile Upgrade

Upgrade .Net profile to 4.6 enabling access to the latest .Net functionality and APIs.

Script Api Updater: Expose APIUpdater to Asset Store authors

Give Asset Store authors the ability change their APIs with less friction and retain compatibility

Scripting: Garbage Collector Upgrade

Upgrade to a modern, generational, low latency Garbage Collector (GC). This will reduce stutters and time spikes spent in GC during collection.

Terrain System

Visual Scripting

Got it

We’ve updated our Terms of Service and software agreement to reflect recent changes to our business model. We’ve also updated our Privacy Policy to better reflect our current data collection and use practices.

We use cookies to ensure that we give you the best experience on our website. Click here for more information.