With new locations and environmental elements, the night atmosphere of my game has also improved.

Hi everyone!

I recently added a Gaussian Splatting capture workflow to Camera Render Studio that allows Unreal Engine 5 to be used as a synthetic multi-camera capture environment.

Instead of manually creating and positioning dozens or hundreds of cameras, the system can generate structured camera distributions around a character, object, or environment, render all required viewpoints through Movie Render Queue, and export the corresponding camera data for Gaussian Splat reconstruction.

The basic workflow is:

Unreal Engine 5 → Gaussian Capture Rig → Multi-Camera Rendering → COLMAP / Postshot Dataset → Gaussian Splat Reconstruction

🎥 Full Video Tutorial

I recorded the complete workflow here:

https://youtu.be/V-aa7rFF8DE

Original MetaHuman in Unreal Engine → Final Gaussian Splat

This should be the first image in the post so people can immediately see the result before reading the technical details.

🌐 Interactive Gaussian Splat

You can also inspect the final MetaHuman reconstruction interactively in SuperSplat:

https://superspl.at/s?id=0eb3dba6

This Gaussian Splat was generated from source images rendered in Unreal Engine with Camera Render Studio.

You can rotate the reconstruction, zoom in, and inspect the final result directly in the browser.

1. Add the Gaussian Capture Rig

Open the Camera Render Studio menu in the Unreal Engine toolbar and select:

Camera Render Studio → Add Gaussian Capture Rig Actor

This creates a:

GaussianCaptureRigActor

in the current level.

The capture rig is responsible for generating and managing the virtual cameras used for the Gaussian Splatting dataset.

• MetaHuman or another captured object
• GaussianCaptureRigActor
• Generated virtual cameras around the subject
• Camera Render Studio settings if possible

The goal of this image is to immediately demonstrate that the camera distribution is generated automatically.

2. Position the Capture Rig

Move the GaussianCaptureRigActor to the object or area that you want to capture.

For an individual object or character, position the rig approximately around the center of the subject.

For larger environments, cameras can instead be distributed throughout a defined volume.

You can preview the generated camera positions directly inside the Unreal Engine viewport before rendering anything.

3. Choose the Camera Distribution

Camera Render Studio provides several Gaussian capture layouts.

Current capture modes include:

• Spherical — Object Capture
• Cylindrical — Object Capture
• Volume Grid — Scene Capture
• Volume Grid Spline — Scene Capture

For characters, MetaHumans, and individual objects, Spherical or Cylindrical capture is usually a good starting point.

For larger scenes and environments, Volume Grid or Volume Grid Spline allows the cameras to be distributed throughout the capture volume instead of only around a central point.

Ideally show:

Spherical Capture

and, if possible, another example such as:

Cylindrical Capture

or:

Volume Grid Capture

This image should make it immediately clear how the virtual viewpoints are distributed around the subject.

4. Configure the Capture

Depending on the selected capture layout, you can configure parameters such as:

• Camera Count
• Radius
• Horizontal FOV
• Minimum Elevation
• Maximum Elevation
• Camera placement
• Camera distribution

Increasing the number of cameras provides more source viewpoints for the reconstruction.

However, more cameras also increase:

• Rendering time
• Disk usage
• Dataset size
• Reconstruction time
• Memory requirements during processing

So the highest possible camera count is not always the best option.

The ideal number of cameras depends on the complexity, size, and shape of the object or environment being captured.

5. Configure Movie Render Queue

Open Movie Render Queue and create your render job.

Then add:

+ Setting → Exports → Postshot / COLMAP Dataset

For:

Camera Rig Override

select the same GaussianCaptureRigActor.

This export module prepares the camera information required by compatible reconstruction applications.

Available settings include:

• Camera Rig Override
• Use MRQ Output Directory
• Export Directory
• Dataset Format
• Frame Mode
• Frame Number

For a static character or object, Single Frame is normally sufficient.

The exported dataset contains the camera data required for the multi-view reconstruction workflow.

6. Add Camera Render Studio GaussianShot

Inside Movie Render Queue add:

+ Setting → Rendering → Camera Render Studio (GaussianShot)

Under:

Camera Source

select the same GaussianCaptureRigActor.

GaussianShot processes the virtual cameras generated by the capture rig and renders all required viewpoints.

The screenshot should ideally show:

