GODOSSIAN SPLATS: Gaussian Splats in Godot (And Why You Might Not Want To)

Added: 2026-05-05

[00:00:00]Hello, ladies and gentlemen, it's Mike here at GameForScratch. Today, we're going to talk about Gaussian splats in Godot specifically. But first, you may be wondering, "What the heck is a Gaussian splat? I've never heard of this before." Well, you've probably seen them though. If you watched any of the coverage of the Olympics, this is a video on how it was created. Notice this array of cameras. It acquires this data.

[00:00:18]It's basically this data is a bunch of Gaussian splats being recorded in real time. A Gaussian splat basically being an ellipsoid data structure for kind of think of them as virtual 3D pixels. Then using a combination of a number of cameras, Gaussian splat data type, a bunch of AI software on the back end, they're able to basically recreate these 3D scenes and do things that were previously impossible within a couple of seconds. So as you you see, zooming in on footage, making trajectory videos, doing markups of them in real time. It's being really heavily used in the world of sports. But what about in the world of games? Well, truth of the matter is not really yet. But the tech is there.

[00:01:00]We're going to look today at how you can get Gaussian splats into the Godot game engine. And we're also going to look at some of the definite limitations of Gaussian splats today. If you want a little bit more interesting hands-on with Gaussian splats, a great place to check out is a site called SuperSplat.

[00:01:14]This is actually built on top of the PlayCanvas HTML 3D framework. It is a cool site and there's a bunch of splats available here. You can go ahead and check these out. Gives you an idea of what they are. So basically, think of a Gaussian splat as a data structure for storing 3D scans. So you can take the real world and bring it into your computer. Again, you saw it being used in primetime TV to to showcase things that were otherwise impossible. But this one here gives you an idea of how it could potentially used to create game levels or to scan real-world objects in. So here you can see, we kind of this looks like a video right now, but I can at any particular time come in here with the WASD keys and I can navigate around this world. So this guy has gone through and basically taken a metric buttload of photos of his uh his garden area. He's obviously polished by the book collection over here. We can see the fidelity of what you can actually scan there if you take enough pictures.

[00:02:08]And then it is over here. Again, see how it's got less detail? If you did not take enough photos, you're going to get less detail of it. So it's all going to basically come down to the amount of data that you sent in as a source, how much you're going to get back. So here, obviously, he's done basically nothing. So you've got the dark abyss going on over there.

[00:02:27]But you can see how this can be used to capture and recreate the real world in a way that we have it in the past. Now another thing you may have noticed here is I actually have collision detection going on here at a basic level. I can even jump and interact with this on physics. That is not part of splats.

[00:02:42]These are not polygons. These are literally like virtualized ovoid pixels in space. It's closer to voxels in a way, but voxels can be meshified a little bit better. Splats don't really work that way. So if you're interested in checking out, do come in.

[00:02:58]Check out SuperSplat. It's actually even got some tools so you can actually, you know, cut down the data that you're not interested in. So if you wanted to use it to acquire something like a bug, so here you can see, this gives you an idea of how detailed of models you could actually bring into your game environment in splat format. So that is a Gaussian splat. You're seeing one in action. They are super impressive and absolute nightmare fuel if you pick this particular demo. So that is the idea behind a splat. These are not polygons.

[00:03:25]They're again, this is made up of a number of splats, literal um ovoid dots in this world. So you can bring these into the Godot game engine though. And there's something new a new plugin released a couple of weeks ago called the Godot Gaussian Splatting or GDGS. This is a real-time splatting rendering plugin for the Godot game engine released under the MIT license. If you like what they're doing here, by the way, do drop them a star. But we're going to go take a look at how this one looks inside of the Godot game engine. And at first glance, here we are in Godot and you're going to notice something right away. This splat is it's very dotty. So that is kind of what splats look like unrendered. But this is actually being drawn. So when we go into the actual view of it, the splat is going to instead look quite a bit different. So here we go. And now we see the splat in the Godot game engine. So it's being rendered as a splat. This is being brought in as a PLY or like basically a point cloud that is being rendered as a Gaussian splat. Though one other thing you're going to want to be aware of is these files are pretty big.

[00:04:31]From a couple of megabytes, this one I think was about 10 megabytes. It shipped with the project, by the way, if you want to go ahead and check that out.

[00:04:37]I'll show you on the GitHub repository where that's available. But this is again, there's no real AI. So you sorry, no real collision. So you notice here, I'm bouncing off of it. Well, that is just because I've set up around this splat a rigid body myself manually. And that's one of the workarounds you're going to have to have. So when you're working with these things, this is a rigid body that I've manually defined around that outside shape. Otherwise, you're going to have to some kind of a post-processing if you want to create a rigid body around these shapes. That is not an aspect of this that is built in straight away. So what you can actually do with this plugin, I've actually gone ahead and imported another This is a kind of a famous splat from earlier demonstrations. Here you can see a different one and we can navigate around the scene. This is a capture of a park.

[00:05:24]You get an idea of what that looks like over there. So this is a Gaussian splat of an outside world. And again, when you render it inside of the editor, it doesn't look ideal. So when I come here and we run it, so go ahead and we'll run that instead.

[00:05:39]And now you're going to see it looks it's a lot like that other example we looked at earlier on. If the data is there, it looks good. So over here, looks good. But as we get to where the scan was not, it doesn't look so great.

