Why is the game lagging?
Before you start optimizing, it's important to understand that any game in Roblox runs on an engine that has to constantly process a huge amount of information: render graphics, calculate physics, execute scripts, and synchronize data between the server and clients. When there is too much of this information, performance drops.
The main causes of lags are usually found in three areas: too complex graphics and a large number of polygons, unoptimized scripts, which perform extra operations every frame, and excessive use of engine physics. Beginners often do not notice these problems at the development stage, but players with less powerful computers or mobile devices will immediately encounter slowdowns.
Optimization of models and graphics
Let's start with the most obvious thing — 3D models. Each model in your game consists of triangles (polygons), and the more of them there are, the harder it is for the engine to render them all. If you take a beautiful detailed tree model with thousands of polygons and place 50 of these trees on the map, don't be surprised if the game starts to lag.
The solution is simple: use models with fewer polygons. For background objects that are far from the player, simple models are quite sufficient. Remember that players often won't even notice the difference between a 500-polygon model and a 5000-polygon model if the object isn't right in front of the camera. Try to find a balance between beauty and performance.
Another important point is textures. Do not upload images of 4096x4096 pixels for a small object. Roblox automatically compresses textures, but it is better to use reasonable sizes in advance: 512x512 or 1024x1024 pixels are enough for most objects. Also, avoid using too many different textures — the engine is easier to work with a smaller set of repetitive materials.
Optimization of lighting and effects
Lighting in Roblox can greatly affect performance. If you have dozens of light sources on your map (SpotLight, PointLight, SurfaceLight), each of which casts shadows, this creates a huge load. Try to limit the number of active light sources and use shadows selectively — only where it is really important for the atmosphere.
Instead of multiple light sources, you can often use global lighting (GlobalShadows) and correctly configured lighting parameters in Lighting. Also pay attention to the CastShadow property of light sources — disable it where shadows are not critical. Each additional shadow requires additional calculations.
As for visual effects — particles, rays of light, smoke and other ParticleEmitter — use them wisely. One emitter that creates 100 particles every second may look cool, but if there are ten such emitters and the game has to process 1000 particles at the same time, the performance will drop. Reduce the number of particles, their size and frequency of occurrence where possible.
Script optimization
Now let's move on to scripts — this is perhaps the most important area for optimization. Many novice developers write code that executes every frame in an infinite loop, even when it is not necessary. A classic example is the use of the while true do loop with wait() inside to constantly check some condition.
Use events instead of constant checks. For example, if you need to track when a player touches a certain part, use the Touched event, and do not check the player's position every frame. Events are triggered only when something happens, and do not constantly load the processor with checks.
Another important point is to avoid using FindFirstChild or other methods of searching for objects in a loop that is executed frequently. If you need access to an object, it is better to save a link to it in a variable once when initializing the script. Searching for objects in the Workspace tree every frame is a waste of resources.
Also pay attention to Remote Events and Remote Functions, which are used for communication between the client and the server. Do not send data to the server every frame — this creates a network load. Group data and send it less often, for example, once a second, if it is not critical for gameplay.
Working with physics
The Roblox physics engine calculates collisions, gravity, and interactions between objects. The more objects with physics enabled, the greater the load. If you have decorative elements that should not fall or that the player does not interact with, set them Anchored in true. This means that the object is fixed and the engine will not spend resources on calculating its physics.
Please also note complexity of collisions (collision). Roblox automatically creates invisible collision boundaries for each object, but for complex models these boundaries can be very detailed. If possible, use simple shapes for collisions (cubes, spheres) instead of exact repetitions of the model shape. This can be configured via CollisionFidelity — for most objects, the value Box or Default will be suitable instead of PreciseConvexDecomposition.
Memory and load management
Do not load everything into the game at once. If you have a large map, use the technique streaming (streaming) — show the player only those parts of the world that are close to them. Roblox provides a built-in StreamingEnabled system that automatically loads and unloads parts of the world as the player moves.
Also keep track of the number of simultaneously active objects. If you have a game with a lot of NPCs (non-player characters) or mobs, don't create them all at the same time. Use object pools — create a certain number of objects in advance and reuse them, instead of constantly creating new ones and deleting old ones.
Testing on different devices
Remember that your game should not only work on your computer. Many Roblox players play on mobile devices or laptops with not the most powerful hardware. Regularly test the game on different devices or at least emulate different performance levels in the studio.
Use Roblox Studio's built-in tools to analyze performance. Open Developer Console (F9) during testing and look at the Performance and Memory tabs. There you will see what exactly is loading your game: scripts, graphics or network. This will help you understand what you should pay attention to first.
Little tricks
There are a few simple tricks that can significantly improve performance. For example, use LOD (Level of Detail) — show simplified versions of models for objects that are far from the camera. Disable rendering of objects that the player does not see, for example, using transparency or removal from Workspace.
Also, don't forget about interface optimization. If you have a lot of GUI elements, especially with animations or updating text, this also creates a load. Only update the interface elements that have actually changed, and don't redraw everything every frame.
Game optimization is not a one-time task, but an ongoing process. As you add new content, you'll have to keep an eye on performance and make improvements. The main thing is to understand the basic principles and apply them from the very beginning of development, then you will not have to redo the whole game when it is ready.
All these topics and much more can be explored in Codice in more detail, analyze each aspect on practical examples and consolidate knowledge by completing tasks. We create courses that help novice developers not only learn the theory, but also learn how to apply it in real projects.
And if you need support during the training or want to discuss your ideas, we already have a large team of like-minded people in active Telegram channel, where developers help each other, share experiences and grow professionally together!