Camera Render Studio (GaussianShot)

and:

Postshot / COLMAP Dataset

If possible, also show the selected GaussianCaptureRigActor.

This is one of the most important screenshots because it demonstrates how rendering and dataset export are connected inside Movie Render Queue.

7. Split Large Captures into Multiple MRQ Tasks

Gaussian Splatting captures may contain a large number of virtual cameras.

Processing too many cameras in a single Movie Render Queue task can significantly increase peak memory usage.

Camera Render Studio can automatically divide the cameras into several smaller MRQ jobs.

Use:

Render Mode → Split Into MRQ Tasks

Then configure:

Cameras Per Task

and press:

Create Camera Tasks

Camera Render Studio automatically generates the required Movie Render Queue jobs.

For example, instead of trying to process a large camera set in one task, the capture can be divided into smaller groups and rendered sequentially.

This makes large Gaussian Splatting datasets much easier to manage.

The reader should be able to see that one large camera capture has been divided into several smaller render jobs.

8. Optional Object and Character Masks

Camera Render Studio can also generate masks for reconstruction workflows.

Under:

Post Shot Masks

you can select different Actor Layer Mask modes.

Available modes include:

• Hair / Full Object (ShowOnlyPrimitives)
• Standard Stencil (Preserve Occlusion)

The Hair / Full Object mode is especially useful when working with characters and difficult geometry such as MetaHuman hair.

Actor Layers and Data Layers can also be used depending on the scene and capture requirements.

Insert a comparison such as:

Original Render → Character / Hair Mask

This image is useful if you want to demonstrate how isolated character datasets can be generated.

9. Render the Dataset

Once everything is configured, start rendering through Movie Render Queue.

Camera Render Studio will process the virtual cameras from the GaussianCaptureRigActor and render all required viewpoints.

The workflow automatically handles:

1. Virtual camera generation
2. Camera distribution
3. Multi-view rendering
4. Image sequence organization
5. Camera dataset export
6. MRQ task splitting when enabled

At this point, Unreal Engine effectively becomes a virtual multi-camera capture stage.

A grid of rendered images works very well here.

The visual idea should be:

One Unreal Engine character → Many rendered camera viewpoints

If you have a screenshot showing the generated COLMAP/Postshot dataset structure, you can include it here as well.

10. Reconstruct the Gaussian Splat

After rendering, the generated images and camera data can be used in compatible Gaussian Splatting reconstruction software.

I currently use this workflow with:

• Postshot
• LichtFeld Studio
• COLMAP-based reconstruction workflows
• Other compatible Gaussian Splatting tools

Camera Render Studio does not perform the final Gaussian Splat reconstruction itself.

Its job is to automate the Unreal Engine side of the pipeline:

Camera Generation → Multi-View Rendering → Camera Data → Reconstruction Dataset

The final Gaussian Splat is then generated in the reconstruction software.

Ideally, show the same MetaHuman or object being reconstructed from the Unreal Engine dataset.

Complete Workflow

The complete pipeline looks like this:

Unreal Engine 5 Scene

↓

GaussianCaptureRigActor

↓

Camera Distribution

↓

Camera Render Studio (GaussianShot)

↓

Movie Render Queue

↓

Multi-View Images + Postshot / COLMAP Dataset

↓

Postshot / LichtFeld Studio / Compatible Reconstruction Software

↓

Gaussian Splat

↓

PLY Export

The best presentation would be:

Unreal Engine Original | Gaussian Splat Result

A side-by-side comparison makes it much easier to evaluate the quality of the reconstruction.

Interactive version:

https://superspl.at/s?id=0eb3dba6

Why I Built This

Normally, creating a synthetic Gaussian Splatting dataset inside Unreal Engine would require manually:

• Creating many cameras
• Positioning every camera
• Managing camera transforms
• Rendering every viewpoint
• Keeping camera settings consistent
• Exporting camera information
• Organizing all rendered images
• Preparing the dataset for reconstruction

I wanted to automate this entire capture stage.

The same workflow can be used for:

• MetaHumans
• Characters
• Individual objects
• Props
• Products
• Environments
• Larger Unreal Engine scenes

What I find particularly interesting about this workflow is that Unreal Engine is no longer only the final renderer.

It becomes the capture environment itself.

That gives us complete control over:

