<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Uche Uche-Ike on Medium]]></title>
        <description><![CDATA[Stories by Uche Uche-Ike on Medium]]></description>
        <link>https://medium.com/@ucheikeuchechukwu?source=rss-825879431f55------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*v_RXN4foNFoVwHcwGyCQmQ.jpeg</url>
            <title>Stories by Uche Uche-Ike on Medium</title>
            <link>https://medium.com/@ucheikeuchechukwu?source=rss-825879431f55------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 11:46:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ucheikeuchechukwu/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Making Mega Man Controls in Roblox]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/making-mega-man-controls-in-roblox-a2ff1bb33b69?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2ff1bb33b69</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[roblox]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Thu, 19 Nov 2026 17:01:02 GMT</pubDate>
            <atom:updated>2026-11-19T17:01:02.405Z</atom:updated>
            <content:encoded><![CDATA[<h3>Overview</h3><p>The Mega Man X series is one of my favourite game franchises ever. Since I started playing around with Roblox Studio recently, I’ve wanted to challenge myself to bring the feel of the Mega Man X games to Roblox — porting its physics, controls, and feel into the Roblox engine with as few compromises as possible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5TPk5CjC-QDcGPykSoxmQw.png" /></figure><p>Enter RKMNController, my custom Roblox module that recreates Mega Man X–styled movement through its own physics simulation and input controls. Building RKMNController and learning how to handle 2D physics controls has easily been one of the most fulfilling projects I’ve worked on in a while. So strap in as I take you on a journey on how I turned RKMNController into a reality.</p><p>I’m getting a bit ahead of myself, though. Before diving into implementation, I had to define RKMNController’s requirements. And before I could answer that, I needed to ask myself an even more fundamental question: what does Mega Man X <em>feel </em>like?</p><h3>What does Mega Man X feel like?</h3><p>Anyone who played the games would probably tell you: responsive controls; lightweight, expressive movement; intense boss fights; tough platforming. For the sake of RKMNController, I wanted to strip away all of the extra fluff and focus on a minimum viable product. I wanted to make a demo with all the core movement mechanics and physics.</p><p>That gave me a starting point, but “lightweight” and “responsive” aren’t exactly precise enough requirements to implement. I needed to describe what happens when the player presses a button, releases it, or combines one action with another. With that thinking in mind, I categorised the system requirements into three sections: movement mechanics, shared movement rules, and input requirements. Let’s dive into each in more detail.</p><h3>Movement Mechanics:</h3><p>RKMNController must support all core movement mechanics from the Mega Man X games, including: walking, jumping, dashing, wall sliding, and wall jumping. These mechanics interact with one another and can also be cancelled. Here’s the rundown.</p><iframe src="https://flo.uri.sh/visualisation/30964578/embed" width="700" height="575" frameborder="0" scrolling="no"><a href="https://medium.com/media/126d30cacf5c88b6b22d3faaabe01783/href">https://medium.com/media/126d30cacf5c88b6b22d3faaabe01783/href</a></iframe><p>The “walking” and “jumping” mechanics are just what you’d expect from a 2D platformer. The other mechanics are where things get more interesting, especially the dash mechanic!</p><p>In the Mega Man X games, players can press the dash button to move rapidly in a specific direction — either left or right horizontally — for a duration. The player can cancel their dash by releasing the dash button early.</p><p>Dashing has one more quirk: a player can jump mid-dash to convert it into a dash jump! During a dash jump, the player keeps the “momentum” from their dash, so in a dash jump, the player still moves quickly.</p><p>From those requirements, RKMNController needs some mechanism for knowing when the player is in the middle of a dash, as well as how much duration the dash has left. RKMNController will also need to keep track of when the player jump from a dash.</p><p>Wall Sliding is another tricky mechanic. The player initiates a wall slide when moving towards the wall while in freefall. During the wall slide, their fall speed is temporarily decreased. The player can also cancel the wall slide by moving away from the wall or letting go of the directional buttons.</p><p>The player can also <strong>wall jump</strong> by jumping mid-wall-slide. Like the dash jump we discussed before, the player can also <strong>wall dash jump</strong> (try saying that three times fast) by pressing the dash button and the jump button simultaneously while wall sliding.</p><p>From our wall slide requirements, we’d similarly need some mechanism in RKMNController to determine when the player is moving towards the wall and a mechanism to control their fall speed.</p><h3>Shared Movement Rules</h3><p>Shared Movement Rules is my catch-all term for general movement features RKMNController needs to support. Firstly, players need complete control of their character; this means changing movement direction on a whim or drifting mid-air. Roblox doesn’t make this easy. Out of the box, its physics engine supports its own acceleration, friction, and gravity logic — but these implementations hinder our intended behaviour, so RKMNController needs to calculate and apply its own physics. Here are the requirements we need to meet:</p><iframe src="https://flo.uri.sh/visualisation/30964600/embed" width="700" height="575" frameborder="0" scrolling="no"><a href="https://medium.com/media/3c755784c42005a23b1fe8574db42b90/href">https://medium.com/media/3c755784c42005a23b1fe8574db42b90/href</a></iframe><p>The Direction Control, Input Release, and Movement Plane requirements all mean we need to implement custom Physics Resolution logic in RKMNController to support.</p><p>Coyote time is a bit more interesting. For the uninitiated, coyote time is a platformer quirk that enables players to jump for a brief period after walking off a ledge.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*KkM3E7l0AHp5Ss_e.jpg" /></figure><p>It’s like a grace period for inputting the jump command in tough platforming situations. Like the dash mechanic from before, we’d need some kind of timer to track of coyote time as they walk off a ledge.</p><h3>Input Requirements</h3><p>While not strictly required to emulate Mega Man X’s physics in Roblox, I reasoned building robust player input handling would be a worthwhile venture. Roblox supports three main platforms: PC, mobile, and console — each platform has its own unique control scheme: keyboard and mouse for PC; touch screen for mobile; and gamepad for console. RKMNController will need to support all three of these platforms.</p><h3>System Boundaries</h3><p>Wow. That’s a lot of requirements! RKMNController needs to do a lot, and the biggest struggle is defining a concise set of classes that is powerful enough to meet our requirements but simple enough to understand, extend, and test. Where there’s a will, there’s a way; here’s the system design I came up with:</p><h3>Timer Registry</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uZ-tVch-jNjNfaC6FPw2Fg.png" /></figure><p>The Timer Registry maintains a list of active timers. It exposes an interface for registering a timer, clocking the timers down, and getting the duration for a timer. This class is useful for tracking all of the time-based functions of RKMNController we mentioned previously, like Coyote Time and the dash duration.</p><h3>Player Input Handler</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KnYl4S_M4B3_-ruJpoG9SA.png" /></figure><p>RKMNController is meant to support different types of user input, including keyboard, gamepad, or touch screen. Player Input Handler translates raw controller input from these devices into discrete flags and signals that other systems can query for. For example: the player’s current movement direction; when the player jumped or dashed. It also exposes an API for disabling gameplay inputs when the game is paused.</p><h3>Collision Query</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q8__td_zRwHjCu2n1oM27Q.png" /></figure><p>RKMNController defines custom collision logic with the world. Collision Query is a utility class that exposes an API for querying the player’s character for collisions: whether the player is grounded, if they can move a certain direction, whether they are standing on a floor, touching a wall, etc.</p><h3>Physics Resolver</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5HjAC8XNDUCGFBYT64GukQ.png" /></figure><p>The Physics Resolver overrides Roblox’s traditional physics simulation and exposes an API for other modules to modify the player’s velocity. On each frame, it polls the Collision Query, the player’s gravity, and the player’s current velocity to calculate the player’s new position and velocity.</p><h3>Movement State Machine</h3><p>Certain actions like dashing, jumping, etc. can only be performed when the user is in certain states, so RKMNController needs to support transition logic between different user states. The Movement State Machine manages the current state the player is in and houses the per-state logic of the player. The state machine also fires an event whenever the user state changes.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*NgQlO9LzYf85aHRisp4S7g.png" /></figure><iframe src="https://flo.uri.sh/visualisation/30964761/embed" width="700" height="575" frameborder="0" scrolling="no"><a href="https://medium.com/media/05e77ba53656a4436f4c48e543baa631/href">https://medium.com/media/05e77ba53656a4436f4c48e543baa631/href</a></iframe><h3>Animation Controller</h3><p>The animation controller handles the visual aspects of the player’s state changes. It listens to state changes from the Movement State Machine and plays a new animation on the player’s character.</p><h3>Pipeline End-to-End</h3><p>Now we’ll take a look at how RKMNController works end-to-end.</p><p>For the sake of simplicity, we’ll look at single interaction: moving the player to the right from standstill.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IrchxXwsiAJaLvtVMxHEMQ.png" /></figure><p>The core functionality is driven by the <strong>Movement State Machine</strong> and <strong>Physics Resolver</strong>. The player begins the flow in the Idle state. Upon pressing the right button on their controller, the Input Handler sets the player’s movement direction to the right. The movement state machine checks the user’s current movement direction, notices the player is moving to the right and tells the Physics Resolver to add a horizontal velocity to the player. Inside the Physics Resolver itself. it checks if the player is currently grounded using the Collision Query, and then evaluates the player’s new position and velocity. Since the player is now moving horizontally, the player transitions from the Idle state to the Walking state in the Movement State Machine.</p><h3>Conclusion/Next Steps</h3><p>And that’s RKMNController’s system requirements all laid out! Hopefully the Pipeline section gave you a satisfying taste of the thought put into even the most minute interaction in RKMNController. In my next article, I would like to go into more depth on the implementation and engineering decisions behind each of RKMNController’s components. Until then, do take care!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2ff1bb33b69" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Emulating Object Oriented Programming in Roblox Development]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/emulating-object-oriented-programming-in-roblox-development-ca6e37201141?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/ca6e37201141</guid>
            <category><![CDATA[lua]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <category><![CDATA[roblox]]></category>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 17:01:04 GMT</pubDate>
            <atom:updated>2026-11-05T17:01:04.259Z</atom:updated>
            <content:encoded><![CDATA[<p>For the past several weeks, I’ve been diving back into Roblox development, and reacclimating myself has been a blast, to say the least.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gVNuki9Uspo6nfToc_V5gw.png" /><figcaption>Thumbnail Image of Marble Statue &amp; Luau logo</figcaption></figure><p>I’ve had the most fun relearning Object-Oriented Programming (OOP) in Luau — or rather, the lack of it. Luau has a barebones syntax and no traditional class setup, but we can emulate OOP patterns using techniques that we’ll discuss.</p><p>The more interesting challenge is making those designs understandable and easy to debug. Recently, Roblox introduced <strong>strict type checking</strong>. Strict means the Luau type checker automatically tracks value types and flags type errors as we write code.</p><pre>--!strict  --required at the top of the script!<br>local function deposit(balance: number, amount: number): number<br>    return balance + amount<br>end<br><br>print(deposit(100, 20)) <br>print(deposit(&quot;100&quot;, 20)) -- this gets flagged in the editor!</pre><p>This, combined with type references, makes it very easy to catch mistakes in the editor before they become runtime errors.</p><p>Which is a nice segue to the topic of today:</p><p><em>How do we build classes that are easy to reuse, understand, and catch mistakes in a language without built-in class syntax?</em></p><p>But before we do all that, we need to understand how we write OOP classes in Luau.</p><h3>It’s Tables All The Way Up</h3><p>This is going to be a long one, so we’ll start nice and easy. Here’s Roblox’s <a href="https://luau.org/types/object-oriented-programs/">canonical OOP example</a> without strict typing or type references.</p><pre>local Account = {}<br>Account.__index = Account<br><br>function Account.new(name, balance)<br>    local self = {}<br>    self.name = name<br>    self.balance = balance<br><br>    return setmetatable(self, Account)<br>end<br><br>function Account:Deposit(amount)<br>    self.balance = self.balance + amount<br>end<br><br>local account = Account.new(&quot;John Doe&quot;, 500)</pre><p>That’s a lot of boilerplate. Let’s break it down.</p><p>As mentioned before, Luau doesn’t have classes like traditional programming languages like Python. <strong>Tables</strong> are the main data object for anything and everything.</p><p>Tables are most similar to hash maps in traditional languages. If you’re familiar with Python, Luau’s syntax is shockingly similar!</p><pre>local Account = {<br>    name = &quot;John Doe&quot;,<br>    balance = 100,<br>}<br><br>-- Inserts a new key-value pair using bracket notation<br>Account[&quot;balance&quot;] = 150<br>-- Alternatively, we can use dot notation<br>Account.name = &quot;Jane Doe&quot;</pre><p>In Luau, functions are <strong>first-class citizens</strong>, meaning you can assign them to variables.</p><pre>local balance = 100<br><br>local deposit = function(amount)<br>  balance = balance + amount<br>end</pre><p>Or you can even….</p><pre>local balance = 100<br><br>local Account = {<br>  deposit = function(amount)<br>    balance = balance + amount<br>  end<br>}</pre><p>…add a function to a table!</p><p>We add functions and values to tables to create rudimentary classes in Luau.</p><pre>local Account = {<br>    name = &quot;John Doe&quot;,<br>    balance = 100,<br>    deposit = function(self, amount)<br>      self.balance = self.balance + amount<br>    end<br>}</pre><p>The <strong>self</strong> parameter refers to the original table, so the deposit function here updates the value of balance in the Account table.</p><p>If you’ve ever written in Python, it’s basically the same as the keyword <strong>self.</strong></p><pre>class Account:<br>  def __init__(self):<br>    self.name = &quot;John Doe&quot;<br>    self.balance = 0<br>  def deposit(self, amount):<br>    self.balance += amount</pre><p>So now we have a basic Account class with member variables and methods, but no easy way to create instances of it.</p><pre>local Account = {<br>    name = &quot;John Doe&quot;,<br>    balance = 100,<br>    deposit = function(self, amount)<br>      self.balance = self.balance + amount<br>    end<br>}<br><br>print(Account.name) -- prints &quot;John Doe&quot;<br>Account.deposit(100)<br>print(Account.balance) -- prints 200</pre><p>We take this setup a step further and define a dedicated constructor function that creates new instances of our Account class.</p><pre>local function accountConstructor(newName)<br>  local Account = {<br>    name = newName,<br>    balance = 100,<br>    deposit = function(self, amount)<br>      self.balance = self.balance + amount<br>    end<br>  }<br>  return Account<br>end</pre><p>Now we can have easily create multiple independent instances of our Account class</p><pre>local johnAccount = accountConstructor(&quot;John&quot;)<br>local janeAccount = accountConstructor(&quot;Jane&quot;)<br><br>johnAccount:deposit(100)<br><br>print(johnAccount.balance) -- 100<br>print(janeAccount.balance) -- 0</pre><p>Each account owns its own balance. Depositing into John’s account doesn’t affect Jane’s.</p><p>And this approach works… <em>somewhat.</em> The major problem with this is our deposit method. Every time we call the accountConstructor, we create a new functionally identical instance of the deposit function.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*FPModW9_Q6zdbZSg8zTUlA.png" /><figcaption>Diagram of Account Instances and Deposit Functions</figcaption></figure><p>As our programs scales and we create hundreds of Account instances, this becomes a huge waste of resources. It’d be much more efficient to define the function once and have all instances of our class use it. Now, if only there were a way…</p><h3>Metatables</h3><p><a href="https://www.lua.org/pil/13.html">Metatables</a> are tables that contain <a href="https://create.roblox.com/docs/luau/metatables#metamethods">Metamethods</a>. Metamethods are special functions that are invoked when a certain action is performed on a table. The full list of metamethods is listed <a href="https://create.roblox.com/docs/luau/metatables#metamethods">here</a> — they’re all super cool!</p><p>The most important one for our case is __index(table, index), which affects how indexing is resolved on a table.</p><p>Simply put, if we try to access a value from the table and it isn’t present, we check whatever table is set as the index for that value.</p><pre>local BaseAccount = {<br>  currency = &quot;USD&quot;<br>}<br><br>local UserAccount = {}<br>local metatable = {__index = BaseAccount}<br><br>print(UserAccount[&quot;currency&quot;]) -- prints nil<br>setmetatable(UserAccount, metatable)<br>print(UserAccount[&quot;currency&quot;])</pre><p>Ordinarily, our attempt to access the currency key in UserAccount would fail, but since we’ve defined a metatable, any index to the UserAccount table first checks the UserAccount table itself, then the BaseAccount table!</p><p>Now let’s circle back to our class implementation. Let’s use this same concept to avoid the multiple function issue we referenced before: we’ll create separate table that houses all of our class methods.</p><pre>local AccountMethods = {<br>    deposit = function(self, amount)<br>      self.balance = self.balance + amount<br>    end<br>}<br><br>function accountConstructor(value: number)<br>  local Account = {<br>    name = newName,<br>    balance = 0<br>  }<br>  setmetatable(Account, {__index = AccountMethods})<br>  return Account<br>end</pre><p>Now we can use all the methods of our Account and we only have to define them once!</p><pre>local johnAccount = accountConstructor(&quot;John&quot;)<br>local janeAccount = accountConstructor(&quot;Jane&quot;)<br><br>johnAccount:deposit(100)<br><br>print(johnAccount.balance) -- 100<br>print(janeAccount.balance) -- 0<br><br>print(johnAccount.deposit == janeAccount.deposit) -- true</pre><p>The balances belong to each account, while the deposit is resolved through the shared method table. We’ve separated instance data from shared methods.</p><h3>Back to Accounting</h3><p>Now that we’ve completed our training, the Roblox’s example Account class should make a lot more sense.</p><pre>local Account = {}<br>Account.__index = Account<br><br>function Account.new(name, balance)<br>    local self = {}<br>    self.name = name<br>    self.balance = balance<br><br>    return setmetatable(self, Account)<br>end<br><br>function Account.deposit(self, amount)<br>    self.balance += amount<br>end<br><br>local account = Account.new(&quot;Alexander&quot;, 500)</pre><p>Like before, let’s break things down step by step</p><pre>local Account = {}</pre><p>The first Account table holds all the methods for our Account class.</p><pre>function Account.new(self, credit)</pre><p>function Account.new(name, balance) looks scary at first, but it’s just <strong>syntactic sugar</strong> — a simpler way of writing this:</p><pre>Account[&quot;new&quot;] = function(name, balance) <br>  -- Create the new account<br>end<br><br>-- alternatively, we can write..<br><br>Account.new = function(name, balance)<br>  --Create the new account<br>end</pre><p>With our knowledge in mind, deciphering this constructor (new) is a piece of cake.</p><pre>local Account = {}<br><br>function Account.new(name, balance)<br>    local self = {}<br>    self.name = name<br>    self.balance = balance<br><br>    return setmetatable(self, Account)<br>end</pre><p>We first create a new table called self; it contains all the member variables unique to this account instance, such as the name and balance.</p><p>We finally set the metatable of self to be the Account table. To reiterate, the Account table’s main purpose is for handling methods specific to this class.</p><blockquote>One small wrinkle readers may have noticed is that we defined our metamethods and the class methods in the same Accounts table; whereas in our previous examples, we kept the metamethods and class methods in separate tables. Both approaches are functionally identical.</blockquote><p>Especially eagle-eyed readers might notice that this pattern is effectively identical to the <a href="https://en.wikipedia.org/wiki/Prototype-based_programming">Prototypal Inheritance</a> you’ll find in JavaScript.</p><figure><img alt="A Diagram of the Prototype Pattern. With a Class on the left with several methods connected to a Data Instance with several Fields. This highlights the separation of data and functionality in the prototype." src="https://cdn-images-1.medium.com/max/1024/1*UUJEyAJ5e8Ul1N4GAXUupQ.png" /><figcaption>Diagram of Prototypal Inheritance Pattern</figcaption></figure><p>The Account table is the <strong>prototype</strong> that exposes a method new to make new instances of it. self is the <strong>data instance</strong>.</p><p>From here on out, I’ll refer to the table containing all the methods as a <em>Prototype</em> and the individual instance of the class with all the member variables as the <em>Data</em> Instance.</p><h3>Describing Classes with Types</h3><p>That was one hell of a background, but hopefully all this context makes things make a bit more sense when we introduce strict typing and type references. Here’s <a href="https://luau.org/types/object-oriented-programs/#_top">Account example</a> from Roblox’s official docs but with strict typing.</p><pre>local Account = {}<br>Account.__index = Account<br><br>type AccountData = {<br>    name: string,<br>    balance: number,<br>}<br><br>export type Account = typeof(setmetatable({} :: AccountData, Account))<br><br>function Account.new(name, balance): Account<br>    local self = {}<br>    self.name = name<br>    self.balance = balance<br><br>    return setmetatable(self, Account)<br>end<br><br>function Account.deposit(self: Account, amount: number): ()<br>    self.balance += amount<br>end</pre><p>It’s largely the same as the Account class we looked at just a second prior. The most notable thing is the new type declaration we made for Account.</p><pre>type AccountData = {<br>    name: string,<br>    balance: number,<br>}<br><br>export type Account = typeof(setmetatable({} :: AccountData, Account))</pre><p>Here, the AccountData type refers to the contents of our Data Instance; that’s what self refers to inside the constructor. self’s metatable points to the table Account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mZjArMQOdY2Bvt5YaLoaXA.png" /></figure><p>A subtle different you probably didn’t notice is that all the methods in the strict-typing version of the Account class are made using dot-notation.</p><pre>--!strict<br>function Account.deposit(self: Account, amount: number): ()<br>    self.balance += amount<br>end</pre><p>Whereas in the non-strict typing version, we used colon notation. Colon notation is syntactic sugar for dot notation. The main difference is that with Colon notation, the self parameter is added implicitly.</p><pre>function Account:deposit(credit) -- self is an implicit parameter here<br>    -- can still access self, even though its not declared as a parameter<br>    self.balance += credit<br>end</pre><p>Using dot notation, we can add a type reference to self and enforce the strict typing check on whatever member variables or class functions we use in the method.</p><pre>function Account.deposit(self: Account, amount: number): ()<br>    -- Works fine!<br>    self.balance += amount<br>    -- Shows error in editor<br>    self.account_type = &quot;Savings&quot;<br>end</pre><p>Whereas without strict typing, we could easily overlook this mistake.</p><h3>Making the Pattern My Own</h3><p>Since reacclimating into Roblox development, I’ve made my current style a mixture of my own preferences alongside some tricks I found by other Luau developers.</p><p>Here’s the set up for the Account class implementation again in my style.</p><pre>local AccountPrototype = {}<br>AccountPrototype.ClassName = &quot;Account&quot;<br>AccountPrototype.__index = AccountPrototype<br><br>type AccountData = {<br>  name: string,<br>  balance: number,<br> }<br><br>type AccountPrototype = typeof({ __index = AccountPrototype })<br><br>export type Account = typeof(setmetatable(<br> {} :: AccountData,<br> {} :: AccountPrototype<br>))<br><br>-- Class Methods here are largely unchanged<br><br>function AccountPrototype.Destroy(self: Account): ()<br>    setmetatable(self :: any, nil)<br>    table.freeze(self)<br>end<br><br>table.freeze(AccountPrototype)</pre><p>Let’s break it down.</p><p>The first things that probably catches your eye is that I don’t name the table with the class methods “Account”. Rather, I mimic the naming convention of the Prototype pattern I mentioned a second ago. AccountPrototype for the table that store class methods and AccountData for the table that stores class member variables. I find these names useful because they make the distinction between stored data and shared methods explicit.</p><pre>local AccountPrototype = {}<br>AccountPrototype.ClassName = &quot;Account&quot;</pre><p>The next thing that probably catches your eye is fields ClassName. Since Lua has no compile time type-checking, giving each class an explicitClassName field makes it possible validate classes at runtime.</p><pre>--!strict <br>local function isAnAccount(object: {any})<br>  return (object.ClassName == &quot;Account&quot;)<br>end<br><br>function Bank.RegisterAccount(self: Bank, account: Account)<br>  -- Code crashes immediately if the account argument isn&#39;t valid<br>  assert(isAnAccount(account), &quot;\&quot;account\&quot; argument must be an instance of Account class&quot;)<br>  -- Registration logic here...<br>end</pre><p>Finally, there’s the logic for destroying the class.</p><pre>--!strict<br>function Account.Destroy(self: Account): ()<br>    setmetatable(self :: any, nil)<br>    table.freeze(self)<br>end</pre><p>I like to create a destroy method with three essential steps:</p><p>Removing the metatable prevents the instance from finding methods through its prototype. Freezing the table prevents further changes to its fields.</p><pre>local johnAccount = Account.new(&quot;John Doe&quot;)<br>johnAccount:Destroy()<br><br>johnAccount.deposit(100) -- Error<br>johnAccount.name = &quot;Jack&quot; -- Error </pre><p>Both these actions mean that once destroyed an Account instance is effectively useless.</p><h3>Programming to an Interface</h3><p>So far, our systems have known exactly what kind of account they’re working with.</p><p>But often, a system doesn’t need to know the specific class. A reward system, for example, might only care that it has something with a Deposit method.</p><p>That’s where interfaces come in. Instead of describing one particular class, an interface describes the methods another system can rely on.</p><p>In traditional languages, we may declare a class as an <strong>Interface</strong> or define <strong>Abstract </strong>methods.</p><pre>from abc import ABC, abstractmethod<br><br>class DepositAccount(ABC):<br>    @abstractmethod<br>    def deposit(self, amount: float):<br>        pass<br><br>class Account(DepositAccount):<br>    def __init__(self):<br>        self.deposit = 0<br>    def deposit(self, amount: float) -&gt; bool:<br>        self.deposit += amount</pre><p>In Luau, there’s no pecial keyword for interfaces. We define a type that describes the shape another object needs to have.</p><pre>export type DepositAccountInterface = {<br>    Deposit: (self: DepositAccountInterface, amount: number) -&gt; (),<br>}</pre><pre>local function awardWelcomeBonus(account: DepositAccountInterface)<br>    account:Deposit(100)<br>end</pre><p>The payoff is that any class can satisfy this contract, as long as they provide a compatible Deposit method.</p><p>When creating classes that implements this interface, we can create an intersection between the type and the class type.</p><pre>local AccountPrototype = {}<br>AccountPrototype.ClassName = &quot;Account&quot;<br><br><br>export type Account = typeof(setmetatable(<br> {} :: AccountData,<br> {} :: (AccountPrototype &amp; DepositAccountInterface)<br>))</pre><pre>awardWelcomeBonus(AccountPrototype.new(&quot;John&quot;, 0))</pre><p>We use an intersection type to say that AccountPrototype must provide both its own methods and everything required by DepositAccountInterface.</p><pre>//.. Account boilerplate<br><br>function AccountPrototype.new(name, balance): Account<br>    local self = {}<br>    self.name = name<br>    self.balance = balance<br>    <br>    // Error here: Account instance is missing deposit method<br>    return setmetatable(self, Account)<br>end</pre><p>Now unless we define the deposit method, we’ll see a strict typing error in our constructor method.</p><h3>Specialising with Inheritance</h3><p>Let’s define a SavingsAccount class as a subclass of Account.</p><pre>local SavingsAccountPrototype = {}<br>SavingsAccountPrototype.Super = Account<br>SavingsAccountPrototype.ClassName = &quot;SavingsAccount&quot;<br><br>setmetatable(SavingsAccountPrototype, { __index = AccountPrototype })<br>SavingsAccountPrototype.__index = SavingsAccountPrototype<br><br>type SavingsAccountData = AccountData &amp; {<br>  interestRate: number,<br>}<br><br>type SavingsAccountPrototype = typeof({ __index = SavingsAccountPrototype })<br><br>export type SavingsAccount = typeof(setmetatable(<br>  {} :: SavingsAccountData,<br>  {} :: SavingsAccountPrototype<br>))</pre><p>The set up is similar to the Account we looked at a second ago with three key differences.</p><pre>setmetatable(SavingsAccountPrototype, { __index = AccountPrototype })</pre><p>We create an anonymous table with the __index set asAccountPrototype . And set SavingsAccountPrototype’s metatable to be that anonymous table. This sets up a chain between the two prototypes that instances of SavingsAccount follow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vv3aBbaiNRL4oTL53itkBg.png" /></figure><p>For any field thats not present in the SavingsAccountData, we check SavingsAccountPrototype and then AccountPrototype. This set up effectively simulates inheritance properties like method overriding.</p><pre>type SavingsAccountData = AccountData &amp; {<br>  interestRate: number,<br>}</pre><p>We define the type of SavingsAccountData to be the intersection of its member variables and AccountData’s member variables (that’s why separating them is useful!). So our new SavingsAccountData class has the same member variables as AccountData plus the new interestRate field.</p><pre>--!strict<br><br>function SavingsAccountPrototype.applyInterest(self: SavingsAccountPrototype): ()<br>  -- No type check error on &quot;balance&quot;<br>  local interestAccumulated = self.balance * self.interestRate<br>  -- No type check error on &quot;deposit&quot;<br>  self:deposit(interestAccumulated)<br>end<br><br>local savings = SavingsAccountPrototype.new(&quot;Jane&quot;, 1000, 0.05)<br><br>savings:Deposit(200)<br>savings:ApplyInterest()<br><br>print(savings.balance) -- 1260</pre><p>Deposit is not defined on SavingsAccountPrototype, so Luau finds it through the prototype chain. ApplyInterest is defined on the savings prototype and uses that inherited method.</p><h4>Explicit Parent Access</h4><pre>SavingsAccountPrototype.Super = Account<br>--...<br><br>function SavingsAccountPrototype.new(name: string, initial_balance: number, interestRate: number): SavingsAccount<br>  local self = self.Super.new(name, initial_balance)<br>  self.interestRate = interestRate<br>  setmetatable(self, SavingsAccountPrototype)<br>  <br>  return self<br>end</pre><p>Near the top of the file, we define the Super , the parent class, of SavingsAccountPrototype to be AccountPrototype .</p><p>We could alternatively just call using AccountPrototype table, but I find that this way makes it more obvious that the function call is meant to call the parent class’ constructor.</p><h4>Class Validation With Inheritance</h4><p>You may recall that for my Account class I suggested adding a special ClassName field.</p><pre>AccountPrototype.ClassName = &quot;Account&quot;</pre><p>We could add a new case to the isAnAccount function we made earlier..</p><pre>function isAnAccount(self: Account):<br>  return self.ClassName == &quot;Account&quot; or self.ClassName == &quot;SavingsAccount&quot;</pre><p>But it scales poorly and separates the class inheritance logic from the class definition. I’m not a fan of it.</p><p>Alternatively, we can define an IsA() method for all classes</p><pre>--!strict<br><br>function AccountPrototype.IsA(self: AccountPrototype, className: string): boolean<br> local currentClass = getmetatable(self) or self<br> <br>  while currentClass do<br>    if currentClass.ClassName == className then<br>        return true<br>    end<br>  <br>    currentClass = getmetatable(currentClass)<br>    local isAClass: boolean = type(currentClass) == &quot;table&quot; and currentClass.__index<br>    if isAClass then<br>      currentClass = currentClass.__index<br>    else<br>      break<br>    end<br>  end<br> <br>  return false<br>end</pre><p>For all our Account related validation checks, we can just verify whether the class is an “Account”.</p><pre>function Bank.RegisterAccount(self: Bank, account: Account)<br>  -- Works for both SavingsAccounts and regular Accounts<br>  assert(account:IsA(&quot;Account&quot;), &quot;\&quot;account\&quot; argument must be an instance of Account class&quot;)<br>  -- Registration logic here...<br>end</pre><h3>Conclusion</h3><p>Relearning about Object Oriented Programming in Roblox Studio has easily been the most enjoyable part of me returning to the platform. Coming from more traditional programming languages makes you take Class implementations for granted, and having to think critically about how to emulate those patterns in Luau has given me a newfound appreciation for OOP. I hope this article helps you better understand how classes, tables, work and how we can leverage OOP patterns to write more robust Luau code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ca6e37201141" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Research Study | Performance Telemetry]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/research-study-performance-telemetry-7dab5c8dd5e1?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/7dab5c8dd5e1</guid>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 16:31:01 GMT</pubDate>
            <atom:updated>2026-09-24T07:45:32.169Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>Traditional performance debugging tools show you when performance hiccups occur during playtests, but not where. I developed an Unreal Engine 5 (UE5) plugin, <em>Performance Telemetry, </em>that attached spatial context to performance data. As part of my master’s thesis at the University of Illinois Urbana-Champaign, I wanted to determine whether that spatial context actually changes how developers debug performance issues. In my previous three articles, I discussed <em>Performance Telemetry</em>’s <a href="https://medium.com/@ucheikeuchechukwu/why-performance-debugging-in-games-is-fundamentally-broken-0a01364902b3">problem statement</a>, <a href="https://medium.com/@ucheikeuchechukwu/designing-performance-telemetry-why-performance-debugging-in-games-is-fundamentally-broken-6d562d019175">design</a>, and <a href="https://medium.com/@ucheikeuchechukwu/how-i-built-performance-telemetry-for-ue5-why-performance-benchmarking-is-fundamentally-broken-f49c525c3d8d">implementation</a>. In this article, I want to walk you through the design of my user study.</p><p>To clearly define our research question, I wanted to investigate:</p><p><strong>Does adding spatial context to performance information make developers more efficient at debugging performance issues?</strong></p><p>I hypothesised that my plugin would streamline performance debugging. Developers would focus edits near observed performance hotspots, playtest more often and in shorter bursts, and make edits sooner after noticing issues. Ultimately, games built using the plugin would show measurable performance improvement over time.</p><h3>Study design overview</h3><p>Designing the user study was a deliberate process of maximising the validity of our study. We had eight subjects, sourced from students taking various game development-related courses at UIUC. All subjects would install <em>Performance Telemetry</em>, and the plugin would discreetly record user analytics for the study duration. We split the subjects into treatment and control groups: those in the treatment group received all the features of the plugin, and those in the control group had the features disabled. After two months, subjects concluded the study by completing a user survey discussing their experience.</p><p>With the plan formalised, it was time to settle on some metrics to test my hypothesis.</p><p>FPS is the de facto metric for gameplay performance, so that was an easy choice — the plugin should enable developers to improve the FPS of their game. Playtest duration and number of playtests fit naturally as well.</p><p>Measuring the effect of a playtest on debugging was a bit trickier. My first instinct was to measure the edits the user did immediately after a playtest, but we need to separate superficial changes like renaming a variable from performance-minded ones. But that begs that question..</p><p>What is a performance-minded edit?</p><p>I decided that blueprint edits, moving, or deleting actors from the level would count as a performance-minded edit. Because these types of edits directly change the number of objects the player has to render during playtests. A blueprint edit may use a more performant mesh, deleting an actor removes another element for the player to render.</p><p>My initial list of metrics looks like this:</p><ol><li>Average FPS</li><li>Average Number of playtests</li><li>Average Playtest duration (s)</li><li>Average Time to Performance-Minded Edit after playtest (s)</li></ol><p>— just one problem. I had to source our subjects from students using UE5 for coursework, meaning all the students were working on machines with different system specs, on differently scoped projects. I couldn’t take metrics like FPS at face value. So I changed the metrics to be <em>relative,</em> i.e. we looked at how performance <em>changed</em> over the duration of their project. We also decided to use the median values to avoid outliers skewing our results.</p><p>I finally settled on my user study metrics.</p><iframe src="https://flo.uri.sh/visualisation/30191300/embed" width="700" height="575" frameborder="0" scrolling="no"><a href="https://medium.com/media/85337b3c6707ccee0fe37911f139059d/href">https://medium.com/media/85337b3c6707ccee0fe37911f139059d/href</a></iframe><ol><li>Performance Change Over Project Duration (Delta FPS)</li><li>Median Number of Playtests</li><li>Median Playtest duration (s)</li><li>Median Time to Performance-Minded Edit after Playtest (s)</li></ol><h3>Measuring Metrics</h3><p>I mentioned in my <a href="https://medium.com/@ucheikeuchechukwu/how-i-built-performance-telemetry-for-ue5-why-performance-benchmarking-is-fundamentally-broken-f49c525c3d8d">implementation article</a>, that I’d discuss how we measure metrics in my research article. To give a brief recap, our plugin comprises four <strong>modules</strong> or subcomponents. Three of those modules implement <em>Performance Telemetry</em>’s core functionality; the final module, the <em>Metadata Module,</em> records user analytics.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*prE6uTJwPLFEjC76VKb3-g.png" /><figcaption>Metadata Module System Diagram</figcaption></figure><p>My plugin already logs telemetry data remotely in the <em>Runtime Module, </em>so recording the subject’s FPS over time is trivial; the Metadata Module needs to handle the other three metrics.</p><p>To track playtests, I created a <em>Session</em> class to represent a single playtest session. Each Session has a unique ID, a start and end time.</p><p>I then hooked my Metadata Logger to Unreal Engine 5’s lifecycle events so the logger would start and end a Session when the player started and ended a playtest, respectively.</p><p>To calculate the number of playtests, we can log every time a user creates a session. Likewise, to get the playtest duration, we can take the difference between the start and end of a session.</p><p>To measure Median Time to Performance-Minded Edit, I created an <em>Editor Action</em> class. It defined any action of interest our subject performed in the editor: adding an actor into the level, deleting an actor, moving an actor, editing a blueprint,</p><p>Each editor action has a timestamp and an associated session ID.</p><p>To calculate median time to a performance-minded edit, we subtract the timestamp of the associated session from the timestamp of the editor action.</p><h3>Measures and data collected</h3><iframe src="https://flo.uri.sh/visualisation/30194114/embed" width="700" height="575" frameborder="0" scrolling="no"><a href="https://medium.com/media/47dbfa4bfc160cc1edf6e8aedec420d6/href">https://medium.com/media/47dbfa4bfc160cc1edf6e8aedec420d6/href</a></iframe><p>The study had some unexpected results, to say the least. For our primary metric, gameplay performance over time, the treatment group had a lower mean FPS delta (-21.32) than the control group (37.16). Meaning students using the plugin’s features had <em>worse</em> gameplay performance over time than the control group. Ouch.</p><p>The other metrics followed the trend I hypothesised, however. The treatment group averaged more playtests (158.67) compared to the control group (82.67) and performed shorter playtests (59.7 s) compared to the control group (161.149 s). For performance relevant edits, the treatment group made more edits (228) compared to the control group, and the average distance of each edit to a performance hotspot was significantly closer (2570.654 Unreal Units [UU]) than the control group (3720.397 UU).</p><p>Overall, the results partially supported my hypothesis that adding location context to performance logs improves the debugging workflow. The treatment group exhibited more frequent playtesting, shorter playtest sessions, and greater spatial alignment between edits and observed performance hotspots, all of which are consistent with more focused debugging behaviour.</p><p>I figured the plugin’s features encouraged students to notice performance problems sooner in the development process — hence, the shorter, more frequent playtests.</p><h3>Limitations</h3><p>There are several things I would change given the chance to do this study again. The biggest problem was our inexperienced subject pool, many of whom worked on smaller-scale classroom projects. It’s the best our research team could scrounge together given time constraints, but I would love to see how behaviour would change with more experienced game developers working on larger, more collaborative projects.</p><p>Moreover, the study involved an experiment body using a variety of computers with different base performance, so we cannot directly compare the FPS of different subjects’ games. To compensate, we measure the relevant metrics as deltas instead of absolute values. If we could have all our subjects using identical machines, that would help reduce bias in our data.</p><p>Lastly, <em>Performance Telemetry</em> focused on a select subset of performance metrics like FPS and Memory Used, but did not include other relevant performance signals like GPU performance or in game streaming behaviour.</p><h3>Lessons learned and next steps</h3><p>Working on and running a user study for <em>Performance Telemetry</em> was an eye-opening experience. It was thoroughly enjoyable to dive into the world of performance profiling and try my hand in improving the workflow game developers go through. My biggest take away from working on this plugin was how unsolved the problem space still felt to me.</p><p>From reading the survey responses from subjects, I found that many of the features of the plugin weren’t immediately intuitive or actionable for developers. It also makes we wonder how could remake the plugin to support additional metrics or integration with existing profiling tools like <a href="https://dev.epicgames.com/documentation/unreal-engine/unreal-insights-in-unreal-engine?lang=en-US">Unreal Insights</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7dab5c8dd5e1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Core Principle Behind All of Game Design is Structured Uncertainty]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/the-core-principle-behind-all-of-game-design-is-structured-uncertainty-031eb0883e2e?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/031eb0883e2e</guid>
            <category><![CDATA[psychology]]></category>
            <category><![CDATA[game-design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[user-research]]></category>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 16:51:00 GMT</pubDate>
            <atom:updated>2026-09-02T16:51:00.917Z</atom:updated>
            <content:encoded><![CDATA[<h3>What makes games compelling?</h3><p>It’s <em>the</em> question that has teased game designers for ages.</p><p>Several designers have attempted to answer it, but these different viewpoints — called <strong>frameworks</strong> — are scattered across psychological, formal, and practitioner perspectives. In this article, I want to discuss several game design frameworks and synthesise them into one coherent idea.</p><p>My overarching thesis from these frameworks is that games are <strong>problem solving ventures</strong>. A game become compelling when it asks the player questions they cannot answer in a straight-forward way. As they play, the player acquires a sense of the game’s problem space, make plans, act them, and learn from the result. I call this idea <strong>structured uncertainty</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PM_cym5fFMJ3mlpwoUt_TA.jpeg" /></figure><h3>Let’s start at the very beginning…</h3><p>No conversation of game design frameworks would be complete without a mention of — arguably the most canonical game design lens — <em>Mechanics, Dynamics, and Aesthetics</em> (MDA). Introduced by Robin Hunicke et al, MDA comprises games into three connected layers.</p><ol><li><strong>Mechanics: </strong>The rules and components the designer creates</li><li><strong>Dynamics: </strong>The behaviors that emerge when players use those rules over time.</li><li><strong>Aesthetics: </strong>The emotional experiences the player has as a result</li></ol><p>As designers, we create our games from the mechanics, which in turn create dynamics, and finally create aesthetics.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EQVtbhFHe52iZ0Ou_n1RsA.png" /><figcaption>Mechanics into Dynamics intoAesthetics Flowchart</figcaption></figure><p>To help ground this idea, let’s take a mechanic like a Hadouken from Street Fighter.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*f4zeM13bsoAgij8y.jpg" /><figcaption>Ryu’s Hadouken in Street Fighter 6</figcaption></figure><p>The new pressure, punishment, and prediction games it enables are dynamics. The tension of committing to an unsafe attack is an aesthetic experience.</p><p>But as a player, we experience games the<em> </em>other way around.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y-W-IrUOOdVz3IqeiXreHg.png" /><figcaption>Aesthetics into Dynamics into Mechanics Flowchart</figcaption></figure><p>Players perceive games through how they <em>feel</em> first, notice the patterns of play that develop, and only later begin to understand the rules underneath.</p><p>With two layers of abstraction between the content we as designers make and what the player experiences, the question now arises: how should designers think when trying to create specific aesthetics in their games?</p><p>In this dilemma, looking at games as <strong>systems</strong> can offer an interesting alternative.</p><h3>Games as Systems</h3><p>Katie Salen Tekinbaş and Eric Zimmerman introduce the idea of games as <strong>systems</strong> in their book <em>Rules of Play: Game Design Fundamentals</em>. The duo defines a system as a set of interacting <strong>rules</strong>, <strong>objects</strong>, <strong>states</strong>, and <strong>player actions</strong>. While in MDA, we reason about games in terms of mechanics; in this system lens, the mechanics of the game are the system’s<strong> </strong><em>rules</em>.</p><p>These semantics are all fine and dandy, but what we really care about is how players interact with that system. Compelling games are systems where players engage in <strong>meaningful play</strong>.</p><p>Salen &amp; Zimmerman define meaningful play as “[what] emerges from the relationship between player action and system outcome”.</p><p>That definition is too jargony for my taste — so I describe it as what happens when a player explores the game’s possibility space. When engaged in meaningful play, a player should ask: “what did I do in the game?”; “what changed because of it?”; “why does that change matter?”</p><h3>Uncertainty Creates Space for Decisions</h3><p>But how do game systems create meaningful play?</p><p>Games create meaningful play through <strong>uncertainty</strong>. Uncertainty exists when players cannot reliably predict an action’s outcome from the rules of the game even though the rules themselves are clear. Players engage in meaningful play when they make consequential decisions in the game system under uncertainty<strong> </strong>and can learn from the outcomes.</p><p>Uncertainty manifests itself in many ways. Ryan Costikyan goes in depth about different sources of uncertainty in his book <em>Uncertainty in Games. </em>Here are just a few:</p><ul><li><strong>Performative uncertainty</strong><br>Can I execute the action successfully?</li><li><strong>Analytic complexity</strong><br>I know the rules, but can I predict what happens after a certain action?</li><li><strong>Player Unpredictability</strong><br>What will the other player do?</li></ul><p>Let’s analyse Tic-Tac-Toe through this system lens to see uncertainty in action. In Tic-Tac-Toe, player unpredictability and analytic complexity drive uncertainty. Every turn, each player leverages the current state of the board along with their opponent’s strategy to decide on a move. “Do I play aggressively and try to get three in a row?”; “do I play defensively and try to block off a row from my opponent?” These kinds of questions are what meaningful play is all about.</p><p>Tic-Tac-Toe shows how uncertainty can create meaningful play — and how a game becomes boring once that uncertainty is resolved.</p><p>Anyone who has played Tic-Tac-Toe enough knows about its optimal strategy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CQF59GTNWkX5QYiC.jpg" /><figcaption>How to always win at TicTacToe</figcaption></figure><p>High level Tic-Tac-Toe’s reduces to a meager flowchart where the first player can guarantee a victory/draw by taking a corner position on the first turn. The second player has to take the center position to force a draw or lose. Neither player’s <em>intent</em> matters much as there’s only one optimal course of action, so the expected outcome is a draw. Uncertainty disappears and along with it, meaningful play. The game is no longer compelling.</p><h3>Complex versus complicated</h3><p>Adding rules is one way to expand the possibility space of a game. More rules, more possibilities, more things for the player to juggle in their head sounds like a recipe for uncertainty.</p><p>It certainly can be.</p><p>But there’s such a thing as too much of a good thing.</p><p>Add too many rules, make your game too complicated, and you get the opposite problem. A game becomes difficult to engage with when players must spend too much attention decoding rules before they can form an intention, predict a consequence, or learn from a result.</p><p>Magic: The Gathering is a great example of this. Its enormous card pool creates genuine strategic depth and expressive play, but it also asks new players to learn a substantial number of mechanics before they can interpret many interactions confidently. Too many rules delays the moment when uncertainty becomes intelligible enough to support meaningful play.</p><h3>Emergence Rises From Structured Uncertainty</h3><p>My own reading of Salen &amp; Zimmerman’s <em>Rules of Play</em> is that compelling games are <strong>emergent</strong> systems: systems with a small number of rules which create an enormous amount of uncertainty. In MDA terms, this relates to games with limited mechanics but incredibly expressive dynamics from those mechanics. Go and Chess are enduring examples. Players can learn the basics in a few minutes, but spend years learning how positioning, timing, sacrifice, threats, spatial control, and opponent behaviour interact.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ywJ3QGqVeKC0T5_gxqkw0w.png" /></figure><p>Uncertainty provides the raw material for meaningful play, but designers must be mindful when writing their rules so players can understand them and explore them. I call uncertainty derived from compact rules <strong>structured uncertainty</strong>. The process of learning the game’s problem space, making sense of its uncertainty, and brainstorming optimal strategies is what makes games compelling.</p><p>At their core, games are problem-solving ventures.</p><h3>What meaningful play clicks in us (SDT / Csikszentmihalyi’s Flow)</h3><p>The frameworks we’ve looked at so far explore how games are built systemically. We’ll shift focus to frameworks centered on how games are psychologically compelling and how structured uncertainty fits into them.</p><p><strong>Self-Determination Theory (SDT)</strong> is a theory of human motivation developed by psychologists Edward Deci and Richard Ryan. It asserts that people are most likely to engage deeply, persist, and feel intrinsically motivated when an activity supports three psychological needs: <strong>autonomy, competence, </strong>and <strong>relatedness</strong>. Structured uncertainty supports autonomy by giving players meaningful ways to respond to a problem, and competence by making improvement visible through clear feedback.</p><p>While SDT looks at games from the lens of satisfying human needs, <em>Flow</em> by Mihayli Csikszentmihalyi offers a complementary perspective. How can a difficult system remain absorbing rather than frustrating? Csikszentmihalyi argues that flow depends on the relationship between perceived challenge and skill. A game can contain enormous strategic uncertainty — like Go! — while remaining engaging if the player can gradually build the skills needed to confront it.</p><h3>Putting it into practice</h3><p>So far, the frameworks we’ve analysed have explained how structured uncertainty is created. We first interpret games as a system with a set of rules. Then we craft an elegant rule set that produces uncertainty in our system. Finally, we make our system emergent by ensuring the ruleset is compact and legible.</p><p>Theory alone does not tell a designer what to change when a game doesn’t feel compelling. How do we turn structured uncertainty from an analytical concept into a practical design tool?</p><p>This is where Jesse Schell’s <em>The Art of Game Design: A Book of Lenses</em> offers an alternative. Schell provides a large collection of lenses: focused sets of questions that help designers inspect a game from different perspectives. Here are just a few that help turn the ideas we’ve discussed so far into practical design questions.</p><ul><li><strong>The Lens of Rules &amp; Elegance</strong><br>Are the rules of my game easy to understand? What purpose does each rule have? Could we combine rules?</li><li><strong>The Lens of Problem Solving &amp; Curiosity</strong><br>Does the game continually create questions that players want to answer?</li><li><strong>The Lens of Dynamic State</strong><br>What are the objects in my game? What are the attributes of the objects? What are the possible states for each attribute? What triggers the state changes for each attribute?</li><li><strong>The Lens of Emergence &amp; Simplicity/Complexity</strong><br>How many ways can players achieve their goals? How do side effects change constraints? Is there a way the game’s complexity could be turned into emergent complexity?</li></ul><h3>Four principles of Structured Uncertainty</h3><p>These frameworks approach game design from different directions, but together they suggest four practical principles for building systems players want to keep exploring.</p><ol><li><strong>Structured uncertainty enables learnable decision spaces.</strong><br>Players cannot know the correct answer in advance, but they can form a plan, test it, and revise it.</li><li><strong>Clear feedback ensures discernibility.</strong><br>Players can see what changed and connect that change to an action they took.</li><li><strong>Systemic integration makes actions consequential.</strong><br>An action affects the wider game state and changes the decisions that follow.</li><li><strong>Progressive complexity supports mastery.</strong><br>The game reveals deeper interactions at a pace that lets players build a usable mental model.</li></ol><p>In my next article, I want to analyse how a game can transform from brilliant to timeless by adhering to the principles I have listed.</p><h3>References</h3><p>Costikyan, G. (2013). <em>Uncertainty in games</em>. MIT Press.</p><p>Hunicke, R., LeBlanc, M., &amp; Zubek, R. (2004). MDA: A formal approach to game design and game research. In <em>Proceedings of the AAAI Workshop on Challenges in Game AI</em> (Vol. 4, pp. 1–5).</p><p>Salen Tekinbaş, K., &amp; Zimmerman, E. (2003). <em>Rules of play: Game design fundamentals</em>. MIT Press.</p><p>Schell, J. (2020). <em>The art of game design: A book of lenses</em> (3rd ed.). CRC Press.</p><p>Wizards of the Coast. (2026, August 7). Magic: The Gathering comprehensive rules. Retrieved August 31, 2026, from <a href="https://magic.wizards.com/en/rules">https://magic.wizards.com/en/rules</a></p><p>AlanKr. (2021, January 10). How to never lose Tic-Tac-Toe. Medium. <a href="https://medium.com/writers-blokke/how-to-never-lose-tic-tac-toe-e6e16715a76b">https://medium.com/writers-blokke/how-to-never-lose-tic-tac-toe-e6e16715a76b</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=031eb0883e2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Built Performance Telemetry for UE5 | Why Performance Benchmarking is Fundamentally Broken]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/how-i-built-performance-telemetry-for-ue5-why-performance-benchmarking-is-fundamentally-broken-f49c525c3d8d?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/f49c525c3d8d</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[unreal-engine]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 13:21:01 GMT</pubDate>
            <atom:updated>2026-08-26T13:21:01.127Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Performance Telemetry </em>helps UE5 developers connect gameplay performance problems to the places in the level where they occurred. Capturing metrics during a playtest was only part of the challenge; the harder problem was preserving that runtime data and reconstructing it later as an interactive, editor-native visualisation.</p><p>In my previous two articles, I expounded on the problem space behind <em>Performance Telemetry</em> and the design I employed when developing the plugin. This time, I want to dive into <em>Performance Telemetry’s</em> implementation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RlY-fuAA-KV7mMbFMx0kuQ.jpeg" /></figure><h3>The Implementation Goal</h3><p>To recap from the design discussion, <em>Performance Telemetry</em> had three major functional requirements:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*DSKQ9hub6UTBIvctH2JxbA.png" /><figcaption>Functional Requirements</figcaption></figure><ol><li><strong>Display performance information during playtests</strong><br>We need to display performance information</li><li><strong>Record playtest performance information</strong><br>Record playtest telemetry data as a JSON file</li><li><strong>Visualise performance information</strong><br>Visualise performance information as actors in the editor viewport</li></ol><p><em>Performance Telemetry</em> was my master’s thesis project, which means we had two additional non-functional requirements:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/949/1*zHU1y0dv4jzfzvihZ_ztzA.png" /></figure><ol><li>Implementation Constraints<br>Implementation must finish within a 6-month time-frame.</li><li>Metadata Logging<br>We need to log user behaviour in the plugin for use in my thesis’ user study section.</li></ol><h3>System Architecture 101</h3><p>UE5 plugins are broken down into sections called <strong>modules</strong>. Modules help separate related code within plugins. In <em>Performance Telemetry</em>, I split the codebase into modules based on the three subsections of <em>Performance Telemetry</em>’s functionality: visualising performance info; logging performance in playtest; and logging user metadata.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*prE6uTJwPLFEjC76VKb3-g.png" /><figcaption>Performance Telemetry System Design. Arrows show dependencies.</figcaption></figure><p><em>Performance Telemetry</em> is divided into four modules:</p><ol><li><strong>Runtime Module</strong><br>This module runs the <strong>Playtest Workflow</strong>. It handles recording and displaying performance data during the user’s playtest and serialising the data as a JSON log.</li><li><strong>Editor Module</strong><br>This handles the <strong>Editor Workflow</strong> we mentioned in the design section. It visualises performance data from JSON logs and recent playtests</li><li><strong>Metadata Module</strong><br>This module handles logging data for use in my user study.</li><li><strong>Core Module</strong><br>Much of <em>Performance Telemetry</em>’s codebase is shared between the existing modules. This module helps organise shared files between modules, such as the Telemetry Event class.</li></ol><p>Separating the code into modules like this has another benefit: the in-playtest and in-editor functionality of the plugin are split into the Runtime and Editor modules respectively. In production builds of games using the plugin, the Editor Module gets omitted but the Runtime functionality can still exist.</p><p>With those boundaries established, the next question was how telemetry data should move through the system during a playtest. That workflow begins in the Runtime Module, where the plugin samples performance and packages each sample into a reusable telemetry event.</p><h3>Capturing Playtest telemetry</h3><h4>Overview</h4><p>Per our functional requirements, the Runtime Module needs to record, display and log performance information.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*eIHLZdVZQFkYVMpLr4SYZg.png" /></figure><p>Once per second, the module records performance metrics and the player’s position, then packages them into a telemetry event. The event is displayed through a user interface widget and queues the event for persistence. At the end of the session, the telemetry event list is saved as a JSON file.</p><p><strong>Implementing the Runtime Module</strong></p><p>The module consists of four major components:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*PWg3DxjtC_c_k795eBuE0Q.png" /></figure><ol><li><strong>Telemeter</strong><br>The <em>Telemeter</em> records the user’s performance metrics: FPS, Memory Used, Number of Nearby actors, and creates a <strong>telemetry event</strong> from that data.</li><li><strong>Telemetry Widget</strong><br>The telemetry widget takes a telemetry event object and displays its metric data.</li><li><strong>Logger</strong><br>The <em>Logger</em> records the telemetry events produced by the <em>Telemeter</em> during the user’s playtest session. It writes these events into a JSON file.</li><li><strong>Telemetry Subsystem</strong><br>The <em>Telemetry Subsystem</em> orchestrates these classes together and forwards the telemetry events from the <em>Telemeter </em>to the <em>Telemetry Widget</em> and <em>Logger</em>.</li></ol><p><strong>An Aside: Development in Unreal Engine</strong></p><p>Developers write UE5 plugins in C++ and can leverage traditional C++ classes for implementation. UE5 also has several classes called <strong>engine classes</strong>. Many of these classes have special engine integration or lifecycle management. One subset of these classes is the <strong>Subsystem;</strong> UE5 itself will create and destroy these classes automatically, so we don’t need to write any complex initialization code or singletons to manage them. Fewer lifecycle paths meant fewer opportunities to log at the wrong time or forget to clean up afterward. Most importantly, it means less code to maintain — and that’s <em>always</em> a good thing.</p><h4>Using engine lifecycles to avoid edge cases</h4><p>I implemented the <em>Telemeter </em>class using UE5’s <strong>LocalPlayerSubsystem</strong> and the <em>Telemetry Subsystem</em> using the <strong>GameInstanceSubsystem</strong> engine class.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*YCqeq_os9lq480AAiKbGag.png" /><figcaption>Class Choices for Performance Telemetry’s Runtime Module</figcaption></figure><p>The main drawback of using these engine classes is the additional bloat these subsystems carry, namely the lifecycle machinery and abstraction overhead compared with a plain C++ class.</p><p>Because we are making a <em>performance</em> profiler, one could argue that using pure C++ classes, without the extra bloat from inheriting UE5’s Subsystem class would mean more accurate performance logs.</p><p>I went against that instinct because — realistically — we’ll only have one <em>Telemeter</em> and one <em>Telemetry Subsystem</em> instance alive at a given point, so any performance degradation from using the more bloated engine classes would be negligible. For the sake of implementation speed and less code, I decided it was a worthy trade-off.</p><p>With the Runtime Module complete, we’ve solved the first half of the problem. The Editor Module solves the second half by turning our telemetry events into something developers can see and manipulate in the editor.</p><h3>Visualising Telemetry Data</h3><h4>Overview</h4><p>The Editor Module is responsible for loading and visualising telemetry data in the editor viewport. The module consists of two major components:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*dqpecdy3bt-ZrdyswmMxWw.png" /></figure><ol><li>Telemetry Visualiser</li><li>Visualiser Panel</li></ol><p>The Telemetry Visualiser spawns markers in the editor world, while the Visualiser Panel is a User Interface (UI) that users interact with the UI to manipulate the visualisation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kxQJ9OuP1i6Py6cxEXp2ZA.png" /></figure><h4>Manipulating The Visualisation</h4><p>A visualisation can change for several reasons: we load a new session; toggle heatmap mode on; apply a time interval; run a query. Wiring each UI control directly to each visualisation behaviours ““““works””””, but it would become brittle as the number of filters grew.</p><p>All of the analysis methods we mentioned could each require separate code paths to clear markers, filter events, aggregate data, and respawn the viewport representation. As more controls were added, those paths would begin to overlap and drift apart.</p><pre># Sample implementation<br>class VisualiserPanel:<br>    def on_load_session(self, path):<br>        events = load_json(path)<br><br>        self.visualiser.clear_markers()<br>        self.visualiser.spawn_markers(events)<br><br>    def on_toggle_heatmap(self, enabled):<br>        self.visualiser.clear_markers()<br><br>        events = self.visualiser.events<br><br>        if enabled:<br>            self.visualiser.spawn_heatmap(events)<br>        else:<br>            self.visualiser.spawn_markers(events)<br><br>    def on_time_interval_changed(self, start, end):<br>        self.visualiser.clear_markers()<br><br>        events = [<br>            event for event in self.visualiser.events<br>            if start &lt;= event[&quot;time&quot;] &lt;= end<br>        ]<br><br>        self.visualiser.spawn_markers(events)<br><br>    def on_query_changed(self, query):<br>        self.visualiser.clear_markers()<br><br>        events = [<br>            event for event in self.visualiser.events<br>            if query.matches(event)<br>        ]<br><br>        self.visualiser.spawn_markers(events)</pre><p>As you can see, it’s a mess. Repeated code everywhere.</p><p>We want to keep telemetry and filtering state in one place, let the UI update that state, and finally regenerate the viewport representation when state changes. So, I went for a stateful UI implementation.</p><p>For those unfamiliar, in a stateful implementation, we maintain one source of truth. The UI responds to changes in the state.</p><pre>class VisualisationState:<br>    def __init__(self):<br>        self.events = []<br>        self.heatmap_enabled = False<br>        self.time_interval = None<br>        self.query = None<br><br><br>class Visualiser:<br>    def __init__(self, state):<br>        self.state = state<br><br>    def refresh(self):<br>        events = filter_events(<br>            self.state.events,<br>            self.state.time_interval,<br>            self.state.query,<br>        )<br><br>        self.clear_markers()<br><br>        if self.state.heatmap_enabled:<br>            self.spawn_heatmap(events)<br>        else:<br>            self.spawn_markers(events)<br><br><br>class VisualiserPanel:<br>    def __init__(self, state, visualiser):<br>        self.state = state<br>        self.visualiser = visualiser<br><br>    def on_query_changed(self, query):<br>        self.state.query = query<br>        self.visualiser.refresh()<br><br>    def on_time_interval_changed(self, start, end):<br>        self.state.time_interval = (start, end)<br>        self.visualiser.refresh()<br><br>    def on_toggle_heatmap(self, enabled):<br>        self.state.heatmap_enabled = enabled<br>        self.visualiser.refresh()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*FZuNz4w9_yJQBfqHRZQxWw.png" /></figure><p>The data flow essentially looks like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*o1Oi3u5gptyyRy9K1nceyw.png" /></figure><p>[Data Flow Diagram of Editor Module wrt MVC]</p><p>The <em>Performance Visualiser</em> imports a playtest log and updates the model. This update prompts the View layer to spawn markers to the editor. As the user edits the filters on the <em>Visualiser Panel</em>, the model layer changes and fires events that the View layer listens to to change the visualisation.</p><p>The Runtime and Editor modules support the plugin’s core user workflow. Because this project also involved a controlled user study, I added one more concern without coupling it to either workflow: recording how participants interacted with the tool.</p><h3>Designing for the user study</h3><p>Because <em>Performance Telemetry</em> was also used in a user study, the plugin needed to record how participants interacted with its features. I separated this responsibility into a dedicated Metadata Module rather than coupling study instrumentation to the runtime and editor workflows.</p><p>The module itself consists of one major class: the <strong>Metadata Logger</strong> implemented using UE5’s <strong>EditorSubsystem</strong> class, allowing it to live for the lifetime of the editor session and listen for interactions across the editor-side tools.</p><p>The <em>Metadata Logger</em> listens for events emitted by UE5 and the other Performance Telemetry modules, then sent the resulting data to a supabase database for later analysis. I’ll discuss the study design, the interactions we analyzed, and the results in a separate article.</p><h3>Wrapping it up</h3><p>The <em>Performance Telemetry</em> prototype successfully met all functional and non-functional requirments by the deadline. It captured telemetry at runtime, persisted it as shareable session data, and reconstructed it as interactive spatial markers where developers could investigate it. In the next article, I will discuss how <em>Performance Telemetry</em> did in a field study with Unreal Engine 5 developers and the takeaways I gathered from that.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f49c525c3d8d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing an Autograder for Unreal Engine 5 Projects]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/designing-an-autograder-for-unreal-engine-5-projects-fe71eda0b60c?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe71eda0b60c</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[unreal-engine-5]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[unreal-engine]]></category>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Wed, 19 Aug 2026 13:21:01 GMT</pubDate>
            <atom:updated>2026-08-19T13:40:44.126Z</atom:updated>
            <content:encoded><![CDATA[<p>At the University of Illinois Urbana-Champaign (UIUC), course staff for <a href="https://siebelschool.illinois.edu/academics/courses/cs415-120231">CS 415</a> (Game Development) manually grade <a href="https://www.unrealengine.com/unreal-engine-5">Unreal Engine 5</a> (UE5) project submissions for roughly 200 students.</p><p>This process can take anywhere between two weeks and a month.</p><p>I decided to change that.</p><p>In collaboration with Professor Eric Shaffer and UIUC’s Engineering IT, I developed a pipeline to automatically grade student submissions for CS 415, transforming a chore that could take several weeks into an automated process completed in a single night.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n6TrfkEfjCmIgHszWCKuEA.png" /></figure><h3>Digging Into The Problem and The Unique Quirks of Unreal Engine 5</h3><p>Automated grading is nothing new in academia; most university CS courses have a pipeline for autograding student assignments. Traditional university courses instruct in languages such as C++ or Python. These programming languages have tools to automatically test student submissions; these testing frameworks naturally lend themselves to autograding workflows.</p><p>A typical programming assignment will give students a skeleton of the solution code to complete.</p><p>[Simple Code sample with Incomplete function and tests for the function. Like something really simple i.e. multiplying or adding two numbers]</p><pre># Homework! Complete this function!<br>def add(x: int, y: int) -&gt; int:<br>  pass</pre><p>Then a set of tests against that code</p><pre>def test_add_positive_numbers():<br>    assert add(2, 3) == 5<br><br><br>def test_add_negative_numbers():<br>    assert add(-2, -3) == -5<br><br><br>def test_add_zero():<br>    assert add(5, 0) == 5<br><br><br>def test_add_mixed_numbers():<br>    assert add(-2, 5) == 3</pre><p>Student submissions are then graded based on the number of tests they pass</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*XB1UuXwWf1_XJViHWVBfyA.png" /></figure><p>Things aren’t so straightforward with UE5.</p><p>UE5 games are large, asset-heavy projects. A typical project can be anywhere from 1- 2 GB and requires a powerful machine to run. Whereas a couple of Python files are easily a couple of MBs and can run on basically anything.</p><p>Not to mention the creative requirements of CS 415’s assignments. How do you standardise grading for an expressive field like game development? How do you automate it?</p><p>For these reasons and more, CS 415 defaults to manual grading for its assignments. Students submit their completed projects on Canvas, and course staff manually review them. Manual review is reasonable for creative work, but inefficient for requirements every student must satisfy in the same way.</p><h3>Implementation End to End</h3><h3>Overview</h3><p>Our final grading pipeline involved a three-pronged approach.</p><ol><li><strong>Canvas assignment page</strong> <br>Students upload their submissions before deadlines, and TAs can adjust scores and add comments after grading.</li><li><strong>Autograder website</strong><br>Course staff monitor and orchestrate grading runs</li><li><strong>An automated pipeline with dedicated worker machines </strong><br>Receives, processes, and grades student submissions sent by the autograder website</li></ol><p>The grading workflow went like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*JJ5h-Tj4DxLERKtdF-GFWw.png" /></figure><p>Students upload their submissions to the Canvas course site. Course staff triggers an autograder run on the website. The grading website’s backend signals to a computer to grade the assignment submission. The computer picks up the grading job, runs the grading script, updates the student’s submission score on Canvas, and reports the run to the backend.</p><p>And just like that, the student’s submission is fully graded in a matter of minutes!</p><p>That’s the overview; now, we’ll dive into how the individual components work.</p><h3>The Brains Behind It All: The Autograder Website</h3><p>The autograder website is the orchestrator behind everything. It has to schedule, initiate, and log autograder runs and manage our worker machines.</p><p>The website itself is your textbook full-stack website with a Flask backend, a Vite-based frontend, and a SQLAlchemy database. The backend initiates Grading Run Workflows via HTTP requests and records and orchestrates grades run through SQLAlchemy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*2DOkxjYyYN1tx-MV8iGFSw.png" /><figcaption>Technology Stack diagram</figcaption></figure><p>The website coordinates with our automated pipeline to grade student submissions</p><h3>The Muscle Of The Operation: Automated Pipeline</h3><p>The automated pipeline is where the core of the grading process happens. We run a script on dedicated computers called <strong>worker machines</strong> to grade student submissions.</p><h3>Worker Machines</h3><p>Our worker machines need to run the autograder tests predictably. In automated pipelines, developers use an <strong>isolated environment</strong> (typically Docker containers) to separate our target process from other processes running on the computer. Luckily for us, Epic Games — UE5’s developers — offer a Docker image of UE5 and all its dependencies. We can easily install Docker and this image on our target worker machine.</p><p>Where things get dicey is in actually finding a suitable machine</p><p>Two major constraints complicate things:</p><ol><li><strong>We need a machine with enough storage.</strong><br>Unreal Engine is a <em>massive</em> game engine (A standard installation needs 120+ Gigabytes!). Any worker machine we use needs to have enough space for the full installation.</li><li><strong>We need a machine powerful enough to run UE5 reliably.</strong><br>Unreal Engine’s system specifications are pretty beefy. Epic Games’ system specs call for an 8-core CPU, 8 GB RAM, and a GPU with 2 GB of VRAM.</li></ol><p>Things sound pretty grim — especially with that second requirement — but we have two things going in our favour:</p><ol><li>Epic Games offers a <em>slim</em> Docker image of UE5 that trims the storage requirement to 50 Gigabytes. 50 Gigs is still a lot, but it’s a heck of an improvement!</li><li>Unreal Engine 5 can run in <em>headless </em>mode — which essentially means it runs without a user interface — reducing the system requirements to run the engine.</li></ol><p>After much deliberation, we settled on Amazon’s AWS machine [TODO: Add exact name here]. Amazon’s AWS Linux machines are both beefy enough and cheap enough to run our AG process.</p><p>With the worker machine settled, we can focus on the script driving the grading process.</p><h3>Grading Script</h3><p>Our grading script drove the actual grading process. Its flowchart looked like this:</p><p>The script takes two parameters: the student’s submission ID on Canvas and the target assignment ID.</p><p>[Image of Grading Script Flow Diagram]</p><p>It first downloads the student’s project submission from Canvas onto the worker machine.’</p><p>Then it downloads the test cases from a repository. The tests came from a dedicated testing version of the assignment. That version shared the Blueprints and interfaces under evaluation with the starter project, allowing the injected tests to locate and validate the required components in a student submission.</p><p>With the student’s submission on disk, the script injects the UE5 Functional Blueprint tests into their project.</p><p>The script rebuilds the student’s project and runs the newly added test suite in headless mode. Running the tests produces a JSON file containing the results.</p><pre>{<br>  // Device Info<br>  &quot;tests&quot;: [<br>    {<br>      &quot;testDisplayName&quot;: &quot;Test2&quot;,<br>      &quot;fullTestPath&quot;: &quot;Project.Functional Tests.SomeGroup.Test2&quot;,<br>      &quot;state&quot;: &quot;Success&quot;,<br>      &quot;deviceInstance&quot;: [&quot;878B6A854613D3B6A69CDEAFBA1C5DBA&quot;],<br>      &quot;duration&quot;: 0.3,<br>      &quot;dateTime&quot;: &quot;2000.01.01-12.00.00&quot;,<br>      &quot;entries&quot;: [<br>        {<br>          &quot;event&quot;: {<br>            &quot;type&quot;: &quot;Info&quot;,<br>            &quot;message&quot;: &quot;...&quot;,<br>            &quot;context&quot;: &quot;&quot;,<br>            &quot;artifact&quot;: &quot;00000000000000000000000000000000&quot;<br>          },<br>          &quot;filename&quot;: &quot;&quot;,<br>          &quot;lineNumber&quot;: -1,<br>          &quot;timestamp&quot;: &quot;2000.01.01-12.00.00&quot;<br>        }<br>      ],<br>      &quot;warnings&quot;: 0,<br>      &quot;errors&quot;: 0,<br>      &quot;artifacts&quot;: []<br>    }<br>  ]<br>}</pre><p>The process parses this JSON and calculates the student’s grade based on how many tests the submission passes.</p><p>Finally, the script publishes the student’s grade and test results to Canvas.</p><h3>The Testing Design</h3><p>When designing our grading pipeline, we had to work around the creative components of CS 415’s MPs. There’s a bit of tension with this requirement, however. We need <em>some</em> way to standardise grading between students for the autograder to work. But we also don’t want to rob students of their creativity while making assignments.</p><p>Then I noticed something.</p><p>All the assignments have a guided portion for students on how to implement part of the MP. Students seldom deviate from these instructions — this is the perfect spot to add test cases!</p><p>To account for creative components, we’d have to instruct students to submit a demo video/screenshots of their creative additions, so we would require some manual review, but it would be much faster than before, and we’d have the added thoroughness and consistency of automated tests.</p><h3>Reliability and Future-proofing The System</h3><p>Running a UE5 project automatically is not as predictable as running a small unit-test suite. A student submission may fail to rebuild, reference missing assets, cause the editor to crash, or simply take too long to finish. Since one stalled job could otherwise block grading indefinitely, the autograder needed to treat failure as a normal outcome rather than an exception.</p><p>Each grading run executed inside a Docker container on the dedicated AWS worker. This gave the UE5 process a consistent environment and kept project-specific dependencies separate from the worker’s host environment.</p><p>The grading process also had a hard 10-minute timeout. If Unreal Engine completed normally, the script parsed the test report, posted a preliminary score and comments to Canvas, and reported the successful completion back to the autograder website. If the website did not receive that completion signal within 10 minutes, it marked the run as timed out for course staff to review.</p><p>This run-status model gave staff a clear outcome for every attempted grade: completed, failed, or timed out. Instead of guessing whether a student had been graded, staff could identify exceptions and fall back to manual review.</p><p>Finally, the Canvas API token was stored in GitHub Secrets rather than in source control. That kept the credential used to retrieve submissions and publish grades out of the repository and out of the grading script itself.</p><h3>Conclusion</h3><p>This project started with a practical problem: manually grading UE5 submissions for a class of roughly 200 students could take anywhere from two weeks to a month. We could not fully automate evaluation for a creative game-development course — but we could automate the assignment tutorial segments!</p><p>The resulting proof of concept combined a staff-facing web application, Canvas REST API integration, GitHub Actions, a dedicated AWS worker, Dockerised UE5 execution, and Unreal Engine Function Blueprint Tests. It could process a single student submission in approximately two to four minutes, publish preliminary grades and feedback to Canvas, and surface failures or timeouts for staff review.</p><p>At that throughput, the standardized portion of grading for an approximately 200-student course could theoretically be completed overnight rather than becoming a weeks-long manual bottleneck. More importantly, the pipeline let course staff spend their time where human judgment mattered most: reviewing creative work, investigating edge cases, and giving students meaningful feedback.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe71eda0b60c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing Performance Telemetry: Why Performance Debugging in Games Is Fundamentally Broken]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/designing-performance-telemetry-why-performance-debugging-in-games-is-fundamentally-broken-6d562d019175?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d562d019175</guid>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Wed, 12 Aug 2026 13:21:01 GMT</pubDate>
            <atom:updated>2026-08-26T03:15:23.709Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why traditional profiling falls short</h3><p>Ever notice a performance hitch during a playtest, open your profiler, and realize you have no idea where in the level it actually happened? Traditional tools like Unreal Insights are excellent at showing <em>when</em> frame time spikes and which systems are active, but level designers often need to know <em>where</em> to look.</p><p>In other words, in level design work your questions relating to performance are often <em>spatial</em> rather than <em>temporal</em>. This spatio-temporal disconnect is the main weakness of traditional profiling tools in game development.</p><h3>My solution: Performance Telemetry</h3><p>For my master’s thesis at the University of Illinois Urbana-Champaign, I built <em>Performance Telemetry</em> for UE5: a plugin that brings playtest performance data into the editor viewport, helping developers connect a performance event to the part of the game world that produced it.</p><p>Rather than starting with a timestamp in a profiler and reconstructing the in game context from memory, developers can open the level, find the relevant telemetry marker, inspect its metrics and nearby actors, and use that context to decide what to investigate next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tylly_N33_BLIREeo11F6A.jpeg" /><figcaption>Performance Telemetry Logo</figcaption></figure><p>In the <a href="https://medium.com/@ucheikeuchechukwu/why-performance-debugging-in-games-is-fundamentally-broken-0a01364902b3">first part</a> of this series, I expounded upon the spatio-temporal disconnect in traditional profiling tools. In this article, I want to discuss the design principles behind <em>Performance Telemetry</em>’s approach in addressing this disconnect.</p><h3>The Design Behind the Plugin</h3><h4>Overview</h4><p>We anchored the design of <em>Performance Telemetry</em> around three design principles:</p><ol><li>Keep profiling information within the editor.</li><li>Enable cross-collaboration between engineers.</li><li>Add world context to performance information.</li></ol><p>These design principles drove the decision making for the three major design pillars <em>Performance Telemetry</em>: the selection of metrics; the in-playtest workflow; the in-editor workflow.</p><h3>Metrics</h3><p><em>Performance Telemetry</em>’s metrics were tailored to ground performance information in gameplay context. We focused on three primary performance metrics: Frames Per Second (FPS), Physical Memory Used, and Virtual Memory Used.</p><p>FPS was the primary performance metric — it’s the one most people are familiar with when discussing if a game feels “choppy.”</p><p>Physical and Virtual Memory Used served as more secondary metrics; they provide resource-pressure context to the FPS metric.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*Idaxb0noeAEdi8Du_a4QFQ.png" /><figcaption>FPS, Physical &amp; Virtual Memory Metric Relationship in Performance Telemetry</figcaption></figure><p>Unreal Engine — thankfully — already provides APIs for accessing these values, making these three options ideal for creating a minimum viable product. There are API for more niche metrics — but we intended to pilot our plugin for a research study. Best to keep things simple and not overwhelm our test subjects.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/850/1*y6nYkvnmUhjq3ufBzCATPw.png" /><figcaption>Metric Relationship in Performance Telemetry</figcaption></figure><p>The final metric: Number of Nearby Actors, grounds the other performance metrics in gameplay context by providing a possible level-design explanation for an event’s metrics. Actors are essentially UE5’s general class for objects in the world. Our rationale for this metric was that poor performance reasonably correlates with a large number of actors in the level.</p><h3>Profiling Workflows</h3><p>Our group defined two major personas for the plugin: <strong>Playtesters</strong> and <strong>Performance Engineers</strong>. We designed the in-playtest and in-editor workflows with those personas in mind.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/811/1*HPrm_pJ3tyMYmwuYKaRR4A.png" /><figcaption>Personas for Performance Telemetry</figcaption></figure><p>Playtesters are people looking to try the game out and get a general sense of performance stats; we tailored the in-playtest workflow specifically for them. Whereas Performance Engineers want more granular performance details and data manipulation capabilities.</p><h3>In-Playtest Workflow</h3><p>During playtest sessions, the plugin adds a widget to the screen that displays a general performance status (e.g., Normal, Warning, Critical).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zHuRZJEUluaqusLTqRPciA.png" /></figure><p>The user can expand the widget for more detailed performance metrics, including FPS, Memory used, and Number of Nearby Actors metrics as we discussed before.</p><p><em>Performance Telemetry</em> records telemetry events as JSON logs, which the user can read, share with other engineers, or visualise in the editor workflow. Here’s an example of one!</p><pre>{<br> &quot;context&quot;:<br> {<br>  &quot;map_name&quot;: &quot;UEDPIE_0_Untitled&quot;,<br>  &quot;date_time&quot;: &quot;2026-03-20T09:43:34.313Z&quot;<br> },<br> &quot;events&quot;: [<br>  {<br>   &quot;timestamp&quot;: &quot;+00:00:15.436&quot;,<br>   &quot;position&quot;: [<br>    0,<br>    0,<br>    0<br>   ],<br>   &quot;metrics&quot;:<br>   {<br>    &quot;used_physical_memory_mb&quot;: 6286.9765625,<br>    &quot;used_virtual_memory_mb&quot;: 9195.8984375,<br>    &quot;fps&quot;: 30.00,<br>    &quot;nearby_actors&quot;: 0<br>   }<br>  }<br>  ]<br>}</pre><p>The In-Playtest workflow is straight forward — it does the job and not much more. The real meat and potatoes of <em>Performance Telemetry</em> is the In-Editor workflow’s <em>Performance Visualiser</em>! Here’s where we truly bridge the spatio-temporal gap we discussed in the introduction.</p><h3>In Editor Workflow</h3><h3>Overview</h3><p>At the helm of the in-editor workflow is the <em>Performance Visualiser</em>. It’s the beacon through which the plugin turns an abstract telemetry event into something a developer can inspect at a location in the level<strong>. </strong>In alignment with this idea, the <em>Performance Visualiser’s</em> primary job is to add telemetry events from playtest sessions as translucent markers in the editor world.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Cmul2STAMPx1dVwsG-IN-w.png" /><figcaption>Performance Telemetry’s Performance Visualiser</figcaption></figure><p>One of our goals with this workflow was to make using the <em>Performance Visualiser</em> as intuitive as possible. To accomplish this, we used user experience patterns UE5 developers already understand. Think things like selecting actors, toggling filters, and inspecting actor detail panels to manipulate the visualisation.</p><h3>Inspecting Individual Events</h3><p>The markers themselves are either red, yellow, or blue, corresponding to the different statuses a telemetry event can have: critical, warning, or normal respectively.</p><p>By clicking on a marker, developers can read the specific metrics for a telemetry event.</p><p>Visualising data is all well and good, but as playtest sessions grow longer, we anticipated developers would want to filter for specific telemetry events from their sessions.</p><h3>Finding patterns across a session</h3><p><em>Performance Telemetry</em> offers three main tools to manipulate the event markers in the editor: the <em>Visualiser Control</em>, <em>Time Interval, </em>and the <em>Query Builder.</em></p><h4>Visualiser Control</h4><p>The <em>Visualiser Control</em> is a toggle that allows developers to visualise their events in two ways: <strong>Scatterplot</strong> and <strong>Heatmap</strong> mode.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/1*VwxvXpmTpHtL-7mh3oXf2w.png" /><figcaption>Two Visualisation Modes of Performance Telemetry</figcaption></figure><p>Scatterplot mode is the one we’ve seen so far. It enables developers to see each telemetry event that happened in a playtest, making it ideal for a granular view of telemetry events.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xUa2ws9tnEaqeMXHgmNrZw.png" /><figcaption>Scatterplot vs Heatmap Mode</figcaption></figure><p>In contrast, Heatmap mode divides the map into a 3D grid and adds a marker for each cell. These cell markers contain the aggregate metric data of the telemetry events that happened inside them. This approach complements scatterplot mode by giving an overarching view of performance at a level.</p><h4>Time Interval</h4><p>Using the <em>Time Interval,</em> developers can filter telemetry events for specific time frames in their playtest session.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/550/1*d-KtlNhUU8tCSk1IsUsivQ.png" /><figcaption>Time Interval Widget</figcaption></figure><h4>Query Builder (This is the good part!)</h4><p>With the Query Builder, things get really interesting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/542/1*xz80yXcBWvJLF3YWz-vG3w.png" /><figcaption>Query Builder Widget</figcaption></figure><p>The <em>Query Builder</em> enables developers to create queries to filter telemetry markers by specific metrics. e.g. FPS &gt; 30 or Memory Used &gt; 8000 MB. By combining different filters, developers can access high-level performance visualisations of their levels.</p><p>Here’s an example of Performance Telemetry inside UE5’s <a href="https://www.fab.com/listings/1a2b1d97-bc88-4c3f-98b8-22369b5c3170">UnrealLearningKit</a> map.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1001/1*2rfxQDHlnYyEa9rUhfHjgQ.png" /><figcaption>Performance Visualisation of Unreal Learning Kit Map</figcaption></figure><p>For example, if I wanted to look for areas of good performance, I could filter for telemetry events where the performance status is normal.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jBHbG7osx81atCvdjKRqvw.png" /><figcaption>Visualisation of Good Performance Areas in Map</figcaption></figure><p>Perhaps these are areas where we can mark performance as good and look elsewhere.</p><p>If I wanted to look for areas of bad performance where there were a lot of actors present, I could filter for events where the performance status is low, and the nearby actor count exceeds a chosen threshold.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YHKHBH9SJ6I0BQsRgxiAXw.png" /><figcaption>Visualisation of Poor Performance Areas in Map</figcaption></figure><p>The query results identify areas worth investigating, and the developer can then inspect the actors and validate whether encounter density is actually responsible.</p><p>The <em>Query Builder </em>is where the power of <em>Performance Telemetry</em> really shines. It offers a unique game-world context that traditional profiling tools simply do not offer.</p><h3>Wrap up</h3><p>Performance Telemetry was designed to make performance debugging feel less like reconstructing a timeline from memory and more like investigating the level itself. By pairing playtest telemetry with spatial visualisation, familiar UE5 editor interactions, and flexible filtering tools, the plugin helps developers move from “something felt slow” to a specific area, event, and set of conditions worth investigating. In the next article, I’ll go behind the workflow to discuss how I implemented the telemetry pipeline, persistent logging, and in-editor visualisation in UE5.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d562d019175" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built UE5 Exam Questions to Beat ChatGPT. And Then Students Beat Me Instead.]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/i-built-ue5-exam-questions-to-beat-chatgpt-and-then-students-beat-me-instead-8641f74c5219?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/8641f74c5219</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[unreal-engine]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[teaching]]></category>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Wed, 05 Aug 2026 13:21:01 GMT</pubDate>
            <atom:updated>2026-08-05T16:36:16.055Z</atom:updated>
            <content:encoded><![CDATA[<p>Everyone’s worried about students using ChatGPT to ace their assignments. In the game dev course at the University of Illinois Urbana-Champaign, that worry was very real. I was a TA for <a href="https://siebelschool.illinois.edu/academics/courses/cs415-120231">CS 415</a>, where students build games in <a href="https://www.unrealengine.com/unreal-engine-5">Unreal Engine 5</a> (UE5). Our existing UE5 exam questions were mostly multiple‑choice: easy to guess, easy to paste into an LLM, and nothing like how students actually program in UE5.</p><p>I decided to build new, editor-style UE5 questions that were harder to outsource to AI and closer to the decision‑making students did in their course assignments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/971/1*uXPkLxGYV3YKIZswP6oDRQ.png" /></figure><p>Fast forward two weeks later, and we finally demo the questions during the midterm. As the midterm drew to a close and student feedback trickled in, I realised a fatal oversight: the autograder rejected their perfectly valid solutions.</p><h3>The system at a glance</h3><p>For those uninitiated, Unreal Engine 5 has an alternative to traditional coding called <a href="https://dev.epicgames.com/documentation/unreal-engine/blueprints-visual-scripting-in-unreal-engine">Blueprints Visual Scripting</a> (Blueprints). Instead of typing out C++ code, users can spawn, drag, and drop “nodes” to build simple graphs. These nodes acts as building blocks that developers can connect to create game logic. Think of it as like writing your code as a flowchart.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/912/0*X167kWl45AmyUTY8.png" /><figcaption>Example Blueprints code adding health to player</figcaption></figure><p>Instead of player.health = player.health — damage, you grab nodes representing the Player Health and the incoming damage add them together, then set the player Health to the result.</p><p>I wanted the new questions I was developing to go all the way — whatever I built <em>had</em> to replicate Blueprints.</p><p>My solution was a using a tech stack of Python, HTML, and JavaScript. The real powerhouse in this operation was the JavaScript library Litegraph.js — a front-end graph editor library made specifically to emulate UE5 Blueprints!</p><p>The data flow worked like this:</p><p>Our backend, written in Python, lets course staff define the starter graph that students are given when they open the question and solution graph that students’ submissions are graded against.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/916/1*n2bE-9EPbyMRQn_7u_qLlw.png" /><figcaption>Data Flow Diagram for Backend to Frontend Pipeline</figcaption></figure><p>Once the question is created. The student can then edit the graph as they please as they develop their solution.</p><h3>Representing UE5 logic in Python</h3><p>You might be curious about how our graph representation works. Unfortunately for me, it wasn’t as straightforward as graphs from your <em>Intro to Data Structures</em> course. Unreal Engine 5’s Blueprints system contains hundreds of nodes, each node has input and output slots you can pass values to called “Pins”. Pins can carry different kinds of data: floats, integers, booleans; we needed a representation that could handle all of that.</p><p>To best handle this, we separate the Pins and Nodes into distinct classes and reason that a Node <em>contains</em> a set of input and output pins. When we define a new node (say, “Add Health”), we specify which pins it has and what types they accept. Creating a new node becomes a matter of plugging together the right pins.</p><p>You might think this is a lot of effort, but this representation is important. Mostly because it abstracts a lot of complexity for making new problems and means we can easily reuse nodes between different problems.</p><p>The front‑end was thankfully much simpler. Litegraph.js does most of the heavy lifting; most of my code was boilerplate to make the nodes look and behave like UE5 Blueprints.</p><h3>Grading</h3><p>Now that we’ve covered the prerequisites, we can dive into how grading works. The process is essentially the inverse.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/954/1*T0zN9Q8w0zqoU2Gj0RUYWw.png" /><figcaption>Dataflow diagram for Frontend to Backend Pipeline</figcaption></figure><p>Once the student hits submit, we take the graph on the screen and convert it back into JSON and then convert it back to the Python graph implementation we defined before. We finally compare the student’s submission to our solution graph using the <a href="https://networkx.org/documentation/stable/reference/algorithms/isomorphism.vf2.html">Vento-Foggia 2</a> algorithm.</p><p>And that’s how the system works end to end!</p><h3><strong>Where everything went wrong</strong></h3><p>Now we can finally swing back to the issue I had in the beginning of the article. I created two question variants for a demo run and watched as my little passion project stumbled onto the finish line. Most students didn’t have an issue with the problems, but one recurring issue came up: my questions weren’t accounting for multiple solutions to the problem.</p><p>For example, one demo question involved a code snippet that increases the player’s health but caps at the player’s max health.</p><p>My intended solution involved adding health to the player and them clamping their HP to a maximum value after adding.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CneDcTs5Ow6PcSfvDgQcYA.png" /><figcaption>Blueprints Code Snippet Adding Health</figcaption></figure><p>But, some students had other ideas…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vmrP7-IwB3dJtR5ZZEAQiA.png" /><figcaption>Alternative Blueprints Code Snippet for Adding Health</figcaption></figure><p>It was a real facepalm moment. Here I was thinking I wrote the questions cleverly enough that there would only be one real solution. Just goes to show how important user testing can be.</p><h3>Back to the drawing board...</h3><p>An quick fix to this problem would be to force students to use minimal graphs, but that would punish students for not thinking exactly like me when solving problems.</p><p>I had to think of something else.</p><p>My first real solution was to include multiple potential solutions for each problem. So for the healing script example, we could list both approaches be plausible answers when grading the student’s submissions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/946/1*y3FpC0azUuxX9PonsCMiOg.png" /><figcaption>New Grading Pipeline</figcaption></figure><p>That <em>kind of</em> works fine enough — but only because this is a relatively simple blueprint to write. Remember our second goal for this project was making our questions resistant to LLMs! If we wanted to write more complex questions, we’d have to account for more and more possible solutions. That scales horribly and is a nightmare for any future graders to reason about when working on new problems.</p><p>Let’s think about it another way then.</p><p>What if we could somehow “follow” the flow of data through the student’s graph? We treat the student’s submission as a theoretical “black‑box” function: feed it some inputs, read the outputs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*UJk0t1kCIbfsNpQbPKWVgg.png" /><figcaption>Graph “Black Box” Concept</figcaption></figure><p>We treat our solution graph the same way. At grading time we check if the student and the solution’s graphs’ black boxes have the same outputs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*PdB-g5J0BzxurmVmykG6qw.png" /><figcaption>Proposed Grading Pipeline</figcaption></figure><p>For example, if the player’s max HP is 100, the health pickup heals for 20, and they’re currently at 50 HP, then their final HP should be 70. We could run those numbers through the student’s graph’s black box function and compare the results to our solution graph’s function.</p><p>If this worked, we wouldn’t need to enumerate every possible correct graph. We’d just need one reference solution and a way to simulate both graphs with the same inputs.</p><p>Transforming the graph for our healing script problem is a bit abstract but not impossible. How would we adapt this approach for other problems though? Well, whatever abstraction we’d make would have to be something generic for all the different data types the UE5 has to offer and be flexible enough to work for all the different types of nodes and graphs that I may make problems for in the future.</p><p>At that point, I wasn’t just comparing graphs anymore. I was trying to decide what “correct” means. Then I realised I was about to start writing a programming language.</p><p>Let’s take a step back.</p><h3>Debugging and tooling</h3><p>Rewriting the UE5 Blueprints from the ground up — while a very impressive resume project — was not something I was about to do in the middle of an already hectic semester.</p><p>Then I thought:</p><p>Why not just add some manual grading?</p><p>Prairielearn already supports manual grading for questions, and we could use that to our advantage. Granted, it’s not as elegant as having everything be fully automatic, but — considering scope and time constraints — it would work! I’d have to be deliberate about this though; CS 415 has a limited number of staff as is so the approach I finally settled on was:</p><ol><li>Hardcode a few known‑good solutions.</li><li>If a submission doesn’t match exactly but contains the key nodes (e.g., a heal node, a max‑HP check, a player reference), flag it for manual review.</li></ol><p>That way, the autograder handled the obvious cases, and staff only looked at the interesting edge cases where students were often doing something clever we hadn’t anticipated.</p><h3>Takeaways</h3><p>In the end, this project was a great reminder that engineering is often times less about finding the perfect answer, but leveraging the strengths and mitigating the weaknesses of your project’s domain. In this case, that meant building something flexible enough to handle creative student solutions, while still being simple enough for staff to maintain.</p><p>If I kept iterating on this project, I’d spend more time user testing with students earlier in the process and refining the grading system around the kinds of solutions they naturally reach for. Heck, the idea of writing a minimal version of the Blueprints language still intrigues me.</p><p>Even with its limitations, the project gave me a lot of experience building across the stack, working within production constraints, and making practical tradeoffs to ship something usable.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8641f74c5219" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Performance Debugging in Games Is Fundamentally Broken]]></title>
            <link>https://medium.com/@ucheikeuchechukwu/why-performance-debugging-in-games-is-fundamentally-broken-0a01364902b3?source=rss-825879431f55------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a01364902b3</guid>
            <category><![CDATA[unreal-engine-5]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[performance-optimization]]></category>
            <dc:creator><![CDATA[Uche Uche-Ike]]></dc:creator>
            <pubDate>Wed, 29 Jul 2026 13:01:05 GMT</pubDate>
            <atom:updated>2026-07-29T13:01:05.072Z</atom:updated>
            <content:encoded><![CDATA[<p>Picture this:</p><p>You spent the last few days hard at work and built this beautiful open-world game in your game engine of choice.<br>You play around for a bit, and your stomach drops as the frame rate nosedives: at the enemy encounter; while walking through a dense forest; or during the busy cutscene.</p><p>You stop the game. Take a deep breath. Open your profiler. Stare at the screen. And you realize: you have no idea where to even begin.</p><p>Sure — you can talk to death about which specific lines of code can be improved, but you have no idea which areas of the game are performance hotspots.</p><p>The real problem lies in the way our tools think about performance. In this article, I want to unpack <em>why</em> performance debugging in games is harder than it looks, where traditional profilers are genuinely excellent, where they fall short for performance optimization during level design, and how that led me to build a spatial performance telemetry plugin for Unreal Engine 5.</p><h3>The core mismatch: time vs. space</h3><p>Almost all modern profilers are <strong>timeline-first</strong>.</p><p>Unreal Insights (UE5’s proprietary performance profiler) gives you a powerful timeline-based view of gameplay performance. It provides all the granular details on when frame time spikes, which threads are busy, and what functions are running; so, it’s fantastic for questions like:</p><ul><li>“What is taking so long on the game thread right here?”</li><li>“Which function is responsible for this spike?”</li><li>“How do CPU and GPU timelines line up?”</li></ul><p>But when you’re doing level design work, your questions are often <em>spatial</em>:</p><ul><li>“Which area of my level is causing this hitch?”</li><li>“Is it this foliage cluster, that marketplace, or the boss arena?”</li><li>“If I change this section of the map, will it actually fix the stutter I felt?”</li></ul><p>The profiler answers “<em>when</em> did it happen?” far better than “<em>where</em> did it happen?”</p><p>That temporal–spatial mismatch is where a lot of the pain comes from. You feel a frame-rate dip in one part of the level, then you spend far too much time mentally mapping:</p><blockquote><em>“OK, around 3:25 into the playtest, I was near the bridge… or was I already in the cave?”</em></blockquote><p>The more complex your level and the longer your playtests, the harder it becomes to reconstruct where that hitch actually happened. Coordinating these problematic areas across an entire team becomes a nightmare.</p><h3>What traditional profilers get right (and what they miss)</h3><p>I would be remiss to say that profiler tools like Unreal Insights aren’t extremely valuable. They shine at:</p><ul><li>Deep time-based analysis</li><li>CPU/GPU hotspots at the line-by-line code level</li><li>Verifying optimizations at the function or system level</li></ul><p>But for level iteration in game development, there are a few pain points:</p><ul><li><strong>Context switching:</strong><br>You bounce between playtesting, the level editor, and the profiler window. Your mental model of “where on the map was I?” gets fuzzier every hop.</li><li><strong>Weak spatial grounding:</strong><br>The profiler tells you “a spike happened at 123.4 seconds,” but not “right next to this specific cluster of actors.”</li><li><strong>Cognitive load:</strong><br>You’re constantly translating between three different views: the level, the profiler timeline, and your memory of the playtest.</li></ul><p>When you spend most of your time in the editor, you start to wish that performance data could live closer to the level itself.</p><h3>The moment I realized I needed something different.</h3><p>This project started with a project proposal from one of my Professors from the University of Illinois Urbana-Champaign (UIUC), one Daniel Cermak — most famous for his work as a General Manager at Volition (think Saints Row, Red Faction!). He gave me the proposal for such a plugin as the subject for my master’s thesis at UIUC.</p><p>After investigating the problem further, I realized most existing tools fell into one of three buckets:</p><ul><li>Outdated</li><li>Not geared toward performance profiling</li><li>Focused on granular, timeline-based data (think Unreal Insights).</li></ul><p>Then it hit me. A fully realized tool in this space could cut down the time devs spend hunting down performance issues, and make profiling accessible to developers who aren’t performance experts.</p><h3>A simple framework for tools devs actually use.</h3><p>After mulling over Cermak’s proposal for the plugin, I decided on three major design principles for my implementation.</p><h3>1. Spatial co‑registration</h3><p>If a problem is inherently spatial, the data should live where the problem lives.</p><p>In my case, that meant:</p><ul><li>Logging FPS, memory, and nearby actors <strong>together with</strong> player position.</li><li>Spawning editor actors/heatmaps in the level viewport where critical events occurred.</li><li>Letting developers click those markers instead of hunting through a timeline.</li></ul><p><strong>Concrete example:</strong> Instead of staring at a timeline spike at “3:25” and trying to remember whether that was the bridge, the forest, or the boss arena, you open the editor and see a red marker floating right next to the dense foliage cluster that caused the issue. No mental reconstruction needed.</p><p><strong>This directly addresses the “where did it happen?” question that timelines can’t answer.</strong></p><p>General lesson: when the work happens in the editor, performance data should be visualized in the editor.</p><h3>2. Low cognitive load</h3><p>Performance tools should <em>lower</em> mental overhead.</p><p>For the plugin, that meant:</p><ul><li>Reusing UE5’s existing interaction patterns (selecting actors, filtering in simple UIs).</li><li>Avoiding “dashboard syndrome” where the user has to decode five graphs before doing anything.</li></ul><p>General lesson: a tool can be powerful without being cognitively heavy.</p><h3>3. Retrospective scalability</h3><p>Debugging doesn’t just happen live; it also happens after the fact.</p><p>For the plugin:</p><ul><li>Every playtest writes telemetry to a simple JSON log.</li><li>You can reload previous playtest sessions and see their hotspots directly in the current level.</li><li>You can filter by time, severity, or metrics to understand how performance changed over several runs.</li></ul><p><strong>Concrete example:</strong> Last week, your teammate mentioned a hitch in the marketplace cutscene, but you couldn’t reproduce it. Instead of guessing, you reload last Tuesday’s playtest log, filter for “FPS &lt; 30,” and instantly see a cluster of markers around the marketplace stalls. Now you’re debugging from evidence, not memory.</p><p><strong>So you’re not starting from scratch every time someone asks, “Did we fix that hitch in the marketplace?”</strong></p><p>General lesson: design for <em>time</em>. Tools should support both the “I just finished playtesting” and the “I’m looking back at last week’s regressions” moments.</p><h3>Where is this going next</h3><p>In future posts, I’m planning to share:</p><ul><li>The exact design and workflows behind my plugin</li><li>A deeper look at how the plugin works under the hood in UE5.</li><li>What happened when I put it in front of developers in a controlled study.</li><li>Lessons learned about building tools that actually change workflow, not just add more data.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a01364902b3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>