Your Unreal scene. Your point clouds. Brought together.

Unreal Engine is already the gold standard for real-time visuals. Unlimited Detail removes the ceiling on what you can put inside it. Full-resolution lidar data, any size, no decimation with your Lumen, Nanite, and material budgets untouched.

Quickstart GitHub

Real-world scan data doesn't fit neatly inside a triangle budget. Unreal's native point cloud support decimates your dataset to hit that budget - detail disappears, and the bigger the capture, the worse it gets. Drop in the Unlimited Detail plugin and your UE5.7 scene renders the complete, uncompromised dataset on CPU, leaving your Lumen, Nanite, and material budget entirely intact.

Overview

A native plugin. Not a workaround.

Unreal gives you the best real-time renderer in the industry. What it can't do natively is render a trillion-point lidar scan without throwing most of it away. The Unlimited Detail plugin fills that gap: drop it into your project, rebuild, and add the new UUDComponent to any Actor, point its URL property at a .uds file, and the complete, full-resolution point cloud appears in the editor viewport and in PIE - depth-correct against your terrain, meshes, and sky - without touching your GPU render budget.

Quickstart

Up and running in four steps

Copy the plugin into your project's `Plugins/` folder, regenerate Visual Studio project files (right-click the `.uproject`), rebuild in Visual Studio, then open the project. Set your credentials in **Project Settings → Plugins → Unlimited Detail (udSDK)**. Add a `UUDComponent` to any Actor and set its `Url` property. That's it - the point cloud renders in the editor viewport immediately, and PIE works without extra setup. The plugin copies `udSDK.dll` to `Binaries/Win64/` automatically at build time. The snippets below show the project layout after install, the generated config entry, and the C++ / Blueprint surface area.

// 1. Plugin install layout
MyProject/
└── Plugins/
    └── UnlimitedDetail/      ← paste the plugin folder here
        ├── UnlimitedDetail.uplugin
        └── Source/

// 2. Credentials - set via Project Settings UI or edit directly:
// Config/DefaultUnlimitedDetail.ini
[/Script/UnlimitedDetail.UUDSettings]
ServerPath=https://udcloud.nuclideon.com/
APIKey=your-api-key-here

// 3. Add a point cloud to any Actor (C++)
UUDComponent* PC = NewObject<UUDComponent>(MyActor);
PC->SetUrl(TEXT("https://my-bucket.example.com/site.uds"));
PC->RegisterComponent();

// 4. Check that the SDK session is live (C++ or Blueprint)
UUDSubsystem* UD = GEngine->GetEngineSubsystem<UUDSubsystem>();
if (UD && UD->HasSession())
{
    // Connected - point clouds are rendering
}

The plugin requires a C++ UE project. If your project is Blueprint-only, add an empty C++ class first (Tools → New C++ Class) so Unreal generates the necessary build infrastructure before installing the plugin.

What you get

What the plugin does for you

The hard parts of integrating a CPU renderer into UE's render pipeline - handled.

Blueprint-spawnable component

Add `UUDComponent` to any Actor from the component picker. No C++ required for basic use. Set `Url` in the Details panel or at runtime with `SetUrl()`.

Depth-correct compositing

Point clouds interleave with UE meshes, terrain, and sky via a shared depth buffer. Not a flat overlay - a building correctly occludes a point cloud behind it, and a point cloud correctly occludes geometry behind it.

Doesn't compete with your render budget

udSDK renders on CPU. Point cloud rendering runs independently of Lumen, Nanite, and your material graph - adding a billion-point scan to your scene doesn't cost you a frame on anything else.

Editor viewport support

Point clouds are visible in the editor viewport, not just in PIE. `RefreshPointCloud()` is callable from the Details panel to force a reload without restarting the editor.

Automatic binary management

`udSDK.dll` is copied to your project's `Binaries/Win64/` folder automatically at build time. Packaging picks it up without any manual staging step.

Project Settings integration

Server URL and API key live in **Project Settings → Plugins → Unlimited Detail (udSDK)**. Stored in `DefaultUnlimitedDetail.ini` - no hard-coded credentials, no `.env` files. Supports per-platform config overrides.

Requirements

What you need before you start

Unreal Engine 5.7

The plugin targets UE5.7 specifically. It uses rendering APIs introduced in UE5.5+ (FSceneViewExtensionBase, RHICreateTexture, internal renderer headers that moved in UE5.5). It is not compatible with earlier 5.x releases without modification.

A C++ UE project

The plugin is a C++ module and must be compiled against your project. Blueprint-only projects need at least one C++ class added so Unreal generates the build files. The plugin itself is fully Blueprint-accessible once compiled.

Windows 64-bit

The current release ships a Win64 binary. A Linux build (glibc 2.38+, Ubuntu 23.10 or later) is included and can be enabled - see the platform limitations below. macOS support is pending a usable library from the SDK vendor.

A udCloud account and API key

Sign in or create an account at udcloud.nuclideon.com to obtain an API key. Domain licenses are available for enterprise deployments - contact us to arrange one.

API Reference

Component, subsystem, and settings

The plugin surface area is intentionally small. Most use cases need only UUDComponent and the Project Settings panel.

UUDComponent

A `UPrimitiveComponent` subclass. Blueprint-spawnable (`meta = (BlueprintSpawnableComponent)`). **`Url`** - path or URL to a `.uds` file; editable in the Details panel. **`SetUrl(FString)`** - BlueprintSetter; changes the URL and triggers an immediate unload/reload. **`RefreshPointCloud()`** - BlueprintCallable and CallInEditor; forces a reload of the current URL without changing it, useful when the source file changes on disk during development.

