Search Unity

Unity 2018.1 marked the start of a new cycle with two major innovations at the core. Together, the Scriptable Render Pipeline (SRP) and Shader Graph give artists and developers more power, while the C# Job System, Burst Compiler and ECS make it possible to take advantage of multi-core processors without the programming headache. Unity 2018.2 builds on these innovations and adds several new features. This post provides an overview of the most important updates in 2018.2.

While you go through the list of new features, you can download Unity 2018.2 here or via the Unity Hub.

One of the goals for Unity 2018.2 has been to build on the Scriptable Render Pipelines (SRPs) in order to enable next-level rendering. Another focus area has been to develop a range of features and improvements that will help you succeed in mobile. Let’s take a brief look at what we’ve done in these two areas before going into more detail on the entire release.

Unity 2018.2 optimizes the performance of the Lightweight Render Pipeline (LWRP) and enhances the High Definition Render Pipeline (HDRP) to help you achieve high-end visual quality, including multiple improvements to the Shader Graph, which now supports both pipelines (please note that both the LWRP and HDRP are currently in preview.)

We also added support for managed code debugging on iOS and Android,  Windows, macOS, Nintendo Switch, UWP and PS4 for IL2CPP, and we started adding some mobile optimizations to the Lightweight Render Pipeline (LWRP).

For Android projects, 64-bit (ARM64) support gets its final release, and we now let you add Java code to your Unity plugins folder without needing to create libraries in advance.

Finally, several new 2D features are available as Preview packages, including the Vector Graphics importer and Pixel Perfect. The Vector Graphics importer makes it easier for you to work with SVG graphics, and Pixel Perfect makes it easier for you to achieve a perfect retro look across different resolutions on a wide range of devices.

To get an overview of all the improvements in this release, read on.

What’s new in Unity 2018.2

Give me all the details


Scriptable Render Pipeline (SRP) improvements

In 2018.1, we introduced the Scriptable Render Pipeline (in preview), which places control of powerful new rendering pipelines in the hands of artists and developers. This release includes the following SRP updates:

SRP batcher

Speeds up CPU rendering

The SRP batcher is a new Unity engine inner loop that speeds up CPU rendering without affecting GPU performance. It replaces legacy SRP rendering code.

Games that use Physically Based Rendering (PBR) often have many different objects and meshes that share the same shader and keywords for all the different materials per object. The SRP batcher gives games that use PBR a major CPU speed boost.

The SRP batcher works with the High Definition Render Pipeline (HDRP) and Lightweight Render Pipeline (LWRP), with PC DirectX-11, Metal and PlayStation 4 currently supported.

Scriptable shader variants stripping

Reduces player build time and data size

Player build time and data size increase with the complexity of your project because of the increased number of shader variants.

With scriptable shader variants stripping, introduced in 2018.2, you can manage the number of shader variants generated and therefore drastically reduce player build time and data size.

This feature allows you to strip all the shader variants with invalid code paths and/or unused features, and to create shader-build configurations, such as “debug” and “release,” without affecting iteration time or maintenance complexity. Scriptable shader variants stripping can lead to a massive increase in team efficiency. See this blog post to learn more about how scriptable shader variants stripping is implemented in the Unity shader pipeline architecture.

Shader variants stripping options in the GraphicsSettings


Lightweight Render Pipeline (Preview)

Delivers high performance

The Lightweight Render Pipeline (LWRP) delivers high performance, which is especially useful for lower-end hardware, performance-hungry applications like XR, and platforms, such as mobile.

LWRP improves performance and optimization further with Optimized Tile utilization. LWRP will adjust the number of load-and-store to tiles in order to optimize the memory of mobile GPUs. It also shades light in batches, which reduces overdraw and draw calls.

Basic LWRP is currently supported on all VR platforms, however, it will not support Multisample anti-aliasing (MSAA) until 2018.3.

Please note that LWRP is currently not supported for handheld AR, like ARCore or ARKit, or HoloLens or Magic Leap devices. New product plans will be communicated at a future date.

The LWRP delivers high performance for lower-end HW and performance-hungry apps like XR.

High Definition Render Pipeline (Preview)

First shipped as a Preview in 2018.1, the High Definition Render Pipeline (HDRP) prioritizes high-definition visuals targeting primarily high-end platforms, such as PC and consoles.

In 2018.2, we have gone further to help you achieve high-end visual quality. However, it is important to note that the SRPs are still Previews, and consequently not yet recommended or supported for production. Improvements include volumetrics, glossy planar reflection, Geometric specular AA, and Proxy Screen Space Reflection & Refraction, Mesh decals, and Shadow Mask.

Volumetrics: Volumetric fog receives lighting from all supported light types except area light. It is also possible to control the density of the fog locally with density volume.

Glossy planar reflection: Planar reflection now supports glossy reflection, which means that it takes into account the smoothness of the material.

Geometric specular AA: Mesh with dense numbers of triangles can cause specular aliasing. In order to address this, there is now an option to reduce and limit the amount of aliasing.

Proxy Screen Space Reflection & Refraction: This feature lets you use proxy volume (volume approximating the scene boundary) to perform screen-space reflection and refraction. While it is not as accurate as using the depth buffer, the runtime cost is lower.

Mesh decals: This allows you to use mesh for decals in addition to projector decals.

Shadow mask: Previously, this feature in HDRP used the Distance Shadowmask mode (dynamic shadow fade to shadow mask at maximum shadow distance). With 2018.2, it is now possible to select per light if the dynamic shadow only renders a non-lightmapped object (corresponding to the shadow mask mode of the built-in pipeline). So unlike with the built-in pipeline, HDRP allows both shadow-mask modes to be enabled at the same time, and you have a per-light control for the built-in Shadow mask mode.

