I’d consider myself a high-intermediate Roblox scripter, and I’m at the point where I feel like I understand most “standard” scripting concepts — but when I look at advanced systems or open-source frameworks, it feels like I’m staring at an entirely different language.
For example, I understand:
Creating and using ModuleScripts
Returning tables
Writing functions
Basic OOP patterns (like module:New() and setting metatables)
RemoteEvents / RemoteFunctions
General client-server structure
Basic optimization practices
However, when I look at more advanced resources, I start seeing things like:
Highly optimized systems that seem extremely structured and intentional
And that’s where I feel like I hit a wall.
Another area I really want to improve in is optimization and performance. I understand the basics (avoiding unnecessary loops, not overusing wait(), minimizing expensive operations, etc.), but I want to go deeper into:
Writing scalable systems that won’t fall apart with 50+ players
Reducing memory usage in large systems
Understanding how Luau handles memory and garbage collection
Structuring code to avoid hidden performance costs
Network optimization and reducing unnecessary replication
Profiling and identifying bottlenecks effectively
I don’t just want my code to work, I want it to be clean, scalable, and performant at a high level.
My questions are:
What specific advanced topics should I be learning next?
What concepts separate an intermediate scripter from an advanced one?
What optimization knowledge should an advanced Roblox developer understand deeply?
Are there programming concepts outside of Roblox/Luau that I should study?
How can I “read” advanced ModuleScripts better and understand what’s going on?
Are there good open-source projects or patterns I should analyze?
I don’t just want to copy advanced systems — I want to understand why they’re structured the way they are and how performance considerations influence their design.
If you’ve made the jump from intermediate to advanced, what helped you the most?
This is totally unrelated to your questions. But I think you should join the offical roblox programmer group on devfourm. This adds a very small badge near your avatar picture, this is so people know your a scripter.
I reccomend you to learn about typechecking and types, and one important thing you have to learn from all this is that you shouldnt get frustrated about improving immediately. Experience is gained over time.
You probably saw evidence of developers using package managers like Wally. They allow Roblox modules and services to be always updated in your file system. Then, they usually use Rojo to sync the codebase back to Roblox. I personally do not like Wally because it doesn’t let you set where each package goes in the codebase. You end up requiring them from a constant Packages folder, which is unideal for organization. You can try making a module that just requires the package, but then you have to manually re-export and define all exported types. It’s a mess, and I don’t want to deal with it!
I also prefer Argon over Rojo, since it’s more developer friendly and has two-way syncing. There’s also Azul, RbxSync, Pesto, and probably a lot more. Script syncing is high demand! Roblox’s native script sync won’t be properly type checked since requires aren’t properly typed, and will very likely error when you use any linter or language server. A sourcemap.json file is needed to know the hierarchy of the game and fix those type errors, which these syncing solutions will provide.
There’s genuinely countless signal implementations. Here’s a good place to start! If you want to be absolutely sure of which module is best for you, you should benchmark them and check their documentation.
Promise implementations are very important if you’ve dealing with messy asynchronous or error-prone logic. Returning a Promise means returning a value that will be ready in the future, making it a lot easier to deal with. You could use it for so many different things, such as caching and loading user data predictably, loading an image, returning the result of a pending Http request, etc. Like Signals, there are many different implementations people have put together. Find the one that’s right for you or make one yourself!
Attributes (using server authority + client-sided prediction)
Currently I’m using attributes and server authority. Server authority is in a studio beta, and should release Early 2026. Source
I personally believe class implementations are not for Luau. Generally use object oriented programming (OOP), data oriented programming (DOP), or an Entity Component System (ECS) instead!
Modular frameworks are quite popular, but I personally don’t know of one that is worth implementing. For me, it would need to support the new type solver, be type safe, and optionally support external IDE + GitHub workflows.
Generally, if you use less memory, your systems will be faster. For example, instead of using floats to store RGB values, use buffers! Buffers provide low level access to bytes, allowing you store as little as 1 byte to store one 8-bit integer, rather than 32/64 bits. For each color channel, only 1 byte is necessary, so you can save a lot of memory! And when you save memory, you speed up everything.
Reducing calls and/or batching work into less calls also help speed up your code slightly, which may turn into a big performance boost at scale!
Parallelism also allows you to execute threads simultaneously on different CPU cores, speeding up specific classes of tasks!
You should start unit testing everything! They will help you catch bugs and build confidence that your systems are still working when you make a change.
Additionally, if you use UI libraries like Fusion or Iris, you should consider writing stories! Stories are like unit tests for reusable UI components. They’ll help you create, test, and debug your components!
Always trying to find better ways to do things, like you’re doing now, has helped me a lot. Don’t be afraid to try new things, and don’t be afraid of learning tooling, workflows, or other people’s perspectives.
Designing and unit testing sub-systems first will also greatly help you. That’s called top-down design! And before even that, always plan out the prototype of your project.
Prototyping a project before fully polishing it will definitely help you. The sooner you get something usable out there for your testers, the sooner you can get feedback and bug reports. And maybe the idea was a bust… with a prototype you don’t waste too much of your time.
When making any project, always consider the user experience. Whether the user is the player of an experience, a developer using a plugin, or a developer trying to use a library, good UX goes a long way!
You’re not alone, it can definitely be hard sometimes to read other people’s code. See their documentation or example uses if they’re provided. Learn how their code works top-down (more independent systems first). It’s a lot easier to do that rather than to learn everything all at once, not knowing how anything works to begin with.
Be proactive! If you have an issue, need to learn something, or need a new tool, find a solution! As an example, I was getting irritated of testing string patterns with the command line. The plugins that already made an attempt at solving this were not great, so I made my own.
This has helped me a lot! And if you polish your tool and it’s not too niche, you should consider releasing it so you can help other people. I have many ideas for Resources and I plan to do some of them this year. Maybe you could make use of them? ;3
By default, Roblox doesn’t compact the data you send between clients and servers much, because that data could be anything. But when you use a networking module like Packet, you can greatly optimize your network! Packet for instance, serializes requests and responses using buffers, saving only the necessary bytes to get the job done. This reduces memory usage and significantly improves bandwidth, way better than raw RemoteEvent usage could accomplish. Also consider Sera, just a serialization library that can be used for anything.
That’s fair. By class implementation, I was assuming the usage of a library like Classe, specifically designed to feel more like real classes compared to plain old metatables. This is what I’m against, because I don’t feel like it’s fit for Luau!
As disappointing as it sounds, this is not advanced.
In fact, this is a programmer wannabe level, and on Roblox, if you want to make a game that is easy to update and is optimized, you should look at making code as direct as possible, no middleware, no “this will handle it for me”, clean Roblox API calls ONLY are allowed but shall be minimized too.
Functional programming and ECS (without middleware) are the true “endgame” paradigms that you will be using subconsciously, let’s say.
OOP and metatables fight runtime (Luau VM) and cannot be compiled in --!native mode into anything.
But pure upvalues and math absolutely can; this is why decentralized data-oriented logic like functional programming and ECS wins because it aligns with both Luau VM and CPU architectures.
I have made a tutorial about it if you want to learn typecheck
JUST NEVER WASTE TIME ON TYPE FUNCTIONS
I don’t know why they even exist, but all they do is overcomplicate everything and are just insufferable for giving quite literally no information for compiler.
This is why static types are superior
Need to remember that you make code for it to be optimal and not “comfort zone” slop.
As the fellows scripters in this post has sent you what i believe more than enough resources, i will keep this short and help you built some kind of a road map.
The first most important thing.
The first most important thing is experience, you go and see frameworks, cleaners like maid, network optimizers, and wonder “why would i need these stuff”
The truth is, you wont understand it unless you experience it yourself, or have atleast a tiny bit of experience to say “ah i can see your vision and this upcoming problem”.
Types
If you havent, check type annotiation, this comes in handy with the framework, as depending on the framework you make, you wont have auto completion, so learning this is infact more of a productivity hack and easier to do.
for example, you can have a player variable, from an arguement in a function, but auto completion doesnt know, so if you do:
function test(player: Player)
-- or
local player : Player
auto correction will tell you the properties and functions.
Frameworks
Learn simple, like how does a framework scales your game easily. Frameworks arent used on all games, as they arent needed in games, but are nice to have if you plan to have a game that you can easily add more content. you can learn to use knit or others, you can even create your own simple, its not that hard at first.
Networking & Optimizing
Its important to know how sending or spamming remote events or sending large amount of data takes space, in this case, its good to know some modules that handle this better than roblox itself. such as remote events module. Another big issue is that you dont clean up connections, which cause a memory leak, which is a big issue that scripters dont really think at first. In this case we have modules like trove, or maid, which excel in this.
Outside of roblox studio editor
You should try to learn atleast how to use vs code using rojo, argon, and github. This helps you with external good tools such as selene (linter), and wally (package manager). This isn’t needed, but it doesnt hurt to try it out, at the end of the day if you dont like it you can always go back to roblox editor.
Algebra
Most important one. You can build most stuff, but the hardest is math. For example, adding a vector to a cframe, calculating the projectory, etc. This is always important as i, myself, lack math knowledge which i 100% would agree would really help me in video game development.
Thats all, most stuff are well explained by @avodey
Firstly, forget about labels and trying to put programming concepts into absolute tiers is pretty meaningless, it’s all highly subjective and relative to one’s own experience.
Secondly, it’s pointless to ask people what you should learn without saying anything about what you’re trying to make. Making and publishing a complete game is very different from writing an open-source game framework or UI framework, which is very different again from making tooling like plugins for Studio.
Based on your list of topics, you seem to equate “advanced scripting” with code architectures and design patterns. I’d argue that if your goal is to make a game, there are more important things to focus on. Neither of your lists–what you understand and what you don’t–have any game programming fundamentals. Experienced game programmers have knowledge of:
Physics and constraints: Rigid body physics, tuning vehicles, code collision detection, spatial partitioning, ray and shape casting, spring-mass systems, PID controllers.
Entity control: state machines, behavior trees, pathfinding and autonomous navigation
Math: matrix and vectors, basic linear algebra, understanding second-order ODEs
Animation coding: Forward and Inverse kinematics, blending orientations, path generation.
Terrain and environment coding: Terrain generation, voxelization, procedural and modular map creation, and all of the underlying statistical methods used for generating and placing environment features.
Computational geometry, mesh generation and editing, texture projection, mapping and unwrapping, skinning, etc.
Client-server systems: latency compensation, server authority and server validation, exploit mitigation.
User data management: Datastores, serializing state and external (non-Roblox server) data stores and backups, collecting metrics and communicating with analytics services.
Basic data structures: searching, sorting, tree-traversal, graph theory.
I could go on and on. There are lots of things useful to learn about for game programming, and I’d honestly put things like promises and custom class frameworks pretty low on the priority list. Like “might never get to” level of low, or “learn about this when [poor] performance of my game forces me to” level.
I’m very much in favor of letting what you want to make guide what you need to learn. My process is something like:
Envision the game you want to make (or framework, plugin, game subsystem, etc)
Try to make it, as close as you can get to your vision.
Make note of what features you wanted to make, but couldn’t because of lack of know-how.
Identify performance issues and areas where your game needs improvement
Come back to these forums and ask very specific, pointed questions about how you can improve the shortcomings you identified in steps 3 and 4.
Learn about techniques that will help you make what you envisioned, or make your existing game better.
Basically, once you have a working game, it will be more clear to you what you were not able to do, or where you weren’t able to get the performance you wanted.
learn how big companies code on ROBLOX (search this on YT), you’d start seeing rojo, visual studio code, and a whole another ecosystem that is far more superior at raw coding workflow to a point where it’s not even comparable.
learn coding patterns. SOLID principle, common code smells, pub/sub pattern, etc. coding pattern goes far beyond “just organizing code”.
learn optimization techniques, like decreasing O(N) complexity, parallel LuaU, and things like this.
This is beginner, but you also probably don’t actually understand them considering you use modules / metatables
Bad
Somehow one of the worst on this list
Nevermind
ROBLOX HACK: Use Table And Function! Or even just function in like 99% of cases!
-- Debloated table version
local callbacks = {}
local function on(callback)
callbacks[callback = true
end
local function fire(...)
for callback in callbacks do
task.spawn(callback, ...)
end
end
-- Debloated 1-function version
-- binding
local function doSomething(x)
print(x)
end
-- firing
doSomething "foo"
Ew
Dude, it’s not 2019, might shock you but writing bad code is considered bad practice these days
Ironically, 99% of the things on this list are extremely UNOPTIMIZED & slow!
You should be making a game, or something else that actually gives you experience. Repeat this process again and again and again and again until you are experienced and know what you’re doing and know how to make a game. By this point you would know how to optimize your game
An intermediate—no, beginner scripter chases OOP and metatables while an advanced one doesn’t worry about anything and just makes their game