// Add to an Actor at runtime (C++)
UUDComponent* PC = NewObject<UUDComponent>(this);
PC->SetUrl(TEXT("https://my-bucket.example.com/scan.uds"));
PC->RegisterComponent();

// Change the model at runtime
PC->SetUrl(TEXT("https://my-bucket.example.com/updated.uds"));

// Force reload without changing URL (also available in Details panel)
PC->RefreshPointCloud();

UUDSubsystem

An `UEngineSubsystem` - one instance for the lifetime of the engine. Manages the udSDK session, render context, and GPU textures. Initialised at engine startup (PostConfigInit). **`HasSession()`** - BlueprintCallable; returns true when the subsystem holds a live udCloud session. Point clouds will not render if this is false. Check it in your game logic before assuming anything is visible - the session can be absent if credentials are missing or the server is unreachable.

// C++ - access the subsystem
UUDSubsystem* UD = GEngine->GetEngineSubsystem<UUDSubsystem>();
if (UD && UD->HasSession())
{
    // SDK is connected - point clouds are rendering
}

// Blueprint equivalent: Get Engine Subsystem (UUDSubsystem) → Has Session

UUDSettings

Project settings stored in `Config/DefaultUnlimitedDetail.ini`. The preferred way to edit them is **Project Settings → Plugins → Unlimited Detail (udSDK)**. **`ServerPath`** - udCloud server URL; point this at a private tenant URL for self-hosted deployments. **`APIKey`** - API key issued from your udCloud account; required for authentication. Do not commit this to public source control - use Unreal's per-user local config (`Saved/Config/Windows/UnlimitedDetail.ini`) to override it for individual developers.

; Config/DefaultUnlimitedDetail.ini  (committed - keep APIKey out of public repos)
[/Script/UnlimitedDetail.UUDSettings]
ServerPath=https://udcloud.nuclideon.com/
APIKey=your-api-key-here

; Saved/Config/Windows/UnlimitedDetail.ini  (gitignored - per-developer override)
[/Script/UnlimitedDetail.UUDSettings]
APIKey=dev-personal-key-here

Under the hood

How the plugin integrates into UE's render pipeline

A walk through what runs each frame. Skip this if you just want to ship; it's here for engineers who need to understand what's running inside their project before they sign off.

Subsystem startup

UUDSubsystem::Initialize() runs at engine startup in the PostConfigInit phase - before any level loads. It creates a FUDSceneViewExtension, which registers itself with UE's view extension system, then calls into udSDK to establish a session with the configured server and API key. The view extension stays alive for the lifetime of the engine and survives connect/disconnect cycles.

Component registration

When a UUDComponent becomes visible in a scene, it registers a render instance with the subsystem via QueueInstance(), passing the point cloud handle and the component's world transform. When hidden or destroyed, RemoveInstance() is called. The subsystem maintains a flat list of active instances rendered in a single batch per frame.

Per-frame CPU render

FUDSceneViewExtension::BeginRenderViewFamily() fires on the render thread each frame. It extracts UE's view and projection matrices and invokes CaptureUDSImage() on the subsystem, which feeds those matrices into udRenderContext_Render. The result lands in CPU-side colour (BGRA) and depth (float32) buffers.

GPU texture upload

The CPU buffers are uploaded to a pair of FTextureRHIRef textures via RHILockTexture2D / RHIUnlockTexture2D with a stride-aware memcpy. Both textures use TexCreate_Dynamic - compatible with D3D11 and D3D12 without consuming a GPU write path.

Post-process composite

FUDComposite inserts a post-process pass via the view extension. The pass samples the udSDK colour and depth textures and writes SV_Depth, letting the hardware depth test handle occlusion automatically. Point clouds correctly occlude and are occluded by UE scene geometry without any sort or painter's-algorithm logic.

Known limitations

Things to know before you ship

The rough edges in the current build. Workarounds are noted where they exist.

UE 5.7 only

The plugin uses internal renderer headers and RHI APIs that changed between engine releases. It will not compile against UE 5.4 or earlier without backporting. If you need an earlier engine version, contact us.

Windows Win64 in the default configuration

The .uplugin restricts the runtime module to Win64 by default. A Linux .so is included in the plugin and can be enabled: remove the PlatformAllowList entry in UnlimitedDetail.uplugin and uncomment the Linux block in UnlimitedDetail.Build.cs. macOS is pending a usable .dylib from the SDK vendor - the Mac build block is present but throws a build error as a safeguard.

Linux requires glibc 2.38 or later

The included Linux library requires glibc 2.38, which rules out Ubuntu 22.04 LTS (glibc 2.35). Ubuntu 23.10 or later is required; Ubuntu 24.04 LTS (glibc 2.39) is a safe target. If you need broader Linux compatibility, contact us for an older sysroot build.

Single viewport per frame

udSDK renders one view per frame. In a split-screen or multi-viewport layout, all viewports show the same point cloud frame. This is a udSDK render target limitation, not a UE integration issue.

API key stored in project config

There is no per-user credential store. The API key lives in DefaultUnlimitedDetail.ini alongside the project. Do not commit it to public source control. Use Unreal's platform-local config override in Saved/Config/ for individual developer keys.

Ship point clouds in your Unreal scene.

The plugin is on GitHub. Drop it into your project and rebuild. If you need a private udCloud tenant, a domain license, or macOS support, talk to us first.

View on GitHub Talk to Engineering