blog.info()

In November 2024, I left my job as a Senior Software Engineer to make Roblox games. I've been making Roblox games since then. For the last year I've spent every day working on the Roblox engine. I've released 3 Roblox games, with a 4th being under heavy development. The games I have worked on have amassed over a million visits and over 1,400 concurrent users.

Here are the most valuable nuggets of knowledge I gained during that time, ranging from optimizations to marketing. Some of these lessons can be applied to game dev broadly, and some of them are specific to the Roblox ecosystem and tech stack.

Lesson 1: Keep it Simple

For Roblox games, you have to keep in mind that the primary audience is children. For this reason, simplicity is your friend. Keep game loops tight. Make sure that your mechanics are easy to understand, ideally without the need to read anything. Simplicity benefits us in several ways:

Simple systems are easier to port to other games. More on this later.
Systems that are easy to understand work better with children.
Systems that are simple are easier to maintain and are harder to break.
Simple systems typically run better on lower-end hardware, which the majority of your audience will be using (more on this later.)

Lesson 2: Plan to Reuse Systems (With a Caveat)

This is arguably the most important thing I learned during my time making Roblox games. You should create game mechanics under the assumption that you're going to port the logic to other games. Let me give examples of systems I've reused extensively between games:

Robux purchase processing
Coin collection
Animations and sounds
VFX
Level and XP systems
etc

The most important thing to remember, though, is do not design your systems to be fully generic. If you do this, you'll spend all of your time trying to generalize everything. It's OK if your Robux purchase system has hard-coded values for items it grants.

You will have to modify your existing systems when porting them to another game. This is OK. Do not try to make your systems too general, because at that point you're building libraries, not games.

Lesson 3: Keep it Server-Authoritative

If you want your game to be taken seriously, you'll want to defend against hackers. The easiest way to do this is to validate game state on the server before performing an action. The drawback to this approach is that making your game too server authoritative will show in the form of latency. Just keep in mind that anything you delegate to the client can be tampered with, so be careful about what you're letting the client decide.

Lesson 4: Concurrency is Powerful, but Dangerous

Remote event handlers spawn a new task for each remote event that is fired. This allows the server to process many at once. However, something critical to keep in mind is that if you yield (task.wait()) in an event handler, you've now introduced randomness into how events are processed.

If you need to make sure that some piece of game logic executes before anything else happens, do not yield. On the other hand, be careful not to block the main thread with heavy processing.

Lesson 5: Optimize for Mobile

Most Roblox players actually play on a mobile device. This means you should be optimizing for performance. That translates to making sure StreamingEnabled is enabled, which allows the Roblox server to only stream necessary parts to the client. StreamingEnabled forces you to design your game a little bit differently, meaning that you will have to account for objects possibly not being there on the client, and reappearing later. CollectionService is an excellent tool for managing this.

It also means optimizing your map. I'm less of an expert on map building, but making sure your geometry isn't too complex is important.

Be careful about using too many heavy VFX (via beams and particle emitters.)

Be careful about how many objects you're spawning and managing in workspace.

Lesson 6: Optimize the Network

Most of your Roblox game logic will rely on Roblox's native replication or custom remote events that you define. Here are some things to keep in mind:

Batch remote events. Rather than sending 10 remote events in 1 second, send 1 remote event with 10 data points.
Keep the data sent in remote events lean. Try to limit yourself to basic data types like numbers and booleans. Send the minimal information you need the client to have. Tables and large strings cause network overhead.
Offload heavy processing to the client via remote events. A prime example of this is for VFX. Instead of playing VFX on the server and relying on Roblox's native replication, you should instead use a remote event that tells the client "display the VFX with this number ID."

Lesson 7: Use ProfileStore

I won't go too in-depth on this one, but ProfileStore is extremely easy to use and solves several problems for you including session locking, race conditions, graceful shutdowns, and rate limiting. There's really no reason not to use it.

Lesson 8: Expect to Fail

This is more philosophical, and applies to all game dev. Your first game will likely not succeed. Nor your 2nd or 3rd. Try to approach learning Roblox as a long-term endeavor. Build systems to be reusable so if your game flops you can drag and drop it with some modifications for a new game.

Lesson 9: Make Connections With Other Devs

You will come across many people on your journey of making a game, unless you plan to do everything yourself. Find the hard workers and pay them well and network with them. These connections are invaluable, especially in the Roblox ecosystem.

Lesson 10: Use UIAspectRatioConstraint

UIAspectRatioConstraint is absolutely essential for responsive UI in Roblox. Without responsive UI, your game will be unplayable by the majority of players.

Lesson 11: Get Constant Feedback

This one can be applied to game dev broadly, but get feedback from players constantly. Do not build in a silo or you could end up spending months building something that no one finds enjoyable.

Conclusion

This list isn't exhaustive, but it's all I can come up with for now. Some of these lessons I learned the hard way, so I hope you can learn from my example.