Additionally, we have added limited Shader Graph support so you can visually create shaders, and we are working to improve overall stability and performance. Limited support means that only a subset of HDRP features is available in the Shader Graph. There are currently no advanced material features (SSS, clear coat), and tessellation is not currently available either.

Lastly, we have added a shader stripping feature, which makes it possible to avoid compiling shaders that are not required when building a player. This results in a much faster build time.

Please note the HDRP is not currently supported on any AR or VR platforms. Support for these platforms is scheduled for 2019. New product plans will be communicated at a future date.

Fontainebleau Photogrammetry demo with volumetric light shaft from Sunlight


The HDRP was instrumental for creating this entire car commercial in Unity

Progressive Lightmapper

There are several improvements to the Progressive Lightmapper, which came out of Preview in 2018.1.

Configurable baked light falloff

The configurable falloff in the Progressive Lightmapper enables you to match physically plausible falloff curves when baking your lights. Previously, the observed intensity of spot and point lights was greatly affected by the range value of the light. This is not physically plausible because the falloff distance (or attenuation) of a light in reality is determined by its intensity.

This feature allows the Progressive Lightmapper to decouple range and intensity by having a distance falloff that is tied to world-space distance. While legacy falloff is still supported, we now also support linear falloff, distance squared, and distanced squared with attenuation to zero at the range limits. Inverse square falloff is enabled by default in HDRP in order to match real-time lighting, and enables physical units for light intensity.

Instanced albedo and emissives for precomputed lighting

We used to allocate the emission and albedo in unique lightmap space for all our lightmaps. However, since instances generally share the albedo/emission characteristics, we now support generation of those maps per unique instance instead. This reduces the amount of memory that the Progressive Lightmapper uses, enabling you to bake even larger scenes.

Additive scene lighting warnings

For performance reasons, it is often preferable to split larger scenes into smaller “sub-scenes” that can be loaded or unloaded during runtime depending on visibility. This is known as “additive loading” or a “multi-scene” setup.

Additively loaded scenes with global illumination


The supported workflow that Unity offers when generating GI lighting for multi-scene configurations allows the user to load all required sub-scenes and then have them generate lighting for this complete scene hierarchy. The output is a LightingData.asset that stores lightmaps, Precomputed Realtime GI and probe data. This is associated with the first scene that is loaded, which can be inferred to mean the “master” scene.

Scenes that are then loaded/unloaded during runtime derive their lighting data from the LightingData.asset associated with the master scene. In this scenario, the Lighting Settings of the sub-scenes are irrelevant. However, scenes can also be baked individually or loaded in a different order depending on intent. This can lead to scenes having incompatible Lighting Settings and mismatched lighting data. For example, skyboxes may differ, lightmap resolutions may vary or mixed lighting modes could be different.

Previously, Unity did not warn the user of this problem and this has led to some confusion when results were not as expected. Unity now generates a warning to inform the user that there is an incompatibility. Then explicit information about any incompatibilities is provided for easier debugging and validation.

Other improvements

We also exposed the “per light” option to the cull lightmapped shadowcasters function (scripting API only), allowing it to be used by the HDRP.

Shader Graph (Preview)

In 2018.1, we introduced Shader Graph as a Preview package, in order to enable you to build shaders visually. Instead of writing code, you can create and connect nodes in a graph network. Each node in the graph gives instant feedback on the changes, and its ease-of-use means that even new users can be involved in shader creation. For this release, we made several improvements, including:

High Definition Render Pipeline (HDRP) support

Shader Graph now supports the HDRP with both PBR and Unlit Master nodes. Shaders built with the Shader Graph work with both the LWRP and the HDRP.

Vertex position

You can now modify vertex position via the Position slot on the PBR and Unlit Master nodes. By default, the input to this node is object space position. Custom inputs to this slot should specify the absolute local position of a given vertex. Certain nodes (such as Procedural Shapes) are not viable in the vertex shader. Such nodes are incompatible with this slot.

Master node settings

The settings for master nodes are now available in a small window that you can toggle on and off to change various rendering settings for your shader.

Property reference names and exposed state

You can now edit the Reference name for a property, making it far easier to reference your shader properties from script. To do so, select the property and type a new name next to Reference. If you want to reset to the default name, right-click Reference, and select, Reset reference.

In the expanded Property window, you can now also toggle the Exposed checkbox.

Editable paths for graphs

You can now change the path of Shader Graphs and Sub-Graphs. When you change the path of a Shader Graph, this modifies the location it has in the shader selection list. When you change the path of the Sub-Graph, it will have a different location in the node-creation menu.

Is Front Face node

With this node, you can change graph output depending on the face sign of a given fragment. If the current fragment is part of a front face, the node returns True. For a back face, the node returns False. Note: This functionality requires that you have enabled two sided on the Master node.

Gradient nodes

This adds gradient functionality via two new nodes. The Sample Gradient node samples a gradient with a given Time parameter. You can define this gradient on the Gradient slot control view. The Gradient Asset node defines a gradient that can be sampled by multiple Sample Gradient nodes using different Time parameters.

Texture3D and Texture2D Array

This change expands Unity’s support for Texture types via two new property types and four new nodes. These allow you to define and sample Texture 3D and Texture 2D Array type assets in Shader Graph.

Texture 2D LOD node

This adds a new node for LOD functionality on a Texture 2D Sample. Sample Texture 2D LOD uses the same input and output slots as Sample Texture 2D, but also includes an input for level of detail adjustments via a Vector1 slot.

Show Generated Code

You can now see the generated code for any specific node. To do so, right-click the node and select Show Generated Code. The code snippet will open in the code editor that you have linked to Unity.

Vulkan support for Editor on Windows and Linux (experimental)