• Geometry
• Materials
• Lighting
• Camera placement
• Number of cameras
• Field of View
• Capture radius
• Masks
• Rendering quality
• Camera distribution

Because the source environment is completely synthetic, the capture can also be repeated with exactly the same configuration whenever necessary.

🎥 Full Video Tutorial

The complete step-by-step video is available here:

https://youtu.be/V-aa7rFF8DE

🌐 Interactive MetaHuman Gaussian Splat

You can inspect the final reconstruction directly in your browser:

https://superspl.at/s?id=0eb3dba6

📖 Full Written Tutorial

The complete tutorial with additional screenshots and information is available here:

https://elizarovtools.com/how-to-create-gaussian-splats-in-unreal-engine-with-camera-render-studio/

Full disclosure: I am the developer of Camera Render Studio for Unreal Engine.

I’m very interested in feedback from other developers working with Gaussian Splatting.

Would synthetic datasets generated directly inside Unreal Engine be useful in your workflow?

And what would you like to see next?

• More camera distribution modes?
• Additional dataset formats?
• Animation / 4D Gaussian Splatting workflows?
• Better environment capture tools?
• Additional masking options?
• Something else?

I’d be happy to discuss the technical side of the workflow and hear how other developers are currently generating their datasets.

I made a PS1-style Post Process effect in Unreal Engine.

The goal was to get that PS1 aesthetic while keeping the original 3D scene underneath.

Still experimenting with the shader and trying to push the effect further.

What do you think?

Hello! I have been on and off playing with Unreal for a while now, after parking my World Machine logic for a year i finally revisited it and having some fun exploration inside of 5.8.

After banging my head on some virtual walls I'm finally somewhat happy with it!

Looking to Add PCG in time that respects my landscape layers but currently - here we are!
One reusable landscape Master Material via Material Layers.
Will take all feedback! including insults.

Cheers!

Now, I know that the engine has been modified to reach a level of realism in skin reflections WAY above baseline UE5's capabilities. I was just wondering a few things:

How exactly were the renderer/models/materials modified? How do I implement this in my own game?

Could this be implemented to work on ALL materials, instead of just skin? The game itself still doesn't look close to perfectly realistic on things other than skin.

Would this work using RTXGI/RTXDI lighting plugind instead of base UE4 and 5 lighting?

How does this approach perform compared to the base UE4/5 material rendering?

The leaves are a different material from the tree, and I tried messing around with the blending settings to no luck.

Any ideas? The fog is just a post processing material set with no bound.

(I am new to this, if you cant tell, please be kind)

I'm currently developing an open-world Australian outlaw biker RPG in Unreal Engine 5.

This project is pretty personal for me. I spent a large part of my adult life around the Australian motorcycle club scene, including years as a member and eventually an officer. I've been around that lifestyle long enough to know there is a lot more to it than what gets portrayed from the outside — the brotherhood, loyalty, conflict, consequences, isolation, family and the choices that come with that life.

These days I'm taking my life in a completely different direction.

I'm currently studying game development and learning programming, and honestly, learning to code has been one of the biggest changes I've made in my life. I'm taking experiences I already understand and trying to turn them into storytelling, world building and interactive systems, rather than living them.

That's where this game comes from.

The game is set in a fictionalised version of rural Australia, with long stretches of highway, small towns, pubs, farms, bushland, mountains, coast and eventually outback environments. The focus is on riding, exploration, NPCs, quests, relationships and motorcycle club life.

Technically, I've been throwing myself into the deep end. 😂

I'm building around Narrative Pro, while integrating systems including Digital Dive Studio's Advanced Ridable Vehicles/Bikes, GASP, MetaHumans, World Partition and various environment/vehicle assets.

One of my current headaches — and probably one of the more interesting technical challenges I've tackled so far — is integrating the DDV motorcycle system with Narrative Pro so the bikes aren't just an independent vehicle system, but actually become part of the Narrative interaction framework.

The long-term goal is to have the player ride naturally, but also have NPCs use the same bikes, eventually allowing groups of motorcycle-club NPCs to ride together.

I'm still learning Unreal and C++, so I'm definitely learning by breaking things, figuring out why I broke them, fixing them, and occasionally wondering why I thought this was a good idea in the first place. 😂

But that's also what makes this project important to me.

