How to move your Built-in Render Pipeline project to the Universal Render Pipeline (URP)

The Universal Render Pipeline (URP) is the default render pipeline in Unity 6. In this guide, we’ll explain why we're making URP default, cover this Scriptable Render Pipeline (SRP)'s key features and benefits, share examples of studios who moved their projects to URP, and explain step by step how you can do the same with yours.

For a deeper dive on URP, check out the full e-book, Introduction to the URP for advanced creators – newly updated for Unity 6.

Evolution of rendering: From Built-in Render Pipeline to Scriptable Render Pipelines

Platform reach is one of Unity’s biggest strengths. The ideal for almost all game studios is to create a game once and efficiently deploy it to whatever range of platforms they choose, from high-end PCs to low-end mobile.

The Built-in Render Pipeline was developed to be a turnkey solution for all platforms supported by Unity. It offers a mix of graphics features and is convenient to use with Forward and Deferred render paths.

However, as Unity continues to add support for more platforms, we have perceived the following limitations in the Built-in Render Pipeline:

• The bulk of the code is written in C++ and can’t be modified, making it a blackbox system.
• The render flow and render passes are prestructured.
• The rendering algorithm is hardcoded.
• Unconstrained customization makes achieving good performance on all platforms difficult.
• It exposes callbacks in the rendering code that trigger sync points in the pipeline. Those callbacks prevent multithreaded rendering optimizations, enabling changes for injection of state at any point in the frame dynamically by calling to C#.
• It’s difficult to cache data to manage the persistence state for user injection.

The solution: Scriptable Render Pipelines

Both the High-Definition Render Pipeline (HDRP) and URP are Scriptable Render Pipelines (SRPs). Unity's SRPs were developed to support an efficient multiplatform workflow by providing:

• Intelligent and reliable scaling for the maximum number of hardware platforms, from high- to low-end devices
• The ability to customize rendering processes using C#, not C++, which means a new executable does not need to be compiled for every change
• Flexibility to support architecture evolution
• Capacity to create sharp graphics that are performant across many platforms

The image below illustrates how the SRPs work. They use C# to control and customize render passes and rendering control, as well as HLSL shaders that can be created using artist-friendly tools such as Shader Graph. Shaders give you access to even the lower-level API and engine-layer abstractions.

An advanced developer can create a new SRP from scratch or modify the URP or HDRP. The graphics stack is open source and available for use on GitHub.

While both SRPs offer unique advantages, URP is designed for maximum platform reach so you can bring great-looking graphics anywhere. Let’s take a closer look.

6 reasons to move your Unity project to URP

1. URP is accessible to a wide range of skill levels.
   
   URP is configurable by artists and technical artists alike, providing more flexibility for prototyping and refining rendering techniques for full game production.
   
   
2. URP is extensible and customizable.
   
   URP allows you to modify existing capabilities and extend the pipeline with new ones, making it a solid choice for advanced users, including Asset Store and third-party package creators, experienced developers, and professional teams.
   
   While the low-level rendering API is written in C++ for performance purposes, a URP developer can write a simple C# script to be called during the render pipeline, enabling high-level customization without sacrificing performance.
   
   
3. URP offers multiple rendering options.
   
   URP provides a Universal Renderer that supports Forward, Forward+, and Deferred rendering paths, as well as a 2D Renderer.
   
   You can extend these renderers with additional features and Scriptable Render Passes.
   
   The Render Objects feature can be used to render objects from a given Layer Mask at different events in the rendering pipeline. It also allows you to override material and other render states when rendering those objects, making it possible to customize the rendering without code.
   
   URP can be extended with custom renderers to suit specific needs. Teams on Unity 6 now have access to Render Graph, a tool that enables you to access and manipulate the various buffers used to render a frame, and using the renderer features workflow means this can be added at any stage in the render pipeline..
   
   
4. URP enhances 2D game development.
   
   URP provides optimized performance and flexibility, making it ideal for both mobile and high-end platforms. It supports advanced lighting, shadows, and post-processing effects, enhancing the visual quality of 2D games without compromising on performance.
   
   Additionally, URP’s customizable render settings and shader capabilities allow you to fine-tune the appearance of your games for a polished and professional look. This makes URP a valuable tool for creating visually appealing, smooth-running 2D games.
   
   
5. URP is compatible with key artist tools.
   
   URP supports artist- and technical artist-friendly tools, such as Shader Graph, VFX Graph, and the Rendering Debugger.
   
   
6. You can get even better performance with URP.
   
   URP is built with performance in mind, and has many tools to strike a balance between fidelity and frame rate on a wide range of devices.
   
   • URP evaluates real-time lighting very efficiently. In Forward rendering, it evaluates all lighting in a single pass. Forward+ improves upon standard Forward rendering by culling lights spatially rather than per object. This increases the overall number of lights that can be used to render a frame. In Deferred rendering, it supports the Native RenderPass API, allowing G-buffer and lighting passes to be combined into a single render pass.
   
   • URP makes more efficient use of tile memory on mobile devices, leading to less power consumption, a longer battery life, and, therefore, the possibility of longer play sessions.
   
   • URP comes with an integrated post-processing stack that allows for better performance compared to the Built-in Render Pipeline. Using the Volume framework, you can create post-processing effects that are dependent on camera position without writing any code.
   
   • Unity 6 introduces a variety of URP updates, including CPU and GPU improvements when drawing meshes; the SRP Batcher, which ensures fewer draw calls and improvements on how depth is handled; and the GPU Resident Drawer and GPU Occlusion Culling, which can significantly reduce the draw calls for some scenes.
   
   While most Unity projects are now being built on URP or HDRP, the Built-in Render Pipeline remains available in Unity 6.