This release includes experimental support for running the Editor on Vulkan for both Windows and Linux. Vulkan is a new generation graphics and compute API that provides high-efficiency, cross-platform access to modern GPUs used in a wide variety of devices from PCs and consoles to mobile phones and embedded platforms.

Texture Mipmap Streaming

In this release, we have added support for streaming texture mipmaps into memory on demand (i.e. only when they are required).

What is the benefit?

You can enable this feature to reduce the texture memory requirements of a Unity application.

How it works

When this system is enabled, Unity will only load the higher resolution texture mipmaps when meshes are close to an active camera. The high-resolution mipmap data is kept in memory while the overall texture memory is within a user-defined budget. If loading a new texture miplevel would cause the texture memory to exceed the budget, then the higher resolution mipmaps, on meshes furthest from the camera, will be freed from memory.

Speeds up initial load time

The initial scene load time may also speed up due to the reduction in texture data that is first loaded (i.e. loading just the lower resolution mipmap levels). The initial load-speed improvements are platform-dependent.

More control

The Texture Mipmap Streaming system gives you full control over which mipmap levels are actually loaded into memory. Normally, Unity will load all the mipmap levels that are stored on disk, but with this system, you can take direct control over which mipmap levels are loaded.

This system also trades a small amount of CPU time for potentially large GPU memory savings.

Simple to enable and manage

The feature is simple to enable via Quality Settings, where you can define, per texture, if each should be streamed by the system. You can query the metrics to identify the texture memory usage, while still being able to see the memory savings.

Various settings can also be adjusted to control the system so it balances the memory savings and CPU cost, and to allow you to prioritize some textures over others (e.g. character textures over environment textures).

C# Animation Jobs

AnimationPlayables now allow users to write their own C# Playables to interact directly with animation data.

Users can also write multithreaded C# code to control the AnimationStream data used by the PlayableGraph, which also allows integration of user-made IK solvers, procedural animation, or even custom mixers into the current animation system.

Particle System improvements

Here are the improvements in 2018.2:

Support for eight UVs

This allows you to use more custom data than ever before.

MinMaxCurve and MinMaxGradient

It’s now possible to use these types in your custom scripts, outside Particle Systems to match the style used by the Particle System UI.

Linear Color Space

Particle Systems now converts colors into linear space, when appropriate, before uploading them to the GPU.

Emit from Sprites

We’ve added two new modes to the Shape module, in order to emit from a sprite or SpriteRenderer component and match particle emission perfectly to the visuals of the sprite.


There are two new APIs for baking the geometry of a Particle System into a mesh: BakeMesh bakes the particle geometry, and BakeTrailsMesh bakes the Trails module to a mesh.

Show Only Selected (aka Solo Mode)

A much-requested feature, this has been made more discoverable and accessible alongside all the other previewing controls on the Scene View Overlay, with the Play/Restart/Stop, etc., controls.

ETC Texture Support

Shaders that use separate alpha textures can now be used with particles, when you use sprites in the Texture Sheet Animation module.


Pixel Perfect Camera (Preview package)

Try the Pixel Perfect Preview package to stay true to your pixel art vision. The Pixel Perfect Camera component will help you get perfect, crisp pixels – regardless of the screen size – by making all the calculations automatically for you.

Infectonator 3: Apocalypse by Toge Productions


Your sprites will even benefit from the feature when they are in motion or rotating, always keeping a sharp pixelation, without having to add interpolation to smoothen the edges as illustrated below.

2D Sprite Renderer “Sort by Pivot Point”

Traditionally, the distance between the center of a Sprite Renderer and the axis is used to determine which sprite would be rendered last and therefore appear at the front of the image.

With this release, you can use the pivot point instead of the center of the sprite as the reference point in the various sorting methods, such as arranging by distance to the top of the screen. For example, in top-down RPG games, you need the bottom of the sprite to determine the rendering order of the sprite.

The new pivot-point configuration lets you set criteria that better suit your game.

2D Hexagonal Tilemaps

You can now build Hexagonal Tilemaps. This includes support for flat-top and point-top Hexagonal Tiles, which are especially useful for making strategy games or digital board-games.

Art courtesy of David Baumgart


SVG Importer (Preview package)

This feature lets you import Scalable Vector Graphics (SVG) directly into your projects. The SVG Importer allows you to create sprite assets with a very small file size that will retain their quality at any resolution.

The SVG importer supports the most common features of the SVG 1.1 specification, such as gradients, fills, clipping paths, dashed lines, and rounded corners. Vector graphics sprites imported in this manner are supported by the Unity 2D tools.

Once an SVG file is imported, the vector data is tessellated into triangles and a sprite is generated. This sprite can then be used by the 2D system. The source for the SVG Importer can be found in the Editor folder of the package.

Get the SVG Importer as part of the Vector Graphics Preview package from the Package Manager.

The vector graphics APIs can be used to create and manipulate vector constructs directly in code. The source for the Vector Graphics APIs can be found in the Vector Graphics namespace under the Runtime folder.

New 2D APIs

You can use the Vector Graphics API to create or manipulate vector data directly in the code. The new 2D Atlas API lets you write custom tools to create or update atlases. For example, you could create personalized character textures using the player’s profile picture, or you could optimize the atlas based on the player’s configuration.

Editor – general

Support for using .java and .cpp source files as plugins in a Unity project

You now have the ability to add .java (as well as .cpp and .a) source files to Unity project plugin folders. These files will be recognized as Unity plugins and compiled into the APK without requiring the user to build libraries separately in Android Studio. The plugin code remains a part of the Unity project, eliminating the need to create a separate Android Studio project.

Standard Assets replacement

