# URP Blit Render Feature: a more flexible fullscreen pass for Unity 6 > URP Blit Render Feature is a small Unity package that adds a Blit option to the renderer feature list in a Universal Renderer asset, letting you apply a fullscreen shader to the camera or copy it to an offscreen buffer with more control than the built-in Fullscreen Pass. It is built for Unity 6.3 LTS and its trade-offs are documented, including what was removed compared to older versions. **Cyanilux/URP_BlitRenderFeature** — Blit Render Feature for Universal RP. Bit more flexible than the provided Fullscreen Pass Renderer Feature. - Repository: https://github.com/Cyanilux/URP_BlitRenderFeature - Stars: 698 · Forks: 79 - Language: C# - License: MIT - Published: 2026-10-21 · Updated: 2026-10-21 · Language: en - Canonical page: https://hysenlabs.com/projects/cyanilux-urp-blitrenderfeature ## A renderer feature that blits the camera through your own material URP Blit Render Feature is described as a Blit Render Feature for Universal RP that is a bit more flexible than the provided Fullscreen Pass Renderer Feature. The package description in the manifest is plainer: it adds a Blit option to the Render Features list on the Forward and Universal Renderer asset. That last point is where it lives in the editor. Rather than being a separate pass you add to a list of post effects, the Blit appears among the renderer features on the renderer asset itself, next to the features Unity provides. The primary use is applying a fullscreen image effect to the camera with a shader or material, or copying the camera into an offscreen buffer, and the comparison the README draws is with the Fullscreen Pass Renderer Feature. The source of the blit is fixed and the README says so in one line: the source texture is always cameraColor. That is the invariant, and everything else in the feature is about what you do with the result and when in the frame you do it. The implementation is a single C# file, Blit.cs, with an Attribute/ directory beside it, and the whole thing is declared as a Unity assembly with a .asmdef named Cyanilux.BlitRenderFeature.asmdef. The package manifest is minimal, with the name com.cyanilux.urp-blitrenderfeature, the display name URP Blit Render Feature, the author Cyanilux and a single keyword of URP. The package is MIT licensed and the last push was on 2026-07-17, with the repository not archived. There are no GitHub releases, and the version in the manifest is 6.3.0, which tracks the Unity version rather than a release history. ## Sampling the source from a graph or from shader code Once you have a material on the feature, the question is how the shader reads the pixels that are being blitted, and the README answers it in two ways depending on whether you use a shader graph or a shader file. For graphs, the material must use the Fullscreen Graph type, and you use the URP Sample Buffer node to obtain the Blit Source. The requirement on the graph type is not a detail, because a graph set up any other way does not produce the expected input. For shader code, a specific vertex shader is required, and the source is sampled from _BlitTexture. The README points at the author's own FAQ page for the fullscreen shader, noting that the FragBlit example there samples _BlitTexture for you, which is a convenient way to see a working pair of shaders rather than to work out the vertex stage from scratch. So the two routes are a graph that pulls the Blit Source out of a URP Sample Buffer node, or a shader that samples _BlitTexture and is paired with the expected vertex shader. One of the two most useful cross references is the Unity Render Graph documentation, and the other is the URP Render Graph samples in the Unity Graphics repository, which is where you can see what a custom pass is expected to look like when the frame is described as a graph rather than as a list of commands. The Blit feature in this package predates the current Unity 6 documentation link, so reading both is worthwhile. ## The pass event matters, and the After Rendering event does not work The README carries a short note that saves an afternoon of debugging: the After Rendering event does not work, and you should use After Rendering Post Processing instead. In a Universal Render Pipeline renderer feature, the injection point determines what the pass sees. An event that fires too early gets a frame that has not been composed yet, and an event that fires at the wrong point in post processing sees a different image than the one the shader author expected. The blit of the camera colour is sensitive to exactly that. The README also documents several behaviours that differ from the stock Fullscreen Pass, and these are the details that decide whether the feature fits your pipeline. Compared to older versions of this package, support for passing a global texture or a RenderTexture asset in as the source has been removed. The details are in the code comments, and the workaround is that if you need that behaviour you can still sample it in a custom material or shader instead of using the Blit Source or _BlitTexture. The README also explains a related Render Graph subtlety: if you are sampling global textures, you can use the list on the feature to declare and import them so that textures generated by other render passes stay alive. Setting the _InverseView matrix has also been removed. The README's justification is that the matrices are not overridden with the Blitter API anyway, and that a Fullscreen Graph reconstructs world positions for you when you use its Position node. That is the honest shape of the package. It is more flexible than the stock pass in the ways that matter for a custom effect, and it has given up a couple of things it used to do. ## One branch per Unity version, and the current one targets 6.3 LTS The compatibility story is handled with branches rather than with version ranges, and the README is explicit about it. The package was tested with Unity 6.3 LTS, at version 6000.3.6f1. It may work in earlier Unity 6 versions, but that is untested, and for even older versions you are pointed at the branches. The default branch of the repository is 6.3, which matches that, so cloning the default branch gives you the version for the current LTS. The earlier branches exist for the older editor versions, and the package version in the manifest tracks the same numbering, so a branch called 6.2 would carry a manifest version of 6.2.x. That is a workable scheme as long as you remember to switch branch when you change Unity version. The manifest also tells you where the feature attaches itself, in the description that says it adds the Blit option to the Render Features list on the Forward and Universal Renderer asset. Both the Forward renderer and the Universal renderer are covered, which matters if your project is on the older forward path rather than the deferred one. The repository is small in a way that makes it easy to read. Beyond Blit.cs there is the Attribute/ directory, the assembly definition and its meta file, the package manifest with its meta file, the licence, and the README. The.meta files are checked in, which is correct for a package meant to be dropped into a project. The whole feature is therefore a small amount of C#, and that is a reasonable thing to read before you depend on it. ## Installation is a git URL in the package manager There are two installation routes and both are simple. The first is the Package Manager, using Add package via git URL with this address: ``` https://github.com/Cyanilux/URP_BlitRenderFeature.git ``` Adding a package this way means the Package Manager tracks the repository as a git dependency, so the feature appears in the project window like any other package and can be updated from there. The alternative is to download the repository and put the folder in your Assets. That is the route to take if your project does not use the Package Manager for its dependencies, or if you intend to modify the feature, since a package under Packages is managed for you while a folder under Assets is yours to change. The manifest shows the package name, com.cyanilux.urp-blitrenderfeature, and the display name the user sees in the Package Manager window, URP Blit Render Feature. For learning how a renderer feature like this is put together, the README links a tutorial on custom renderer features, the Unity Render Graph samples, and the Render Graph documentation. The samples in particular are the fastest way to understand what the feature is doing at the frame level, because they show the same kind of pass written in the graph form the feature expects. ## Conclusion URP Blit Render Feature is worth adding if you are writing custom fullscreen effects in URP and have outgrown the Fullscreen Pass Renderer Feature, since the Blit option gives you a material, a render pass event and a documented sampling workflow, and the README tells you exactly how to sample from it in a shader graph or in code. It is the wrong tool if you only need the stock fullscreen pass, since that ships with Unity. Before you upgrade a project that already uses the older versions of this package, verify three things yourself: that the source is still always the camera colour, because that is the one invariant the README states, that you are using the After Rendering Post Processing event rather than After Rendering, since the earlier one does not work, and that you have not depended on passing a global texture or a RenderTexture asset as the source, because that support was removed and the replacement path is different. ## FAQ ### What does the URP Blit Render Feature do? It adds a Blit option to the Render Features list on the Forward and Universal Renderer asset, so you can apply a fullscreen image effect to the camera using a shader or material, or copy the camera to an offscreen buffer. The README describes it as a little more flexible than the provided Fullscreen Pass Renderer Feature. ### Which Unity version does the URP Blit Render Feature support? It was tested with Unity 6.3 LTS at version 6000.3.6f1, and the default branch of the repository is 6.3. It may work in earlier Unity 6 versions but that is untested, and older versions live on separate branches of the repository. ### How do I sample the blit source in a shader? For a shader graph you must use the Fullscreen Graph type and get the Blit Source from the URP Sample Buffer node. For shader code a specific vertex shader is required and you sample _BlitTexture for the source, with the author's FAQ page linking to a FragBlit example that does this for you. ### Which render pass event should I use for the blit? The README states that the After Rendering event does not work and that you should use After Rendering Post Processing instead. It also notes that the source texture is always cameraColor. ### How do I install the URP Blit Render Feature? Use the Package Manager with Add package via git URL and the repository address https://github.com/Cyanilux/URP_BlitRenderFeature.git, or download the repository and put the folder in your Assets. The package is MIT licensed with no GitHub releases published. ## Sources - [Cyanilux/URP_BlitRenderFeature on GitHub](https://github.com/Cyanilux/URP_BlitRenderFeature) - [Issues](https://github.com/Cyanilux/URP_BlitRenderFeature/issues) - [License: MIT](https://github.com/Cyanilux/URP_BlitRenderFeature/blob/6.3/LICENSE) - [README](https://github.com/Cyanilux/URP_BlitRenderFeature/blob/6.3/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/cyanilux-urp-blitrenderfeature