The 4 OOP Principles Every Unity Developer Should Know And Actually Use

You've probably heard of Object Oriented Programming, but what does it mean exactly? One may think it's pretty obvious. Well, it's not. OOP is one of those terms that gets thrown around in job listings and Reddit threads until it stops meaning anything.

Here's the thing though: Unity is built on OOP. Every MonoBehaviour you've ever written is a class. Every GameObject you drag components onto is basically a walking demonstration of composition. So whether you've been "using OOP" on purpose or by accident, you've already got your hands dirty.

The 4 principles; encapsulation, inheritance, polymorphism, and abstraction, all sound like you need a degree in computer programming - but after reading this article, you'll be surprised how simple it really is. They're the difference between a codebase you can expand on for years and one that collapses the moment you add a third enemy type. Let's go through them one at a time, Unity-style.

Understanding the Unity Game Loop: Awake, Start, Update, and Everything Else Explained

Welcome to another blog post about the stuff that quietly runs your entire game, whether you think about it or not. This Wednesday's topic: understanding the game loop in Unity; Awake, Start, Update, FixedUpdate, LateUpdate, OnEnable, OnDisable, Reset, teardown methods, coroutines, and a peek at the rendering callbacks.

If you've ever wondered why your player controller moves like it's had too much coffee on some frames and none on others, or why a script that "should" be running just... isn't, chances are you've got a game loop misunderstanding on your hands. 

This stuff isn't glamorous, but it's foundational. Get it wrong, and every system you build on top of it inherits the wobble.

Let's have a closer look at how it all works together.

Delegates, Events, Actions and Func in Unity: When to Use Each One

Welcome to another blog post about one of those C# topics that trips up almost every solo game developer at some point: delegates, events, Action, and Func. If you've ever stared at a tutorial and thought "okay but why would I use this over just calling a method directly," well, ..you're in the right place. 

Let's take a look shall we? 

 

 

 

 

Getting Started With Unity: 3 Things Beginners Should Learn Before Even Installing The Program

Welcome to another blog post about Unity for absolute beginners. If you've searched around for "how to start Unity," you already know the drill: install the engine, drag a cube into the scene, slap a Rigidbody on it, write ten lines of code to make it jump. Video over, you made the thing move, it feels really productive right? 

That's actually how I started learning Unity as well. But I was struggling really bad. I could not wrap my head around what and why things were happening. Now, that I have been using Unity to design my games for over 6 years, I understand what my biggest issue was trying to learn the engine. That's why my teaching method is a different from all the others out there.

Here's the problem, and I understand why most people would quit after taking a course or two. Not because Unity is too hard, but because nobody explained what's actually happening under the hood before throwing them at the code editor. You can't debug what you don't understand, and you definitely can't build anything beyond a tutorial's exact steps if you don't know why those steps exist in that order.

So my approach is unusual. At this stage you don't have to learn how to make the player jump. Instead I'm going to cover the three things I wish someone had explained to me before I touched a single script: the game loop, how references work, and why starting stupidly small is the actual skill that separates people who finish games from people who don't. 

Let's dive in!

State Machines in Unity: 3 Options to Stop Your Game Logic From Turning Into Spaghetti

Welcome to another blog post about writing Unity code that doesn't make you want to throw your laptop out the window. Today's topic: state machines in Unity!

If you've ever written a PlayerController with six bools (isJumping, isRunning, isAttacking, isDead, isReallyDead, isDefinitelyDeadThisTime) and a 100-line Update() full of nested if statements, this one's for you. 

Let's have a look! 

 

Interfaces vs Abstract Classes in Unity: Which One Is Better?

Here we go again, yet another blog post about a debate that's been quietly ruining developer's sleep since the dawn of object-oriented programming. Sit back and relax, because we're finally settling the "interface or abstract class" argument. 

Why This Comparison Even Matters

As a solo game developer like myself, you don't have a senior architect looking over your shoulder telling you your class hierarchy is a big mess. When it comes to interfaces vs abstract classes in Unity, the choice you make on day one tends to snowball... and it'll either be a clean, swappable system, or turn into a tangled inheritance chain you'll be untangling weeks from now. Fully understanding both of them is important, especially at the beginners stage, since this is not even an intermediate topic.

Both let you enforce structure across your scripts. Neither is "wrong." But picking the wrong one for the wrong job is how you end up with an Enemy abstract class that fifteen unrelated objects are awkwardly pretending to inherit from just to get one shared method.

Task vs UniTask vs Awaitable: Performance and API Comparison for Unity Devs

Welcome to another blog post about async programming in Unity, which async should you use? Let's elaborate. If you've ever Googled this while your coroutine spaghetti stared back at you accusingly, you're in the right place. Let's get you something to ponder on over the weekend!

The thing is, Async/await in Unity used to mean one thing: System.Threading.Tasks.Task. Then UniTask showed up and made everyone's coroutines look ancient. Unity's shipped its own native Awaitable type, and suddenly you've got three ways to do the same thing, each with its own opinions about your garbage collector.

So which one should you actually reach for? Let's break down the Task vs UniTask vs Awaitable performance story, the API differences, and where each one earns its spot in a solo game developers toolkit.

 

Anomaly Hours: Forest Cabin Devlog Massive Update. All Cameras Exposed - YouTube Gameplay Video & More News!

Hey guys! Welcome to another Anomaly Hours: Forest Cabin big update. It's been awhile since my last one, and that's because I haven't sat still! 

First and foremost, a big thank you to everybody who has wish-listed the game on Steam. With around 114(!) wish-lists already!! Thank you!

The news is that many features were added to my upcoming survival horror anomaly game. I won't go over all of them, but let's go over on the things that I want to highlight. In this update I'll show you all the camera views of the game! Also, what to expect when you play through all the anomaly hours - and some behind the scenes stuff if you're interested. The planned release date is Q4 of 2026!

 

 

UnityAction vs UnityEvent: The Real Difference (And When to Use Each)

Back in the day when I first started programming in Unity (during COVID) this was probably one those hard concepts to wrap my head around. I kept mixing them up, and didn't know which one to use when. When I did a google search I was left even more confused! I thought, hey, now that I actually understand the whole thing; why not write an article about it because it's actually really simple.

So, do you use a UnityAction, or do you opt for a UnityEvent? They sound kind of the same. They show up in similar places, and yet mixing them up in the wrong context can leave you debugging phantom null references for a loooooong time, wondering why your inventory system just... stopped listening.

So, let me try to explain it in my own words and hopefully I can make some sense of it all, including exactly when to use UnityEvent in Unity, and when it's just adding overhead for no reason.

Inheritance vs Composition in Unity: Which One Should You Use?

How many time have you argued with yourself: should this Enemy class inherit from a base Character class, or should it just be a GameObject wearing a trench coat made of components? Welcome to the inheritance vs composition in Unity debate, a fight that predates Unity by decades, but hits differently when you're the only person who has to live with the consequences of your own architecture.

This isn't an academic computer science debate for you. You're a solo dev. There's no team lead to quietly blame when your class hierarchy buckles under its own weight six months from now. So let's skip the theory-heavy stuff and talk about what actually matters when you're picking a side (or perhaps, you choose a combination of both in your project).

Let do it!