We have removed the 5.0 version of standard assets from the Installer in 2018.2 and are working on replacement packages for each part of the former prototyping pack. The first package (Standard Assets: Characters) will be available as a Preview soon after the 2018.2 release. It will contain a First-Person and Third-Person Controller integrated with Cinemachine, as well as a prototyping environment built with Probuilder. For details, watch for a blog post on the subject in the coming weeks. For those of you who need the legacy 5.0 package, it will remain on the Asset store.

Unity Hub

Unity Hub (v1.0), which will be released soon, is a new tool that was designed to streamline onboarding and setup processes for all users. It provides a centralized location where you can manage your Unity Projects, and it simplifies how you find, download, and manage your Unity Editor licenses and add-on components.

Since our initial release, we’ve been working hard at fixing bugs and fine-tuning the experience. In the past six weeks, we’ve already published more than four releases that have been automatically downloaded and updated on our user’s machines. Here’s a few things that have will ship with Hub 1.0:

  • Project templates
  • Custom install location
  • Added Asset Store packages to new projects
  • Modified project build target
  • Editor: Added components post-installation

In case you missed the beta release back in January, you can read about it in the blog post here.


Camera Physical Properties

This release includes new features that make artists and cinematographers feel more confident and in control when working in Unity, including the following:

  • A new Physical Camera toggle enables you to reveal settings, which artists and cinematographers will find instantly familiar, like standard Focal Length, Sensor Size, and Lens Shift properties.
  • The Model Importer now preserves the properties of Physical Cameras exported from Autodesk® Maya® and other compatible DCCs.
  • Cameras in Unity now perfectly match cameras in other DCCs without the need for additional components or manual FOV calculation.
  • The Camera component now provides a drop-down of Sensor Sizes for common real-world cameras.

Recorder 1.0

Unity Recorder 1.0, which will be released soon, comes with many updates that give users a simple way to manage and record animation clips, videos, and image sequences from the Editor:

  • New UI: A clean view and easy way for you to manage your recordings.
  • Presets: Save your settings so you don’t need to start from scratch.
  • API: Use scripts to trigger recordings through the API.
  • Multiple recordings: Start several recordings at once, and save them in a list if you need to use the same settings in the future.
  • Record video clips with audio in multiple formats.
  • Record image sequences in multiple formats.
  • Record and export animations: Export animation clips (via FBX) to your favorite DCC applications.

The Unity Recorder v1.0 will be available on the Asset Store.

Core Engine

Removal of the old RakNet-based networking feature

RakNet, our former networking feature, was deprecated in 5.1, and has been removed from Unity 2018.2. That means that any project that uses RakNet will not work with this release.

Addressable Asset System (Preview)

The Addressable Asset System makes it easier to manage all the things that make up your game, like prefabs, textures, materials, audio clips, animations, and so on. As projects grow, the number of assets increase too. Users have to reference them intelligently or else everything in your game, from local memory to content distribution, will become difficult to manage.

Your content-distribution strategy, in particular, will be harder to manage because asset references are typically resolved at build time, and users often face heavy refactoring in order to make modifications.

The new Addressable Asset System makes it easy for your team to scale as your game increases in size. It separates the three primary concerns of runtime asset management: referencing, packaging, and distribution. This simplifies referencing content, whether it’s on the local machine or distributed online via CDN, because the content is automatically loaded and unloaded for better memory management. We also provide profiler tools to further optimize memory usage. Ultimately, this results in faster iteration time for you.  


The new Addressable Asset System ships separately. It is available as an add-on via Package Manager and is now in Preview.

High-DPI monitor support

If you have a 4K monitor, you can now enjoy High-DPI scaling support on both Linux and Windows in the Editor and support for per-monitor display scale factors on Windows.

Deprecation of support for the .NET Scripting backend used by the Universal Windows Platform

Since Unity 2018.1, we have been supporting two scripting backends on the Universal Windows Platform (UWP): .NET and IL2CPP. With this release, we are deprecating support for the .NET scripting backend. The goals for this deprecation are twofold.

Easier to port games to UWP

The first goal of this deprecation is to make it easier for you to port games to UWP. Much of the developer pain associated with porting games to UWP in the past has been due to differences in API surface area and differences between the .NET Native and the Mono and IL2CPP runtimes Unity uses on other platforms. This change will ultimately make it easier for most developers to port games to UWP.

Helps us offer better support

The second reason for this deprecation is to make it easier for us to support you by fixing issues efficiently. Because the .NET scripting backend is completely different from the runtimes we use for all other Unity platforms, it has been challenging for us to maintain a consistent quality-level, relative to the rest of Unity. This deprecation will ultimately enable us to spend less time maintaining the .NET scripting backend, and more time working on the features and issues that are most important to you.

IL2CPP has the same .NET API surface as all other Unity platforms, and IL2CPP has had support for accessing WinRT types and APIs for some time now. So with the addition of the IL2CPP-managed debugger in 2018.2, the developer experience on IL2CPP is now on par with, and superior to, what the .NET scripting backend provides.

IL2CPP has been the default since 2017.2, so we expect most users will have no issues with this. However, if you have not yet tried using IL2CPP and you do experience any issues, please be sure to file them. We plan to end backend support for .NET scripting in 2019.1.

C# Job System, Entity Component System and Burst Compiler

With our new high-performance multithreaded system introduced in 2018.1, we’re rebuilding the very core foundation of Unity. The new system will enable your games to take full advantage of the multicore processors currently available — without the programming headache. This is possible thanks to the new C# Job System, which gives you a safe and easy sandbox in which to write parallel code. We are also introducing a new model to write performant code by default with the Entity Component System (ECS), and the Burst Compiler to produce highly optimized native code.

With great performance by default, not only will you be able to run your games on a wider variety of hardware, you’ll be able to create richer game worlds with more units and more complex simulations. You can learn more here.

Entity Component System (ECS)

