What would I like to request?
I would like to request that a Render Distance feature be added to GDevelop for 2D and 3D games, available in the project settings (“Resolution and Rendering”).
The feature should automatically:
hide and deactivate objects that are outside a specified distance from the camera,
save their state (position, variables, HP, animation, etc.) in memory or variables,
restore objects when the player is near them again,
allow the developer to set the render distance in pixels and choose which objects to stream.
In other words: an automatic culling + object streaming system that runs natively in the engine.
Why am I asking for this?
GDevelop currently renders and updates all objects on the scene, even if they are very far away from the camera.
With large maps or open-world games, this results in:
enormous CPU and GPU load,
FPS drops,
the need to manually create complex culling systems,
limitations in designing large worlds.
In my case, I am creating a very large 2D open world (over 3 billion pixels) with hundreds of objects.
Due to the lack of native culling, the game drops to ~26 FPS, even though the game logic itself is light.
Such a feature would:
enable the creation of large worlds in GDevelop,
significantly improve performance,
simplify the work of developers,
bring GDevelop closer to the capabilities of engines such as Unity, Godot, and Unreal (which have culling and streaming built in).
Evidence confirming the need for this feature?
GDevelop updates all object instances, even those thousands of pixels outside the camera.
This is confirmed by the community and documentation — there is no native culling.
Games with large maps (survival, sandbox, open-world) experience drastic FPS drops if the scene contains many objects.
This is a common issue reported by users on GitHub and Discord.
Current workarounds (manual object removal, custom streaming systems) are:
difficult to implement,
prone to errors,
unintuitive for beginners,
do not work perfectly with hundreds of objects.
Other engines have native solutions:
Unity: occlusion culling + streaming
Godot: visibility notifier + chunking
Unreal: world partition
As a beginner-friendly engine, GDevelop should have a simple version of this feature.
In my game (a large 2D world), tests show that the biggest problem is the number of active objects, not the game logic.
Render Distance would solve this immediately.
Summary!
Please add a native Render Distance / Object Streaming system that:
automatically deactivates objects outside the camera,
saves their state,
restores them when the player returns,
allows you to set the rendering distance,
works in both 2D and 3D.
Such a feature would significantly increase the capabilities of GDevelop and allow for the creation of large, smooth worlds without complicated workarounds.
PS.Currently, I hide objects outside the camera and replace static objects such as trees with lighter equivalents without events. But that doesn’t help.
The graphics are not rendered. This means that the GPU does not have to calculate their graphics. But they are physically there, and when they have events, they put a heavy load on the processor. Especially since I have over 2,000 objects on the map. Render Distance would solve this problem. Because it could save the position in memory, remove objects outside the camera or at a certain distance from the player, and when the player (or camera) approaches that position, recreate them. I think that removing objects, saving them in memory, and reading them is much more efficient than having a given object on the map.
And here it doesn’t even matter whether you have a powerful processor or a weak one. It works the same on every one. This is because GDevelop runs on a single processor thread. (and probably also on one processor core). So all collisions, everything my objects have, must be checked every second. And there is no way to optimize the code further, because each object is checked separately. If only there was an event that literally turned off all codes for designated objects that are in the background. That would be better. For example, there are thousands of trees in my game. And each one is checked for collisions with an axe. And Render Distances should literally remove objects from a given distance. So the performance will be much better.Here, I even have a screenshot showing how many objects I have on the map. And somehow it works, and you can play the game relatively normally.
Actually, my game has an open world. But it’s barely 26 fps. So I’m asking the developers to add render distance to the engine. That’s the only thing missing from this engine. And if the developers don’t do it, I’ll try to make a plugin for GDevelop with render distance. But it will take some time and I don’t know if I’ll succeed.
I even gave a simple example of how this could be done before. Because, in fact, GDevelop already has the right system (writing and reading). Now we just need to use it to create a render distance.
I believe that, (based on what you’re saying), the real issue in your project isn’t so much about what gets rendered or not, or at what distance.
The heavier part is probably all the different collisions that need to be checked.
Maybe,and I really mean maybe,you could dig into Pandako’s fast collision system instead of the classic one, just to squeeze out a few more FPS during collisions.
All in all, I’ll see when I have time, and maybe it will really add a few fps. But what I meant was that if GDevelop had Render Distance, the processor wouldn’t have to calculate anything far away from the player at all, because no object would physically exist on the map. That would give a huge fps boost. I’m talking about a system that saves objects far away from the player in the game memory (variable or device) and removes those objects. And when the player approaches that point, it reappears them (from the memory data). This is much more efficient.
And to say i did’nt know that rendering distance existed in the games engines!
Although it can be approched using object(s) variable(s) with condition to verify for performing the actions attached to the condition if variable gives back true.
But if there are hundred of objects to manage, it will be less effective than the solution said by @MoczusYT.
if the collision checks are lagging your game just have them check a set the distance between 2 objects. It usually removes most lag from checking collisions with 200+ objects. or just make a culling method
I already did that. But I just want GDevelop to add automatic object streaming, because that would allow me to make open-world 3D games without worrying about code optimization.
Summary!