3 studios who moved their Built-in Render Pipeline projects to URP

Kluge Interactive – Synth Riders

Kluge Interactive launched their immersive rhythm game Synth Riders on Steam VR and Meta Quest in 2019. Since then, it’s been ported to numerous devices, including the Apple Vision Pro. Keeping up with the latest technology has been essential to help the studio reach more and more players on VR platforms.

“The last 12 to 18 months of game development has been about paying down technical debt and moving our toolsets closer to the 2022 LTS,” explains AnnMarie Wirrel Bartholomaeus, a technical producer at Kluge Interactive. “We already moved from the Built-in Render Pipeline to the Universal Render Pipeline (URP) and switched to an OpenXR backend. That has helped put us in a much better technical position to work with new technologies.”

Subcult Joint – Cookie Cutter

Subcult Joint’s Cookie Cutter is a high-octane, beat-em-up Metroidvania available on PC and consoles. All of the game’s assets are hand-drawn and animated using traditional techniques. To add depth to these stunning characters and environments, Subcult Joint needed the perfect lighting setup – one that could be optimized and remain performant across platforms.

By switching to URP and upgrading the project to the latest Unity version, Subcult Joint unlocked Cookie Cutter’s full potential. They added over 10,000 2D Lights and optimized them using the updated Memory Profiler. And the latest version of Sprite Atlases enabled them to push hundreds of hand-drawn animations to different target platforms more easily and more efficiently.

“Every light in the game illuminates our Sprites in real-time, creating a feeling of density and cohesion between characters, animations, and the environments,” says Subcult Joint founder Stefano Guglielmana. “In dark places, characters are shaded, and bathed in light when they’re exposed to the saturated, contaminated skylights in exterior areas. I love these details so much!”

more8bit – Bleak Sword DX

Solo developer Luis Moreno Jimenez, also known as more8bit, originally launched his 8-bit Soulslike Bleak Sword on Apple Arcade in 2019. Following the game’s success, publishers Devolver Digital suggested more8bit bring the game to PC and consoles to reach even more players. more8bit took the opportunity to expand on Bleak Sword’s original concept, rather than recreating a carbon copy of the mobile version.

Bleak Sword DX’s visuals evoke retro arcade cabinet games. Post-processing effects include light bloom with a dirty texture, screen curvature, VHS-like filters, depth of field effects, and more. For Luis, the biggest challenge was retaining Bleak Sword’s visual flavor but enhancing DX’s graphics to take advantage of extra processing power. He created most of the VFX using Unity’s Built-in Render Pipeline and Shader Graph before optimizing in URP.

“The pass from Built-in to URP was really smooth. It only took me a weekend, and then a week to fix small issues,” says more8bit.

How to add URP to an existing Built-in Render Pipeline project

In this section, we’ll show you how to convert an existing project that uses the Built-in Render Pipeline to URP.

Important: Be sure to back up your project using source control before following the steps in this section. This process will convert assets, and Unity does not provide an undo option. If you use source control, you will be able to revert to previous versions of the assets if necessary.

If you’re upgrading an existing Built-in Render Pipeline project but aren't on Unity 6 yet, you’ll need to start by adding the URP package to your project (as previously mentioned, URP is the default renderer in Unity 6).

Go to Window > Package Manager, and click the Packages drop-down to add URP to your project. Make sure to select the Unity Registry, followed by Universal RP. Click Download in the lower-right corner of the window if the URP package is not yet installed on your development computer. Then click Install once it’s downloaded.

To create a URP Asset, right-click in the Project window and choose Create > Rendering > URP Asset (with Universal Renderer). Name the asset.

Remember: If you create a new project using the Universal Render Pipeline or 3D (URP) templates, these URP Assets are already available in the project. Rather than creating a single URP Asset, URP uses two files, each with an Asset extension.

One is called UniversalRP_Renderer, a Renderer Data Asset that you can use to filter the layers the renderer works on and intercept the rendering pipeline to customize how the scene is rendered. This way, you can facilitate the creation of high-quality effects.

Additionally, the UniversalRP_Renderer controls high-level rendering logic and passes for URP. It supports Forward and Deferred paths, as well as a 2D Renderer that enables features such as 2D Lights, 2D Shadows, and Light Blend Styles. You can even extend URP to create your own renderers.

The other URP Asset serves to control settings for Quality, Lighting, Shadows, and Post-processing. You can use different URP Assets to control the quality settings.

This Settings Asset is linked to the Renderer Data Asset via the Renderer List. When you create a new URP Asset, the Settings Asset will have a Renderer List containing a single item – the Renderer Data Asset created at the same time, set as the default. You can add alternative Renderer Data Assets to this list.