In 2018.2, we added several improvements including Reactive system samples. The Reactive system will enable you to respond when there are changes to component state and emulate event-driven behavior. You can learn more about Reactive systems by watching Joachim Ante’s Unite Berlin talk on the subject.

We will also be providing a number of examples and documentation on how to implement Reactive systems using ECS.

During the latter half of the year, we will be providing small Unity game samples created by Unity users and converted to ECS by us.

Burst Compiler

With this release, burst compiling for ECS is available on all editor platforms (Windows, Mac, Linux), and you will be able to build AOT for standalone players (Desktop, PS4, Xbox, iOS, Android, and Nintendo Switch).

As we progress towards 2018.3, we will continue to focus on ECS performance, release a Preview of determinism, and support more .NET C# language constructions (DllImport, constant arrays, foreach, etc.).

We are aiming to bring the Burst Compiler out of Preview in the 2018.3 timeframe.

IL2CPP-Managed Debugger

IL2CPP-managed debugging is now available, enabling developers to use their preferred debugger to find and fix errors, even when using the IL2CPP backend.

All debugging features will be supported for Visual Studio (with Visual Studio Tools for Unity) and JetBrains Rider on standalone, PlayStation 4, mobile platforms and Xbox One planned for later.

Scripting runtime improvements in Unity 2018.2

Unity 2018.2 ships with dozens of bug fixes related to the scripting runtime, thanks to all of the great feedback we have received since the .NET 4.x.

ARM64-bit support for Android

With this release, ARM64-bit support for Android, based on IL2CPP technology, drops the Preview label. This version provides you with performance benefits because 64-bit Android apps and your games will be able to address more than 4GB of memory space.

APK splitting by architecture

You now have the option of splitting the target architecture (x86, ARM 32, ARM 64) into multiple APKs rather than making a large one. Then, for stores that support this option (like Google Play), you’ll only have to download the APK with the relevant architecture.

Google Play Instant Games Plugin

One of the biggest barriers to acquiring new players is the hassle of the install process.

Downloading and opening an app takes time and results in many users giving up before experiencing your game.

With Google Play Instant, players can try a 10MB instant version of the game without having to install it first. This plugin simplifies the conversion of a Unity-based Android app into an instant app, which can be deployed through Google Play Instant.

The plugin is available as a project on GitHub to use with Unity 2017.x and newer versions.

The plugin’s features include:

  • The option to switch between Installed and Instant-build modes
  • A centralized view of Unity Build Settings and Android Player Settings that need to be changed to support Google Play Instant
  • The ability to build and run the Instant App on an ADB-connected Android device

C# Platform Certificate Store Synchronization

We now fully support modern encryption (TLS1.2) across all platforms from .NET 4.x and UnityWebRequest APIs. This includes automatic verification against platform-specific certificate stores.

On Xbox One and PS Vita, which don’t provide access to system store validation, an embedded CA store is used for validation.

End of support for UnityScript

As previously announced, we have completed the deprecation of UnityScript with this release. See Richard Fine’s blog post from last summer for detailed information.

In general, we made this decision because as we continue to upgrade the Scripting Runtime and the version of C# we support, C# will enable greater possibilities:

  • The Scripting Runtime upgrade enables you to use .NET 4.6 and later C# 7.
  • The JobSystem makes it possible to easily write multithreaded code in a way that protects you from race conditions and deadlocks.
  • The NativeArray type allows you to create and work with large arrays that have their storage controlled by native code, giving you more control over allocation behavior and eliminating garbage-collection concerns.
  • You have control over the script-compilation pipeline, so you can customize how your scripts are combined into assemblies.

We also stopped accepting new Asset Store packages that contain UnityScript code, and we have removed packages with UnityScripts.

Finally, we provided a UnityScript-to-C# Automatic Conversion tool. There are a few of these available, but we weren’t happy with the approaches they use. Since we learned a lot about operating on UnityScript code when we wrote the Script Updater, we decided to apply that knowledge and build our own solution. You can download it here.

Visual Studio Code Debugger Extension

For those interested in using Visual Studio Code as IDE, we have developed, and we maintain, the Visual Studio Code Debugger for Unity extension, which is available as Preview.

For those interested in using VSCode to debug C# code within Unity, please go to this forum post and try it out. We’d love to hear what you think about it. Note that we are also updating the extension to make it support debugging of C# in the new Mono runtime in Unity and addressing reported bugs.


HoloLens Holographic Remoting

HoloLens Holographic Remoting allows applications to leverage the power of a local desktop machine to offload rendering and processing at runtime. We think our Automotive and AEC customers will find this feature particularly useful. Learn more on how to get started.

Release notes

The 2018.2 release also includes 183 improvements and 1426 fixes. Be sure to refer to the release notes for the full list of new features, improvements and fixes. We’ll be happy to discuss your feedback on the new features on our forum.

Thanks to everyone who helped test the 2018.2 beta

If you were a beta tester, you helped make the release of 2018.2 possible. So thanks for trying out all the new features and providing great feedback.

The 25 Unity Gear Set sweepstake winners

We are currently reviewing all the 2018.2 beta sweepstakes entrants and will soon send gift vouchers by email to the 25 winners. (To qualify for a prize, you had to submit a bug entry that had not been previously reported, that we could reproduce, and that we acknowledged was a bug.)

Be part of the next beta

If you are not already a beta tester, consider becoming one. You’ll get early access to the latest new features and you can test if your project is compatible with the new version. You also get to participate with some of the leading experts in the Unity community, help influence the future of Unity, and get a chance to win cool prizes.

You can get access simply by downloading our open beta test. By joining, you won’t just get access to all the new features, you’ll also be able to help us ensure the highest quality software.

As a starting point, have a look at this guide to being an effective beta tester. If you would like to receive occasional emails with beta news, updates, and tips & tricks, please sign up below.