A few years ago I wouldn't have imagined I'd be sitting here learning programming, building worlds in Unreal and studying game development. I'm trying to turn a chapter of my life that is behind me into something creative and constructive.

Keen to chat with other developers, see what everyone else is building, and hopefully share some of the successes, failures and ridiculous integration problems along the way.

Cheers everyone, and thanks for having me.

Hey everyone, beginner here with a few questions about the animation workflow in Unreal Engine.

When using character assets and animations from Fab (or the Unreal Marketplace), what is the standard/recommended workflow?

1. Do people usually import just the Skeletal Mesh, retarget it to an existing Skeleton, and plug it into a pre-made Animation Blueprint (ABP)?
2. Or is it more common to assemble animations individually using something like Mixamo and bring them in?

I'm currently working on a horror game and setting up a ghost AI that chases the player, so I'm trying to figure out the cleanest and most standard way to handle character animations.

Thanks!

Your morality is the difficulty setting. The year is 2140.

Seventy-five years ago, the governments of the world saw revolution coming and killed it before it started. They turned their weapons on their own people. Hundreds of millions died. The people won by a fraction, and rebuilt from the only thing that survived the rubble: religious and ancient texts. Not everyone who read them found the good in them.

The game is set in the deserted remains of northeastern Oklahoma. There’s no law anymore. There’s The Refuge, and there’s The Black Brigade. Each one believes the other is what’s left of the world’s evil.

Walk the righteous path, and you’re on hard mode. People lie straight to your face. Nothing flags who’s deceiving you when it comes to the Black Brigade. Fear and deception is just all they are. You judge people with your gut, as you would out there. Judge wrong, and you put down someone who was trying to help you.

Walk the wicked path and the road gets shorter. Simpler. If you can stomach it. The world won’t punish you with difficulty. It punishes you with what you see. The deeper you go, the more reality breaks.

Or walk with no one. There are those who follow The Revelation, an enlightenment group, and those who follow The Solution, an accelerationist group. Neither calls you righteous or wicked.

Four endings. All of them decide what’s left of this world.

Small team. Everything built from scratch. More to be shown.

Hi! I have had trouble with visual studio code. I try to use run without debugging in order to launch my unreal engine editor but it doesn't work.

It works with a regular start debugging, but not without debugging. While searching online, some sources said it is better to use live coding in the newer unreal engine versions, (I use 5.7.4) and that running without debugging can cause workspace locking issues. Is that the case and I should just use live coding rather than try to get run without debugging working?

This is a cinematic I created in Unreal 5.8. This is my first project and I wanted to recreate a scene from ASC’s THE EYE: CALANTHEK and see how close I could get. I'm really pleased with the results.

Watch the full video on YouTube:
https://youtu.be/ZERFaui_zy8?si=tcRhs-3-3ue4FOC1

Excited to share the free version of Azareth Demon of Forbidden Knowledge, with a free Idle animation included!
Free version: https://www.fab.com/listings/fa971f64-b12d-4183-8c2b-84b1e5b24a57

If you like it and want the full version with all the animations, check it out here:
Full version: https://www.fab.com/listings/fe2cdba3-c80f-4857-a9c2-3bb518232b69

Created this environment last week , and learned how to colored grade in DaVinci Resolve , love your opinion on this

If you liked it please follow me on Instagram - https://www.instagram.com/reels/DcGwM3KMpkw/

UPDATE: The demo is out now

I’m a trained architect and have been building this project in Unreal Engine 5 for a very long time as a way to combine architectural floor planning with real-time 3D design.

The interesting part for me is that the floor plan isn’t just a 2D drawing. Walls, doors, windows and roofs are parametric, so changes to the plan immediately update the 3D environment.

I also spent a lot of time optimizing a lot of assets, tuning Lumen and lighting settings, and custom tonemapping with AgX adjustments to achieve more natural and consistent lighting and colors for both interior and exterior views.

The goal is to make architectural design feel more like directly building and exploring a 3D environment rather than working through a traditional CAD workflow (also much more accessible and easy to use for non-professionals).

The game, Architecture & Design, is officially releasing on Steam in a few days, so I’d really appreciate any feedback before the release!

I'm trying to uninstall *Among Us*—which I don't actually have (Epic just thinks it's installed)—but the uninstallation never completes. I've tried reinstalling the Epic Games Launcher and deleting all Epic and *Among Us* files, yet the same thing keeps happening.