The default renderer is used for all cameras, including the scene view. A camera can override the default renderer by selecting another one from the Renderer List. This can be done using a script, as needed.

Despite following these steps to create a URP Asset, an open scene in the Scene or Game view will still use the Built-in Render Pipeline. You must complete one last step to make the switch to URP: Go to Edit > Project Settings, and open the Graphics panel. Click the small dot next to None (Render Pipeline Asset). In the open panel, select UniversalRP.

A warning message will pop up regarding the switch, but you can just press Continue. Since there is no content in your project yet, changing the render pipeline will be almost instantaneous. You’re now ready to use URP.

Converting the scenes of an existing project

After you complete the steps above, you’ll find that your beautiful scenes are suddenly colored magenta. This is because the shaders used by the materials in a Built-in Render Pipeline project are not supported in URP. Fortunately, there's a method for restoring your scenes to their original quality.

Go to Window > Rendering > Render Pipeline Converter. Choose Convert Built-in to 2D (URP) for a 2D project, or Built-in to URP for a 3D project. Assuming that your project is 3D, you’ll need to select the appropriate converters:

• Rendering Settings: Select this to create multiple Render Pipeline setting assets that will match Built-in Render Pipeline Quality settings as closely as possible. This lets you test different Quality Levels more efficiently.
• Material Upgrade: Use this to convert materials from the Built-in Render Pipeline to URP.
• Animation Clip Converter: This converts animation clips. It runs once the Material Upgrade converter finishes.
• Read-only Material Converter: This converts the prebuilt, read-only Materials included in a Unity project. It indexes the project and creates the temporary .index file. Note that it can take significant time.

Converting custom shaders

Custom shaders are not converted using the Material Upgrade converter. Using Shader Graph is often the quickest way to update a custom shader to URP.

There are several different URP shaders including:

• Universal Render Pipeline/Lit: This physically based render (PBR) shader, similar to the Built-in Standard Shader, can be used to represent most real-life materials. It supports all the Standard Shader features with both metallic and specular workflows.
• Universal Render Pipeline/Simple Lit: This uses a Blinn-Phong model and is suitable for low-end mobile devices or games that don’t use PBR workflows.
• Universal Render Pipeline/Baked Lit: Use this Shader for stylized games or apps that only require baked lighting via lightmaps, light probes, and Unity 6’s Adaptive Probe Volumes (APVs). This shader does not use Physically Based Shading and has no real-time lighting, so all real-time relevant shader keywords and variants are stripped from the Shader code, which makes it faster to calculate.
• Universal Render Pipeline/Complex Lit: The Complex Lit Shader contains all the functionality of the Lit Shader and adds advanced material features. Some features in this shader might be considerably more resource-intensive and require Unity Shader Model 4.5 hardware.
• Universal Render Pipeline/Unlit: This is a GPU-performant shader that doesn’t use lighting equations.
• Universal Render Pipeline/Terrain/Lit: This is suitable to use with the Terrain Tools package.
• Universal Render Pipeline/Particles/Lit: This particle shader uses a PBR lighting model.
• Universal Render Pipeline/Particles/Unlit: This unlit particle shader is light on the GPU.

Although Simple Lit replaces many legacy or mobile shaders, the performance is not the same. Legacy/mobile shaders only partially evaluate lighting, whereas Simple Lit considers all lights as defined by the URP Asset.

Refer to this table in our URP documentation to see how each URP shader maps to its Built-in Render Pipeline equivalent.

Once you select one or more of the above converters, either click Initialize Converters or Initialize And Convert. Whichever option you choose, the project will be scanned, and those assets that need converting will be added to each of the converter panels.

If you choose Initialize Converters, you can limit the conversions by deselecting the items using the checkbox provided for each one. At this stage, click Convert Assets to start the conversion process.

If you choose Initialize And Convert, the conversion starts automatically after the converters are initialized. Once it’s complete, you might be asked to reopen the scene that is active in the Editor.

Get the full e-book

Get the most out of URP with our comprehensive, 189-page guide, Introduction to the Universal Render Pipeline for advanced Unity creators, now expanded and updated for Unity 6. Written by Unity expert Nik Lever, this manual covers best practices for creating scalable graphics in Unity as efficiently as possible.

Download the e-book to learn how to:

• Work with URP Quality settings.

• Use all lighting tools available in URP, including new features like Adaptive Probe Volumes (APVs) for real-time global illumination and lighting scenarios that blend between day and night lighting.

• Use URP shaders for lit scenes and understand the differences between URP and Built-In Render Pipeline shaders.

• Use custom shaders, includes and HLSL includes.

• Use the URP post-processing framework, including adding a Local Volume and controlling post-processing with code Use Rendering layers.

• Apply many kinds of performance optimizations with tools in URP, including the newly-released GPU Resident Drawer, GPU occlusion culling, and more.

• Customize the render pipeline using Renderer Features and the render graph system.

Expanded possibilities with Unity 6

Unity 6 is all about putting fast, easy game creation directly in your hands, no matter where your players are.