133 replies on “2018.2 is now available”

Can’t I use shader graph in VR game? It doesnt work(solid black screen – HTC VIVE) when I use shader graph and LWRP.

Can’t I use Shader graph to VR game? steam vr is not working(HTC VIVE HMD Screen is always black.) when I use LWRP and Shader Graph.

2018.2.4 environment VERY SLOW and graphics / dialogs not working on my Mac (posted in OSX forum).

The SVG-Update is great. Is it possible to change the color of SVGs? I thought I can simply change the sprite color, but nothing changed.

Would be great, because my game and game characters really only consist of circles, rectangles and other shapes and I would like to only use as few resources as possible (so for instance, if I need a blue triangle and a red triangle I would like to use an SVG with only a white triangle and manage the color in-game).

Is it possible to achieve this?

The SVG-Update is great. Is it possible to change color of SVGs? I thought I can simply change the sprite color, but nothing changed.

Would be great, because my game and game characters really only consist of circles, rectangles and other shapes and I would like to only use as few resources as possible (so for instance, if I need a blue triangle and a red triangle I would like to use an SVG with only a white triangle and manage the color ingame).

Is it possible to achieve this?

There is one feature that would be helpful for high quality visualisations. Especially when it comes to human body. It is a support for rigs with more than four influences per vertex. HDRP would be an appropriate place to introduce it.

There is a regression with InputField in Unity 2018.2: it breaks Korean IME. Certain combinations of Korean letters disappear after typing. I’ve already filed a bug report about this, but I’m leaving this comment here in case somebody else is also running into this issue. You can rollback to 2018.1.9f1 to avoid this problem for now.

Is this a release candidate or final version?

I cannot believe that it has severe bugs with rigid bodies (already reported and marked as fixed in a future release).

These 2018.x versions almost killed our project, I’m stuck with 2018.1b11 since almost all newer releases have this bug. Something critical, kinematic rigid bodies are being affected by the movement of their parent (non kinematic), this should not happen… I hope that a fix will come soon, it is hard believing that these Unity releases are stable.

First we got an Android crash with 2018.2, it got fixed soon but it take many hours where we searched for what was causing the issue… And the problem was not at our project. And now this severe bug with physics.

These versions should have the beta label guys, please. They are awesome given all the new features, but are far away of something stable or recommended for serious use. I lost more than three entire weeks of work since 2018.1 “stable” came out (so I’m with the 2018.1 beta 11, it has bugs in editor but nothing critical on player).

Maybe launching two more stable versions each year could be a better idea instead of three? This would allow more time to beta testing, without suddenly breaking our projects with a final problematic release.

Hey! Could you let me know the case numbers in question? I’d follow up with the status. Thanks so much for your interest in physics.

Awesome! Nice work! Unity took right direction with their engine.
Waiting for UI system minor improvements and Editor UI update.

Absolutely love the direction that Unity is taking. I have been working with Unity for a long time now and it literally went from kinda clunky to very professional feeling!

SVG question…. Does Unity 2018.2 support SVGs with transparencies? I create all my art in Illustrator which I then convert to PNGs. I often adjust the opacity in many ways as the shapes overlap.

Does Unity support right-to-left text yet? I’m using the InputField component and I had to develop a custom script that flips the input when appropriate, but it’s not reliable when mixing ltr languages with rlt ones.

Did anyone tested 2018.2.1 with default project no SDK imported its cant build send error multidex-1.0.2 cant be found. does QA actually work ?

“IL2CPP has been the default since 2017.2, so we expect most users will have no issues with this. However, if you have not yet tried using IL2CPP and you do experience any issues, please be sure to file them. We plan to end backend support for .NET scripting in 2019.1.”
Is this only related to Universal Apps or every platform?

Hey guys, just wondering if the SVGs that get imported are currently supported by your UI system, as when I try to display an SVG on my UI it seems to be invisible. Works fine as a 2D Sprite though! Any info would be much appreciated, cheers :)

Hello Tom, unfortunately SVG is not yet supported by the UI system. This is something that gets asked very often and we’re seriously considering it. Thanks for the feedback!

– get Windows 10
– get more RAM (min. 16GB highly recommended, maybe more, it depends on what you’re doing)
– get an SSD as a working storage

I absolutely love the idea of SRP. But, will it be possible to write a shader with a custom lighting model? For example, I would like to change the Fresnel approximation for a car game I’m developing.

Say you’ve got a 2D game, totally unlit. Zero lighting etc. Running IL2CPP. Would the LW SRP make a difference in performance?

Not the i’m aware of, the main scripting lang is C#, but that shouldn’t stop you, you can do it !!!

In the runner game, stutter problem can not be solved at all.
Is it the technical limit of Unity?

Hi there :),

If you can provide more info, e.g. what kind of stutter, screenshots of the profiler, exported profiler data and generally more context in a forum post and tag it “performance” or “profiler”, other users and maybe me, if I can find the time, can have a look at it.

With this little information to go on and with having build an runner game for mobile myself before, I’m gonna go out on a limp and assume the typical problem: Allocating data on the heap (showing up in the Profiler as GC.Alloc) costs performance and will eventually trigger GC.Collect since the heap is garbage collected (“managed”) in C#. Garbage collection has quite the performance implications. There are a lot of mobile games out there, where you can practically see how they are allocating some 40mb of “soon to be garbage” every frame with the typical GC.Collect hiccup every x seconds. This is not really an issue isolated to Unity but within Unity, it is rather easy to ignore or overlook this problem until it’s too late. Especially with action oriented games, you want your game loop to be running GC.Alloc free. Use the profiler to find where your issues are. See where you can preallocate data or can convert classes (heap data) to structs (stack data) etc. There’s also a bunch of videos on performance optimization in our YouTube channel.