[00:05:52]But as you can see, the performance is just fine. So even though this isn't a traditional polygonal workflow, it's still renders pretty fast. So if you want to go ahead and check this one out, the best way to do it is go ahead and get that GDGS plugin. It's not available on the asset library. You have to download it from GitHub. And then basically bring it in as a plugin, GDGS.

[00:06:12]Now the rest of the setup is super simple. Once you've done that and enabled it, it brings in an importer. So when you bring in something like here is this demo file I used right there. And here is another one. So this is the demo that we saw earlier on. And you see, that was actually 65 megabytes. So this one right here. So let me turn the other splat off. This one that we see right here, this is a 65 megabyte data structure.

[00:06:34]And you could represent this in polygons in probably, you know, a megabyte worth.

[00:06:38]This is 106. It's not very efficient for size. And then that other one we're looking at, that point cloud, again, not optimized at all for any of this. But as you can see here, that one's 850 megabytes. So Gaussian splats are not tiny. But once you've gone ahead and installed that plugin, it can now import in these point cloud files as PLY. It supports a couple of other file formats as well. Your mileage may vary in terms of which ones work the best. And then the only other thing you need to do, and the secret sauce to how this all works, is this is actually implemented in the compositor. So in your environment world environment settings, go to your compositor settings. And then what you want to do is wait for it to stop doing that. All right. Come on down here and you can add a new compositor effect in.

[00:07:18]And then you're going to find there's one that's predefined, the Gaussian compositor effect available over here.

[00:07:23]So you can see, here is the code for it.

[00:07:25]And that is this is the logic that is actually rendering that splat as part of your scene. This is also why it's being done quick. Now do keep in mind, this is early on. So this technology, it may just not be for games. It may be used for part of the pipeline. It may be used as part of you import or an object in and then later on convert it over to polygons and it never actually touches your game engine. But if you want to bring in these Gaussian splats to your game, I can see how you could actually, if you want to create a neat thing of like going around your own house, you could scan it as a number of different splats, bring them in as separate files.

[00:07:58]And otherwise, it's super simple.

[00:07:59]Basically, once you've got this enabled, come on in. Let's bring this back onto the main screen. It also adds another node here, a Gaussian splat node. You bring that one in. So there is your new Gaussian splat node added in there. And then you just basically take the splat, drop it there, and done. That's it. That's all you need to go ahead and render the Gaussian splat. Other than of course, in your world environment, add the compositor effect and then add in that Gaussian compositor effect in and that's what causes the actual rendering to happen.

[00:08:33]If we take that one out, it goes away.

[00:08:34]Another thing you're going to notice here, I have a light in the scene. You see it's giving off color and you're going to see it's not having any effect on the scene itself. That is another challenge here. If you want to fix that, you're going to actually have to come into that compositor. You're going to have to come into this script and make sure that it interacts with the lights from the scene. But that should be possible. I don't actually I don't have much experience or really any experience with the Godot Godot compositor capabilities. So one of those things that you would probably want to look into a little bit.

[00:09:02]There are a ton of limitations to this technology. But at the same time, it's really cool. It may have very niche uses now, but it may evolve into something very cool in the future. Another thing, again, the performance is just fine.

[00:09:15]Other than my whole computer seems to be chugging today. So one of those things to be aware of. So that is it, ladies and gentlemen. If you want to go ahead and check that one out, once again, it is the Godot Gaussian Splatting GitHub library. Obviously, I will have this linked in an article down below.

[00:09:30]It's from Recon World Lab, by the way.

[00:09:32]So that's GDGS. I mean, I should say if this gets added to the asset library, gives you an idea of how it goes ahead and renders them, how it works.

[00:09:39]It's it's neat technology, but it may not be for everybody, obviously. So Godot 4.4, if you want to go ahead and check that one out. They do have instructions on how to go ahead and get this thing set up, but it is super simple. Another warning is if you try to bring in really large splats, like 4 gigabytes, 5 gigabytes in size, Godot import seems to chug on them. Hopefully that gets resolved in the future. By the way, if you're interested in how I can go about getting and creating my own Gaussian splat, one of the easiest solutions out there is Kiri Engine.

[00:10:06]Maybe worth checking that one out. You can actually just use your phone to go ahead and create 3D Gaussian splats.

[00:10:11]There's a number of other applications out there. I'm actually picking Kiri Engine specifically because they have this interesting article they've done on basically 3D Gaussian splatting in Godot. So, they kind of did a talk on it, how you can actually go ahead and use Gaussian splats in the Godot game engine, the different approaches to it, including the one that we just looked at here. The other one is a straightforward viewer, which is also available. So, the GDGDS, which is implemented with the compositor effect. And kind of a bit of a walk-through of what else is of interest. So, I will have this link in the linked article down below. So, if you want to learn a little bit more about it, or you want to go ahead and create your own splats, Kiri Engine is one of the options. Unreal Engine also has their reality capture, I think it's called. I believe it can create splats.

[00:10:52]There's a number of pieces of software out there that you can use a phone to create splats. So, there's a ton of tech out there that you can go ahead and create with them.

[00:10:59]But yeah, that is it, ladies and gentlemen. Gaussian splats in Godot. Let me know what you think. Comment down below. I'll talk to you all later.

[00:11:05]Goodbye.