No release yet. The package works, but it is still in development and has not been released, so please do not ship it in production. A release is planned.
Contributions are very welcome in the meantime. This is meant to be a fully open, community-maintained package, and that is exactly how it is being built.
A collection of graphics features that Unity does not give you: native features unlocked through a single plugin, plus helpers and utilities that are simply useful when you write rendering and compute code.
Most of the native ones already exist in the graphics APIs (Vulkan, D3D12, Metal) and only lack a Unity-side surface. This package adapts them into APIs that feel like they were always part of the engine, and every feature reports what it can actually do on the current device, so shipping cross-platform code is one comparison instead of a maze of platform defines.
Each feature has its own page with the full API, per-backend implementation details and limitations.
Ask what the device can do instead of guessing from the platform. Every
feature registers an ordered support tier (Unsupported, Emulated,
Partial, Native), so one comparison covers both native paths and
fallbacks.
if (FeatureRegistry.GetTier(FeatureId.MultiDrawIndirect) >= FeatureTier.Emulated)
{
// Native here, or a correct fallback. Either way it works.
}
Debug.Log(FeatureRegistry.DumpReport()); // one-paste device report for bug reportsThousands of indirect draws in one command instead of a loop of draw calls.
D3D12 ExecuteIndirect, Vulkan vkCmdDrawIndexedIndirect, OpenGL
glMultiDrawElementsIndirect, Metal, D3D11 through NvAPI.
cmd.MultiDrawMeshIndirect(
mesh: mesh,
material: material,
properties: propertyBlock,
shaderPass: 0,
bufferWithArgs: argsBuffer, // GraphicsBuffer.IndirectDrawIndexedArgs[]
argsStartIndex: 0,
argsCount: 25_000 // 25k draws, one command
);Supported on every backend, with a native loop where the hardware path is missing.
Register a texture once, then sample it anywhere by integer index. No material slots, no per-draw binding, so the index can vary per pixel or per instance.
uint slot = Bindless.Register(texture); // stable slot in the global heap
propertyBlock.SetInt("_AlbedoSlot", (int)slot);half4 albedo = BINDLESS_SAMPLE(_AlbedoSlot, uv);Vulkan. Devices without descriptor indexing run a paged mode with fixed descriptor tables.
Raw GPU addresses for ordinary GraphicsBuffers, so shaders can follow
pointers instead of binding everything up front. Linked structures, sparse
data, per-draw payloads without descriptors.
ulong address = buffer.GetBufferAddress();
// Shaders take addresses packed as uint2 (x = low, y = high).
var packed = new Vector2Int((int)(address & 0xFFFFFFFF), (int)(address >> 32));float4 value = UGE_BufferLoadAt_float4(_DataAddr, index);Vulkan today, D3D12 planned. The shader side is uint2-based and never needs 64-bit shader ints, which keeps it working on almost all Android devices.
Quality-of-life layer for compute work: typed buffers with GPU-side resize and removal, kernels dispatched by thread count instead of group count, and an ambient command buffer that turns immediate calls into recorded ones.
var particles = new GPUBuffer<Particle>(GraphicsBuffer.Target.Structured, 1024);
var shader = new GPUComputeShader(myComputeShader);
var kernel = shader.FindKernel("Simulate");
kernel.SetBuffer("_Particles", particles);
kernel.Dispatch(particles.Count); // thread count, not group countPure C# and compute shaders, so it works on every backend Unity supports.
printf from inside a shader, straight into the Unity console. Works in
any stage, with call-site rate limiting so a per-pixel print cannot flood
the editor.
UGE_PRINTF2("pos = %v3f, index = %u", worldPos, index);Native on Vulkan (the plugin consumes the printf instructions itself, no validation layers). Everywhere else the same macros run as an emulation over a bound buffer and an async readback, so it works on every backend.
Real GPU time for any region of a command buffer, delivered to a callback a few frames later. No profiler, no development build.
cmd.BeginGpuTimer("Culling", OnTimeReport);
cmd.DispatchCompute(cullShader, kernel, groups, 1, 1);
cmd.EndGpuTimer();
void OnTimeReport(GpuTimerReport report)
{
if (report.IsValid)
Debug.Log(report); // "Culling: 0.412 ms (avg 0.398, min 0.361, max 1.204, n=241)"
}Vulkan timestamps today, D3D12 query heaps planned. Elsewhere the calls are safe no-ops.
A per-pixel map of GPU cost drawn over your scene. Every fragment shader is instrumented automatically, so expensive materials, heavy branches and overdraw light up without touching a single shader.
// URP: add the ShaderHeatmap renderer feature and tick it. By hand:
ShaderHeatmap.Enabled = true;
ShaderHeatmap.RenderOverlay(cmd);Vulkan desktop only, since it rides on VK_KHR_shader_clock. Functional
but still rough, see the note on its page.
Matrix multiplication on the GPU's tensor cores, from C#, with no shader work. Useful for anything batched and linear: neural inference in the frame, learned texture decompression, blend shapes, spherical harmonics, subspace physics.
// result[rows x columns] = left[rows x innerSize] * right[innerSize x columns]
CoopMatrix.MatMul(left, right, result, rows, columns, innerSize);Native through VK_KHR_cooperative_matrix on NVIDIA Turing+, AMD RDNA3+
and Intel Arc. Everywhere else the same call runs a tiled compute fallback.
Requires Unity 6000.0+. In Package Manager choose Install package from git URL and add:
https://github.com/unity-graphics-extensions/unity-graphics-extensions.git
An OpenUPM listing is planned once the first native feature lands.
Contributions are very welcome. This project exists so these capabilities stop being one person's private plugins. See CONTRIBUTING.md for what is most useful, in particular emulating features on platforms that do not support them natively.
The easiest first contribution: run
Tools > Graphics Extensions > Log Capability Report on your device and
attach the output to a device-report issue.
MIT. Created and maintained by Denis Zhukov (@saivs) and contributors.