Your PC is trash…. Sorry but there is no other way to say it. I experience no stutter whatsoever on multiple machines. You should try to meet the recommended requirements before saying it does not work as intended.

Wow, that was an impressive list of changes. The master node settings is a nice QoL, as is editing the reference name for a property. We can now see the generated code for any specific node? I don’t remember asking for this, but I think someone at Unity enjoys making even the little things as easy and convenient as possible. Thanks, Unity team!

Oooh man, still you’re keeping me in suspense for nested prefabs and automatic tiles (I know I can already download them, but was hoping on the official release just to be safe). But ECS is coming to Whoville, hurray! My game doesn’t need the extra performance, but at the same time why not?

I really respect that you’re modernizing your (and our) entire workflow, and slimming down certain features to really give the rest of Unity the attention it deserves. Though I still can’t get my hands on those juicy nested prefabs, at the same time you’ve given us all these other updates which are, honestly, a bit overwhelming. If you keep this up, UnityHub will soon need dropdowns for each version of Unity to keep browsing through the releases manageable!

Great stuff, give Joachim Ante my regards.

I had a few issues with package manager import.cs and various other minor issues when loading my project solution in VS2017. Turns out all I needed to do was do an upgrade of VS2017 to the latest 15.7 release.

Just a little heads up for anyone updating to the latest and greatest unity.

Great work and love the features….

Will i need to redownload the prefab preview of 2018.2 in order to get latest changes?? are you guys keeping prefab preview build up to date with all the changes above?? i really want to get back to an official release, but i will not go back to old prefabs… stuck on 2018.2.x or whatever :(

Hi Brian,

There is not going to be an update of the preview build with Prefabs. All resources are currently focused on getting the new Prefab workflows ready for 2018.3.

How to run Unity2018.2 with Vulkan API?
I downloaded and installed Unity2018.2.0f2 on Ubuntu 18.04 with AMD RX460 GPU but graphic api unity using is OpenGL4.5
I try with -vulkan when run unity but not working
I can play Dota2 with -vulkan so graphic driver is ready with vulkan

You need to set Vulkan as the preferred rendering API for your current build target in the player settings, or launch the editor with -force-vulkan

Last ngiht I tried with -force-vulkan but not working, Tonight, I will try change in player setting

If it’s not working with -force-vulkan, check your editor log to see whether vulkan support is being successfully loaded/enabled (and if not, why not).

I try with -force-vulkan and received error in Editor.log file
[0713/] Running without the SUID sandbox! See for more information on developing with the sandbox on.
Gtk-Message: 00:30:36.044: GtkDialog mapped without a transient parent. This is discouraged.
[0713/] Running without renderer sandbox
[0713/] InitializeSandbox() called with multiple threads in process gpu-process
[0713/] Failed to establish GPU channel.
I will create a thread in forum Linux Editor
Thank you !

I think problem is here:
Initialize engine version: 2018.2.0f2 (10189b18f56e)
Forcing GfxDevice: Vulkan
[vulkan] LoadVulkanLibrary[vulkan] LoadVulkanLibrary failed to load detection: 0
[vulkan] LoadVulkanLibrary[vulkan] LoadVulkanLibrary failed to load detection: 0
GLX Extensions: GLX_ARB_create_context GLX_ARB_create_context_profile GLX_ARB_fbconfig_float GLX_ARB_framebuffer_sRGB GLX_ARB_get_proc_address GLX_ARB_multisample GLX_EXT_import_context GLX_EXT_visual_info GLX_EXT_visual_rating GLX_EXT_framebuffer_sRGB GLX_EXT_create_context_es2_profile GLX_MESA_copy_sub_buffer GLX_MESA_swap_control GLX_OML_swap_method GLX_OML_sync_control GLX_SGI_make_current_read GLX_SGI_swap_control GLX_SGI_video_sync GLX_SGIS_multisample GLX_SGIX_fbconfig GLX_SGIX_pbuffer GLX_SGIX_visual_select_group GLX_EXT_texture_from_pixmap GLX_INTEL_swap_event GLX_ARB_context_flush_control
Renderer: AMD Radeon (TM) RX 460 Graphics
Vendor: ATI Technologies Inc.
Version: 4.5.13529 Core Profile Context

What is “Unable to find name key matches ‘rıght'”? What is “rıght”? And this error doesn’t affect run the game. But spamming my console.

Can’t find the Addressables package in Package Manager and there seems to be no links to the preview builds anymore. How am I supposed to get the package?

Yes as long as you output to game screen and not cameras (it’s an option in the Recorder). We are working on a fix for the cameras.

This is a massive changelist and one to be proud of. Thanks for all the work put into it! ESC will change everything. I also like work put into smaller tools such as Recorder. How many days I spent figuring out how to properly capture footage from Unity. Now I don’t have to! Thanks!

I see it works with lightmaps too, but does it manage reflection probes too?

I’m a little confused, is ECS still in preview. Can we use ECS in our commercial releases/projects, or is it just to test out/learn and not recommended to use in final project releases.

I just installed unity2018.2 and found that the font in the editor is still too small to read on a 4k screen. Where can I set the font size for text in the editor?

There is no option inside Unity to increase the font size however Unity will adjust to Windows settings for your monitors.
This way you can scale up the font size and the whole Editor UI.

Instructions from Microsoft support page:

Windows 10

Select Display > Change the size of text, apps, and other items, and then adjust the slider for each monitor.

Earlier Windows systems

Right-click the application, select Properties, select the Compatibility tab, and then select the Disable display scaling on high DPI settings check box.

Thank you for your explanation.
I reset my scaling setting in Windows 10 and put it back to 150% and now Unity Editor looks good and I can finally read the text there again.

Great update! I love being able to remove built in modules in the package manager. Is there anywhere I can find out more info on what each module covers completely so I know if I’m safe to disable them?

Two examples:

* I don’t use the physics or physics2d system except for collider and collider2d components (and their respective raycasters). I assume this means I can’t disable those modules safely, but how would I know that?

* I don’t use videos anywhere but I use Unity Ads, do I need to keep the video module?

“Proxy Screen Space Reflection & Refraction”
Is there a paper, blog post or any sources that explain the details of the working?

Well there is nothing specifically about “Proxy Screen Space Reflection & Refraction” in these documents, and none talk about how it is implemented and the math and trick behind it. It’s hard to evaluate a new techniques without at least some paper talking about the math of how it operate! I don’t understand how it can be screen space and not use the depth pass at all.

Goddamnit, it’s another name for box projection cubemap, you could have said that, My head was spinning for a while :(

this is cool, but I wonder what about skinned mesh rendering component to be using in ECS and C# Job system?

Sir , actually I really happy and little bit disappointed with “no terrian” updates ! Please make new terrain feature like paint materials !

Any word on the state of the GPU lightmapper? I know it was mentioned as a 2018.2 feature, has it been pushed to 2018.3.x?

“In 2018.2, we added several improvements including Reactive system samples and arrays and strings.”
Where are these string helpers? I can’t find a “NativeString” in the Unity.Collections namespace. Am I missing smth?

The Entity Component System is focused on providing a new way of writing high performance code. It is up to you if you want to use it or not. We have no plan to deprecate MonoBehaviour / GameObject.

Hello, Joachim! Thank you for your answer!
It’s good to hear that MonoBehaviour/GameObjects are not going away. While ECS is a terrific thing, there are some cases, particularly, when developer has to rely on their old reusable code and their project is not bound by performance, it’s nice to have that old code supported by new Unity releases.

Hi Michael, thanks for your feedback. It seems these systems will be coming later. I will edit the blog post to rectify this information.

“Edit Sprite Mesh” in Anima 2D not work on 2018.2 – fix this please!

When are you planning a new prefab system? As far as I remember, it’s promised in 2018.2 version.


Can i find any infromation about how to upgrade full old project to the new HDRP?

Can you give us some details on why some nodes can and some can’t be used as vertex position input ?

I believe you are misreading, or they did not explain well enough. They did not “add Java support” as in, you can’t write Java code as well as C# code, you can simply include already made Java plugins that Android will end up utilizing. That is assuming that I am interpreting this correctly as well.

You’re going to be waiting a LOOOONG time. They just removed Javascript support, and have no intention to add Java support, like ever. Better for you to learn C#, or go somewhere else.

Maybe you could fix Unity’s crashes, hanging, bugs, and errors in your next release. All your “great” features don’t work without at least one engine crash – features that have been part of the engine for years. Every release makes it even more unstable. After working on Unity for 4 years, I’m moving on. I’d never recommend this engine if you want a relatively painless experience.

Sorry to hear you are having problems. Have you filed any bug reports for these issues you are having? What are the bug numbers?

Since 2017.3, we put in place a Release QA team dedicated to ensure the versions we are shipping are of good quality, on top of the QA teams working on testing each feature.

I recommend you take some time to reevaluate your PC setup. At one point I was having a lot of crashing and issue which ended up being caused by video drivers and pc configuration. It has been a year and I work within unity 7-10 hours a day since I have had a single issue.

The new features are great specially shader graph, new asset store, unity hub and the package manger.

Do you have any news on the status LWRP and HDRP for VR? We currently have a project that builds across various VR (and now even AR) platforms – from high-end gaming PCs down to iPhone 6s and Samsung Galaxy S8, and many of the things coming with 2018.2 look like they would be extremely useful for us. Switching to SRP (and ECS / Jobs System ;-) )will probably be quite a bit of porting but might be worth it. But obviously only if VR really works with it ;-)

