Get insight into our future plans, and when you can expect access to new services, features and functionality in the Unity platform.
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.RSS feed
- At Risk
- On Track
Released March 31, 2017
2D: Sorting Groups
Sorts a group of renderers (for instance, a character made up of a bunch of sprite renderers) as a whole without any interleaving of other renderers.
Tiles the sprite's texture using the 9-slice technique when the size of the sprite increased beyond the size of the texture.
Collision Geometry Visualization
Compute Shaders for Metal
GPU Instancing Improvements
- Procedural mode: supply instance data from a custom data source.
- DrawMeshInstancedIndirect: supply draw arguments from a GPU resource.
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.
Improve Component Dragging Usability
Drag component headers to reorder, move, copy them around. Suggestion on feedback
iOS Native Crash Reporting
Collect, view consolidated crash reports for iOS builds. Forums - Unity Performance Reporting
iOS/tvOS: ReplayKit Live Broadcasting support
Provide a solution to how to combine baked lighting with realtime lighting including proper handling of baked and realtime shadows. We will provide several presets to cover a wide range of scenarios including fully realtime GI lighting, partially baked lighting, and fully baked lighting.
Metal support for Editor on macOS
NavMesh workflow and low level API
- High Level workflow based on new components:
- NavMesh Surface – describes a volume where the NavMesh will be built, and allows you to have multiple volumes, at any orientation.
- NavMesh Link – allows you to connect two NavMeshes with a wide link.
- NavMesh Modifier – allows fine grained control of area types per Game Object; replaces static flags.
- NavMesh Modifier Volume – allows to change the area type of the NavMesh which falls inside the volume.
Everything above is built on top of a simple low level API.
- Low level API:
- Allows you to pass in the geometry that will contribute to the NavMesh building.
- Method to quickly collect render or physics geometry for building NavMesh.
- NavMesh data can be built for different agent sizes.
- NavMesh data can be created, updated, added and removed at runtime.
- NavMesh data and can be instanced several times at different position/orientation.
- ...and more!
New network transport
The network transport implementation used by the NetworkTransport class has been rewritten to be more robust and performant.
Optional PhysX debug configuration
- Select debug configuration to get more internal information/warnings/errors/performance advice from the physics engine
Particle System Improvements
- Multi-Edit support.
- Custom Data Module, including HDR color support.
- More flexible Custom Vertex Streams UI.
- New Burst Emission UI, with support for repeating bursts.
- Shape Module upgraded to support non-randomized behaviors (eg. looping and uniform distribution).
- Particle 2D collision optimization including a 10x performance improvement detecting collisions and improved solving of overlaps.
Physics2D: Collision Detection improvements
- 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 Contacts API allows any contacts to be retrieved per Collider2D or Rigidbody2D. Also provides more information on contacts.
- New EdgeRadius property adds a radius around the edges for BoxCollider2D and EdgeCollider2D providing expandable edges with rounded corners.
Introduce Sampler and Recorder classes which give access to built-in profiler labels in development builds. This will allow users to create in-game HUD and display important performance metrics.
Progressive Lightmap Baking (Preview)
Use PowerVR ray tracing to provide progressively updated lightmap bakes. This aims to reduce baking times and improve iteration on lighting. Blog
Sprite Editor Update
Sprite Mesh Tessellation Quality Control
Fine grained control on the quality of the sprite mesh. Tune accuracy and various other tessellation parameters.
Standalone: Use SDL2 on Linux Player
Implementation of window management and input handling with SDL2 instead of raw X11 for desktop Linux. Should be transparent to users, but enables future Wayland and/or Mir support.
Video: New API
Deprecating MovieTexture and providing a new video playback engine API targeting hardware decoding on platforms
WebGL Embedding API
WebGL support for WebAssembly (Preview)
Use the upcoming WebAssembly format to distribute our WebGL build output for smaller builds which can load faster and using less memory.
Released Nov 30, 2016
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
Easy setup of local cache server
- Cache server can now be setup by just enabling it in the editor settings.
- Cache server can vastly improve your import and platform switching times. See http://docs.unity3d.com/Manual/CacheServer.html for how to already use it today.
Exposed Meshes and ComputeBuffers to native code plugins
Full Binary Shader Serialization
- faster load times - no parsing at runtime
- smaller memory footprint
HDR texture improvements
BC6H compressed and FP16 uncompressed texture import formats on PC/consoles
Reflection probes use BC6H/FP16 too on PC/consoles now
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.
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
Linear space lighting support on mobile platforms
- OpenGL ES 3.0+ and Vulkan on Android
- Metal on iOS
Low-level graphics 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
OpenGL2 legacy support removal on MacOSX and Linux
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
- Unlimited Sub-Emitters of each type
- Use Time-based and Distance-based emission at the same time
- Simulate particles relative to any Transform component, not just World or Local
- Improved curve editor with animation window improvements and wrap mode support
PBR viewer/validation tool (Preview)
- LookDev editor window for viewing & validating meshes and materials in various HDRI lighting environments.
Physics2D Collision Detection
- New CapsuleCollider2D is a collider primitive that can be elongated in either the vertical or horizontal directions.
- 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.
Splash screen improvements
- Customise unity splash screen with logo, background and animation.
- Preview splash screen in editor.
- Uniform across all platforms
Texture Importer Improvements
- Decoupled texture format, compression and shape (2D/Cube)
- Removal of the "Advanced" texture type in favor of an "Advanced" options foldout for all texture types
- Reworked various parameters presentation in the GUI (sRGB, Alpha Usage...)
- BC4/BC5 compressed format support
Update PhysX to 3.3.3
- Update to the latest patch release PhysX 3.3.3
- Better performance on Android expected
Use the upcoming WebGL 2.0 API to take rendering in the browser up a level (and on par with OpenGL ES 3.0).
WebGL Brotli compression support
- Optional Brotli compression for WebGL. Improves build size over default GZIP.
- Hint: Needs extra setup on your server, only works with HTTPS, supported natively by Firefox and Chrome (JS decompression fallback provided by us).
WebGL: Use IL2CPP for final linking
- Caches and reuses linked artifacts. Reduces build time when there are only asset and no code changes.
Released July 28, 2016
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.
Depth of Field Image Effect
Improved depth of field, more performant, better quality. Supports multiple aperture shapes, and bokeh textures.
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.
IL2CPP for Android
Official support, removing experimental label.
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
Multi-Threaded Rendering Phase 2
- Parallel command list generation
Native SteamVR support
Integrated VR support for the HTC Vive.
OpenGL2 legacy support removal on Windows
- 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: Substance for Windows Store Apps
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
Single Pass VR
Improves performance across PC and PS4 integrated VR platforms by drawing to both eyes at the same time.
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)
Sunsetting iOS 6.x support
Sunsetting WebPlayer for all OSes
Texture Array support
Expose ability to use DX10/GL3/Metal 2D texture arrays in shaders, with a scripting API to manipulate them.
Tonemapping and Color Grading
Improved color grading with support for LUT, exposure, gamma, and other filmic settings in one post process effect.
WebGL Improvements (5.4)
- Option for fast build iteration times for development builds
Released Dec 8, 2015
Additive animation workflow improvements
Provide workflow where users specify a reference frame for additive animation. We also allow authoring of additive animation clips.
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.
Basic Multi-scene Editing
Allows you to open and edit multiple scenes in the editor. Ideal for creating large world.
A new 2D physics effector that provides 2D buoyancy and fluid-flow forces.
Deploy: LZ4 data compression
Introduces realtime LZ4 decompression for AssetBundles.
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.
Frame Debugger Improvements
- Remote frame debugger: run it on the remote device (e.g. Android).
- Displays shader properties used by the draw calls.
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.
Allows to map the pose of a Humanoid Avatar into another Avatar.
IL2CPP for Windows Store Apps
UnityEngine.JsonUtility is a runtime API for serializing and deserializing objects to JSON format.
Upgrading MonoDevelop to version 5.9
Multi-threaded Rendering Phase 1
Move off main thread:
- Flares, Halos, Lines, Trails
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
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
Placeholder Asset Creation Tool
Easily create primitives like diamonds, n-sided polygons, for 2D game prototyping.
Platform: Apple TV
Render to multiple displays on PC
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
- Shader data size / load time / memory improvements for large shaders
SpeedTree: Billboard Improvements
- Can Cast and receive real-time shadows
- Performance improvements via batching
Test: Editor Test Runner
WebGL Improvements (5.3)
- Soft Shadow support - Better quality for Standard shaders
- Automatic decompression of downloads if the server does not handle compression
Released Apr 16th, 2019
Add OpenGL ES 3.2 Support on Android
Add WebAssembly multi-threading support
ARM64 support for UWP
Developers can now target the ARM64 64 architecture when building for the Universal Windows Platform.
Async Shader Compilation
Fast Iteration on Android
Add a special path to support script-only fast iteration on Android mono.
Expand to assets hot reload based on addressables.
Freeform Animation : Modular Rigging
A form of rigging that uses a collection of interchangeable parts that connect together to create a modular rig. Each interchangeable part is comprised of a series of RigConstraints that defines how the part moves, deforms, and is influenced by other parts of the ControlRig.
Garbage Collector Upgrade
Experimental support for incremental garbage collection, which should reduce stutters and time spikes.
GPU Lightmapper Improvements
- Fix Non-Uniform Scaling
- Double Sided GI Support
- Cast and Receive Shadows
- Enable on OS X and Linux
Graphics Format API (Experimental)
The GraphicsFormat APIs provide performance by default through a full support of all GPU formats through an explicit engine behavior controlled by the users to avoid that extra hidden copy that would limit the user creativity.
Add H265/HEVC transcoding support on Windows and OSX Editor
Particle System C# Job System Support (Experimental)
Experimental C# Job System support allows you to efficiently read and write particle data from within a C# Job with no additional copies of your particle data.
Progressive Lightmapper Updates
- Optix Denoiser
- Add Multiple Importance Sampling (MIS) for environment lighting
Improve the Shortcut Management in the Editor. Make it possible for users to be able to remap keyboard shortcuts, and let feature developers be able to expose actions that can be mapped to shortcuts. The system is able to gracefully handle conflicts, where 2 actions are assigned to the same keys.
Texture Mip Map Streaming in Edit Mode
Texture Mip Map Streaming was added in 2018.2 for Play Mode and Standalone players.
This new feature enables Texture Mip Map streaming in Edit Mode in the Editor:
- This saves GPU texture memory in Editor by only loading the mips required for the Scene View or Play Mode views.
- This feature is disabled by default but can be enabled in the Editor settings.
Timeline Signals are an easy way for Timeline to interact with objects in the scene. Using a signal emitter and a signal asset, you can trigger a signal receiver that will define a set of pre-configured reactions to your Timeline.
UIElements for Editor Extensions
A new retained-mode GUI framework to rapidly develop performant and reusable Editor Extensions.
World Building Scene Visibility
In the scene view or via the inspector, toggle hide/unhide on one or more selected GameObjects.
- In the scene view you can select multiple objects and hide them.
- In the inspector, a visual feedback will be added to the GameObject (Ex: color, icon, ...).
- In the inspector, you can toggle visibility with the same visual feedback.
- If the GameObject is a parent of other GameObjects, the user will be able to hide/unhide all object from the parent’s hierarchy or only hide/unhide the parent.
Released Dec 10th, 2018
Android App Bundles for Google Play
Support for Android App Bundle (https://developer.android.com/guide/app-bundle/) the new upload format for Google Play, which allows to generate and serve optimized APKs for each user’s device configuration.
APKzlib for faster APK package build times on Android
Faster APK package build times on Android with internal build system: allow using apkzlib instead of aapt / apkbuilder when building Android applications.
C# Job System Support for Navmesh Raycasts
Methods for doing raycasts on the NavMesh, compatible with the C# job system.
C#7 - Roslyn
Update to use the Roslyn compiler. This will let users use the latest C# 7 features.
GPU Accelerated Lightmapper (Preview)
Support for GPU acceleration of the Progressive Lightmapper. Light baking with the Progressive Lightmapper will be significantly faster. This will improve iteration and baking times. Does not affect the Enlighten baking backend.
Haptics APIs for VR controllers
We now provide APIs for triggering haptics on the Windows Mixed Reality headset controller, Vive controller through OpenVR, and Oculus Touch controllers. We’ll continue expanding platform support and creating more feature abstractions in future releases.
Enables tilemap users to build isometric or hexagonal tilemaps.
Light Probe Deringing
Sometimes probes cannot faithfully represent the actual lighting information in a scene. In such cases “ringing” may occur which manifests itself as unwanted rings in objects lit by light probes. When enabled, the new feature removes ringing at the cost of reduced accuracy and contrast.
Nested Prefabs and Improved Prefab workflows
This update introduces a number of improvements to Unity’s Prefab workflows.
- Nested Prefabs. Yes, it’s finally happening.
- Prefab Variants. This feature lets a Prefab inherit the properties of another Prefab.
- Prefab Mode. New workflow for editing Prefab assets in isolation. You’ll no longer need to drag a Prefab to an open Scene to edit it.
Particle System Improvements 2018.3
- Burst Probability: Adds a new property to the Burst UI, which gives bursts a random chance of not being triggered at all.
- External Forces Upgrade: Introduces a new ParticleSystemForceField Component, which can be assigned to the External Forces Module of Particle Systems. This new Component offers a variety of controls, for gravity, drag, vortex motion, etc, when particles are inside its volume.
- Flip Option: We have moved the FlipU/FlipV options from the Texture Sheet Animation Module into the Renderer Module and enabled flipping on each axis for Mesh Particles. Be sure to use a shader with backface culling disabled, when flipping your meshes!
- Ordered Mesh Emission: A new option in the Shape Module for meshes, called "Vertex Ordered", which emits particles from each vertex of the mesh in order. This option behaves similarly to the Systematic option in the Legacy Particle System and is being added prior to the final removal of the Legacy Particle System.
- Ring Buffer Mode: A new Particle System mode where particles don't die when their lifetimes elapse. Instead, they remain until the Max Particles property is exceeded, at which point the oldest particles are replaced when new ones spawn. Useful for footprints, bullet holes, etc, and other persistent objects, where the user wants them to stay as long as possible, whilst maintaining a maximum budget.
- Roll Option (for VR): A new checkbox to disable roll when the camera rolls. This is most useful in VR applications where users do not want particles to follow the camera when the user rolls their head from side to side.
- Shape Module Improvements:
- Add visualization of the Radius Thickness property in the Scene View.
- Allow the Arc property to be used on the Sphere/Hemisphere shape.
- Texture Sheet Animation Improvements: Adds 2 new modes to the Texture Sheet Animation Module:
- An FPS mode, where animations play at a fixed FPS, regardless of particle lifetimes.
- A speed-based mode, where the animation frame is chosen based on particle speed, rather than age.
PhysX 3.4 Upgrade
Upgrade NVIDIA PhysX from 3.3 to 3.4
Remove the Legacy Particle System
It is time to remove the Legacy Particle System.
We are providing an upgrader on GitHub, which will convert Legacy Components (e.g. ParticleEmitter) into new Components (e.g. ParticleSystem). this upgrade should be performed in Unity 2018.2 or earlier.
Starting with Unity 2018.3, Legacy Particle Components will not work.
SpeedTree v8 support
In 2018.3 SpeedTree v8 assets (*.st files) are recognized and imported using SpeedTree importer:
• A new SpeedTree8 shader is used by the generated materials.
• Supports per-LOD approximated sub-surface scattering effect.
• Supports top-down billboards.
• Supports back face lighting.
• Improved vertex shader performance.
- GPU-instanced render path for terrain, yielding a dramatic reduction in draw calls for most cases.
- Auto-connect of adjacent terrain tiles.
- Seamless painting across multiple connected tiles
- An experimental C# API for building custom terrain tools, which can interact with newly introduced asset types for terrain materials and brushes
2018.2.0Download Current Release
Released July 10th, 2018
Animation Stream API (C# jobs)
ARM64 bit support for Android
Enable ARM64 bit support for Android, based on IL2CPP technology. Running 64-bit Android apps will have performance benefits, plus games will be able to address more than 4 GB of memory space.
C# Platform Certificate Store Synchronization
Certificate validation using .Net or UnityWebRequest APIs now validates against the platform system CA store where possible.
On XboxOne, PS Vita and Nintendo 3DS, which doesn't provide access to system store validation, an embedded CA store is used for validation.
C# TLS provider through mbedTLS
Support for TLS 1.2 (secure socket) from .NET code
Drop support for UnityScript
As our [blog](https://blogs.unity3d.com/2017/08/11/unityscripts-long-ride-off-into-the-sunset/) noted, we are dropping UnityScript support.
- Stopped accepting new Asset Store packages with UnityScript code
- Notified Asset Store author and removed Asset Store Package with UnityScripts
- Implemented [conversion tool](https://github.com/Unity-Technologies/unityscript2csharp)
High DPI monitor support for Windows
Support for per-monitor display scale factors on Windows.
IL2CPP managed debugger
IL2CPP managed debugging enables developers to use their preferred debugger to find and fix errors, even when using the IL2CPP back end. All debugging features should be supported for Visual Studio (with Visual Studio Tools for Unity) and Jetbrains Rider on Standalone, Playstation 4, and Mobile platforms.
Updates Camera component to optionally allow setting Focal Length / Sensor Size instead of vertical FOV in "Physical Camera" mode. These values will also be imported from FBX.
TLS 1.2 is now supported across all platforms. This brings the ability to secure your network traffic with the latest standards.
Support for using Java source files as plugins in Unity project
Ability to add .java (and .cpp) source files to Unity project plugin folder and those will be recognized as Unity plugins without requiring to separately build libraries for plugins in Android studio.
Support meshes with 8 UVs
Support for up to 8 UVs for model import, Mesh API and in shaders. Previously the maximum was 4.
Texture Mipmap Streaming
The Texture mipmap Streaming system gives you direct control over which mipmap levels are loaded into memory. Helping reduce the total amount of memory required for textures by only loading the mipmaps needed to render the current camera position in a scene. It trades a small cost of CPU for GPU memory saving.
Adds a number of small improvements to the TrailRenderer:
- SetPositions/AddPositions API
- Trails smoothly remove their old points, to remove visual popping.
- A new "Emit" checkbox, to allow trails to start/stop emitting geometry.
Vulkan support for Editor on Windows and Linux (experimental)
Experimental support for running the editor on Vulkan for both Windows and Linux.
Released May 2, 2018
2D Physics - Multithreaded Simulation (experimental)
2D Physics simulation ability to run on multiple cores.
Add support for IL2CPP scripting backend for macOS standalone
Add support for IL2CPP scripting backend for macOS standalone. This brings the CPU speed improvements of il2cpp to the MacOS standalone player.
Add support for IL2CPP scripting backend for windows standalone
Add support for IL2CPP scripting backend for windows standalone. This brings the CPU speed improvements of il2cpp to the Windows standalone player.
Animation: Weighted Tangents
This feature allows animators to create animation curves with fewer keys and smoother curves, by letting them control the weight of the tangents. Once a tangent is set to Weighted, the user can stretch it to affect the curve interpolation without adding any additional keys, for a smoother, more precise result.
Audio Sample Output API
Build Reports C# API
Allows retrieval of information about the build process after it has completed.
Building Android games as ARM64 bit executables - Preview
Adding ARM64 bit runtime support for Android, based on IL2CPP technology. Currently, only 32-bit ARM or x86 builds for Android can be produced using Unity. Almost all current chipsets ship as 64-bit however, and we're not leveraging the advantages that brings: running 64-bit Android apps will have performance benefits, plus games will be able to address more than 4 GB of memory space.
Built-in support for Resonance Audio spatializer
Integrated support for the Resonance Audio spatializer in the Unity Editor.
C# Job System
Support for asynchronous jobs in C#
C# Job system support for Navmesh navigation
Adds support for position, rotation, scale, aim and parent constraints.
Dynamic Resolution for PS4
Allows users to scale their render textures by a given percentage per-frame at runtime to have better control of the GPU load and maintain framerate.
GPU Instancing: Support for GI
Improve Crash Handling & Reporting
- Improve the user experience when Unity crashes: more sensible and informative error messages, better reporting UI, and so on.
- Report crash information to Unity's Performance Reporting service. This will help Unity diagnose and eliminate common crashes.
- Improve the reliability and accuracy of the crash handling process in Unity.
Lightmap UV overlap visualization
UV overlap visualization makes it easy to detect and resolve lightmap chart bleeding
Multi-Platform AR APIs - Preview
Provides experimental base APIs for building mobile AR apps across ARKit (iOS) and ARCore (Android).
Net Standard 2.0 Support and New "Unity" Profile
Net Standard 2.0 Support
New "Unity" Profile (supporting netstandard 2.0) optimized for size and AOT friendly
Particle System GPU Mesh Instancing
Adds support to the Particle System to render meshes using efficient GPU Instancing, when instancing shaders are applied to Particle Systems. On GPU that support instancing, this allows you to render more particles in less time.
Particle System Orbital/Radial Velocity
Adds new options to the Velocity over Lifetime module to add orbital and radial velocity:
- Orbital velocity spins particles around their Transform component
- Radial velocity propels particles out from the center
- Orbital offset, which allows users to specify a custom center for the rotation.
Particle System Sub Emitter improvements
Adds the ability to trigger Sub Emitters from the Trigger Module, and also via script.
Particle System Texture Emission Shape
Take the colors and alpha from a Texture source, and use it to generate particles.
Physics C# Job system support - async raycasts
C# Job system support for async raycasts.
Allows users to:
- Create and apply Preset assets directly from nearly any object inspector using the new Preset tool, or from the new API
- Apply Presets with drag & drop
- Set global default Presets from a Preset's inspector or from the new Preset Manager
- Create importers and Components with default Presets from UI, or using a new object creation API
- Display and edit Presets in the new Preset inspector
- Individual types can be blacklisted to prevent them from being "presettable"
Progressive Lightmapper Large Scene Support
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.)
Stereo 360 Capture
Experimental feature. Adds support for capturing monoscopic or stereoscopic 360 images as cubemap images. Works in the editor and at runtime.
Tessellation for Metal
Tessellation for Metal
Timeline: Clip Edit Modes
Mix, Ripple and Replace edit modes for Timeline clips,
Video: Android Asset Bundle Support
Windows Player Native Crash Reporting
Released Dec 19, 2017 - Now part of LTS as 2017.4
32 bit Mesh Index Buffers
Adds support for 32 bit index buffers, allowing to have meshes that have more than 65535 vertices.
360 Video Player
Allows you to bring in a 360 2D or 3D movie into Unity and play it back on the Skybox.
Assembly Definition Files
Ability to specify separate assemblies for user scripts.
- Better in-editor tools for authoring Cloth
- More of PhysX internals exposed (more options for collisions, self-collisions, etc)
Crunch compression library update
- Support ETC_RGB4 and ETC2_RGBA8 compression
- Improve compression ratio and speed for DXT compression
GPU Instancing Improvements
- Per-instance properties are now packed into a structure data type. One instancing constant buffer contains only one array of such structures.
- For most platforms the instancing array sizes no longer need to be specified by user: they are instead calculated automatically (maximum allowed constant buffer size / size of the above mentioned structure type).
- Instancing batch sizes are therefore improved on OpenGL and Metal, and instancing shader variants compile much faster and potentially costs less in terms of CPU-GPU data bandwidth.
HDR support in lightmap pipeline
Light LODs with realtime probes and baked lightmaps
Lighting Modes for Progressive Lightmapper
macOS Player Native Crash Reporting
Model Importer Improvements
- Add Markdown (.md) to the list of extensions recognized by TextScriptImporter.
- Add "Preserve Hierarchy" toggle to Model Importer to prevent root transform from being stripped when it has no sibling roots.
- Update SketchUp SDK.
Particle Shaders providing core particle rendering functionality
- Includes Surface and Unlit shaders
- Blended Flipbooks
- Soft Particle settings
Particle System Ribbons
A new Trail Module option to have particles generate a trail between each particle based on their age.
Particle System Speed Multiplier
Add a Speed Multiplier curve to the Velocity Module.
Recording Video from Editor playmode playback
Implement recording to generate video from editor playmode playback.
Support for alternative display manager Wayland on desktop Linux (Preview)
Universal Manipulator / Transform Tool
The Transform Tool combines the position, rotation and scale tools in a single tool.
Zoom in Animator Controller Window
Ability to zoom, frame & autofit in the Animator window.
Released Oct 12, 2017
- New TileMapCollider2D produces colliders per-tile for the 2D Tilemap.
Android Native Crash Reporting
- A new AssetBundle API which allows the reading of data from the AssetBundle to be handled by the supplied C# Stream object.
- Allows custom implementations for loading Asset Bundle data, instead of e.g. loading data using the Unity engine internal file APIs.
AsyncOperation completion events
An event name completed has been added to AsyncOperation and allows the registration of a handler with the signature void OnComplete(AsyncOperation op).
Deterministic Importers: Embedded Materials on import
Create materials inside the import prefab instead of in an external 'Materials' folder.
Show statistics and how much CPU time is consumed by the Realtime Global Illumination subsystem.
GoogleVR Video Async Reprojection
Async Reprojection Video allows an app to feed video frames directly into the Google VR Async Reprojection system. These frames are composited directly into the scene without going through the main Unity render loop. This provides a fast path to direct rendering of video regardless of the current frame rate Unity is rendering at. When using Async Video Reprojection texture filtering is skipped providing for a much higher quality output. There is an option to allow for the use of protected memory for users that need to render DRM protected content.
Enable 16 bit floating point format for emission for both realtime and baked GI.
HDR color picker limit increased from 99 to 64k.
Lightmap background (push-pull dilation)
- Fill the empty space in the (directional) lightmap.
- The push-pull dilation will take place in compositing jobs for both Enlighten and Progressive lightmapper.
Linear Rendering with WebGL 2.0
macOS player Retina support
NavMesh Builder Debug Visualization
Visualization of NavMesh in realtime for debugging.
Automatically destroy or disable Particle Systems when they stop playing
Particles: Burst Emission Curve
Use a curve to control the burst emission rate over time
Particles: Editable Custom Data Module Labels
Enter contextual labels for custom data, so you can easily remember what you are using it for in your shaders
Particles: Inherit Lifetime for Sub-Emitter particles
A new inheritance option for Sub-Emitters, to allow a consistent overall duration for an effect, incuding its Sub-Emitters
Particles: Linear Drag
Add Linear Drag to your particles to customize the amount of resistance applied to their velocities based on their size and speed
Platform: Vuforia Support
Integrated support for the development of Vuforia-powered apps in the Unity editor.
Platform: Windows Mixed Reality
Support the creation of apps for the Windows Mixed Reality platform:
Progressive Lightmapper: Cast/receive shadows
Stingray Shader Support
Support standard PBS shaders from Maya and 3D Studio Max.
Timeline visualization of audio clips
Windows Player Launcher
Move majority of Windows Standalone player into a separate signed DLL ("UnityPlayer.dll"), leaving the executable to be a thin wrapper that just calls into it.
Released Jul 11, 2017
Easily mask multiple sprite objects to create various game play visibility effects.
2D Physics - Simulation
Ability to manually simulate physics using "Physics2D.autoSimulation=true/false" and "Physics2D.Simulate(time)"
- Create an atlas asset within the editor
- Query the list of sprites in Atlas
- Runtime swap atlases and automatically rebind with loaded sprite renderers
Ambisonic audio sources
Add support for ambisonic audio clips and ambisonic decoder plugins.
Animation Performance Recording (Experimental)
Simple way to record animations in-game and play it back without having to redo the simulation
Asset Import: FBX improvements
- Support FBX SDK 2016.1.2
- Support for FBX lights and camera
Collaborate: Support Rollback
Support rolling back projects to a specific version
Keyframing Workflow Improvements
Ability to preview an animation without going in record mode
Native Plugin Extension API improvement
Exposed more callbacks to allow plugins to inject their own shader variants.
Particles: Alignment Improvements
- Support Render Alignment for mesh particles
- Align Particles to their velocity direction
Particles: Noise Module Improvements
- Apply noise to positions, rotations and sizes in customisable amounts
- Send noise data to shaders via new Vertex Streams
Particles: Physics / Collision Improvements
- New option in the collision module allows users to apply forces back onto the colliders their particles collide with.
- Fixes made to solve overlap issues in 3D collision. This means Enable Interior Collisions option is obsolete as it is no longer needed (it had been added as a workaround to solve other issues).
Particles: Shape Module Improvements
- New Donut emission shape
- New Thickness params for customisable edge emission
- Add custom transforms to your emitter shapes
- Randomize particle positions
Particles: Sprite Texture Sheet Mode
Use Sprites in the Texture Sheet Animation Module. Allows use of the sprite packing tools for atlasing/batching.
Post Processing V2 (Preview)
- Volume blending
- Support for custom effects
- External LUT authoring
- Effect improvements
- Workflow improvements
- Mobile and XR optimisations
Progress can be followed on the projects public [Github](https://github.com/Unity-Technologies/PostProcessing/tree/v2)
Scripting Runtime Upgrade (Preview)
Upgrade Mono and IL2CPP .NET runtimes to support the latest .NET functionality and APIs. This includes access to C# 6 and the .NET 4.6.x class library profile.
Improvements to UI profiling