LWRP works in 2018.2 for mobile VR platforms but it’s missing MSAA which is coming in 2018.3. HDRP support for VR will be 2019 once we have all the kinks worked out.

A little frustrated with this “Additive scene lighting warnings”. Judging by this inclusion it appears as though there is no current solution and a solution is not planned for using baked probes from multiple scenes which is what I know a few devs were hoping for to help with procedural level generation. There was a bug raised for this but it was closed by Unity so perhaps the stance on this is that it is intended functionality?

I agree. Additive level loading without light probes gives me exactly half of the lighting I need in order to render objects in a scene.

I’ve had to tiptoe around this for years and make complex proxy art and duplicate lighting scenerios to sidestep this critical limitation. It’s ugly and limiting and giving day one warnings doesn’t solve the problem.

New updates are neat, but I still wait for the day I see improvements to this system.

We are actively working on removing the limitations on Additive Loading, especially light probes.

Congratulations on a new release!
With all the focus on Entity Component System, should we worry that the current development approach using GameObjects and MonoBehaviours will become obsolete and will be deprecated at some point?

We are not planning any deprecation of these any time soon. We will maintain what’s there with GameObjects and MonoBehaviours.

Good stuff, though much still in preview!
Planar Reflections? Do you have a link to info on this? Much needed

Planar reflections are for the High Definition Render Pipeline.
If you grab the latest version of it through the Package Manager, you will be able to add a “Planar Reflection Probe” to your scene (GameObject / Light / Planar Reflection Probe). Basically, this object is set like a reflection probe and will influence all surfaces within it’s bounds, but will do reflection according it’s relative horizontal plane.
Note that you have an example setup if you add a “Mirror” object (GameObject / 3D Object / Mirror), which is a combination of a fully reflective plane + a planar reflection probe.

Ah I see, any chance of some reduced quality version for the LWRP in future?
We still want to show some mirror effect on mobile

Comments are closed.