SOLID Principles In Unity Explained Without Needing A Computer Science Degree

FIVE letters, TEN intimidating words, and a bunch of academic jargon that make your eyes glaze over before you even get to the point. Somewhere along the way, "SOLID principles" got a reputation for being something only enterprise developers care about in between coffee breaks and standup meetings.

Here's the thing though: you've probably already broken (or followed) most of these principles in your Unity projects without knowing they had names. SOLID isn't some separate discipline you need to learn, it's just a handful of common-sense guidelines for not making your future self miserable.

 

Let's go through all five, Unity-style!

 

So You Want to Build a VR Game for Meta Quest? Let's Actually Do It!

 
Here's the thing about VR development tutorials: most of them are written by people who already know everything, addressing an imaginary reader who apparently also already knows everything. You get a code snippet, a "simply configure your XR rig," and a vague sense that you missed a memo somewhere.

This series is not going to be that, so if you were expecting that; read another blog :P

I'm starting this the same way you probably are, with an idea for a Quest game and a Unity install that's never touched VR before. Over the next 14 articles, spread out over the beginning of the fall season, we're going from "WTF is an XR rig" to "My game is live on the Meta Horizon Store!"  

 

Why Meta Quest?

There's a lot of VR hardware out there, but Quest earns its own series for simple reasons: it's standalone and popular. No console or PC tether (although you could), no external sensors, just a headset someone bought and strapped on. That convenience is exactly what makes it the best on-ramp for indie VR dev, bigger install base, lower barrier to entry for players, and a genuinely mature toolchain now that Meta's XR SDKs have had years to sand off the rough edges. It's also, not coincidentally, the platform I'm going to build a project for. So consider this dual-purpose: you're getting a tutorial series, and I'm getting a build log!

 

What This Series Actually Covers

I'm going to write 14 articles that follow the real order things happen in, not the order they're fun to talk about:

Getting oriented (Parts 1-4): Why build for Quest at all, getting your dev environment actually working (this is the part where builds mysteriously fail and nobody explains why), understanding the alphabet soup of Meta XR SDKs, and getting a literal cube rendering in your headset. Unglamorous, but skipping it is how projects die in week one.

Core VR fundamentals (Parts 5-6):  Locomotion and comfort, arguably the most VR-specific design problem there is, since "how does the player move" can straight-up make people vomit if you get it wrong, followed by hand tracking and controller interactions.

Building your actual game (Parts 7-9): Designing a concept that works because it's VR, not despite it. Then the core gameplay loop, and a look at multiplayer basics for when "can my friend join" comes up (it always comes up).

Making it good (Parts 10-12): Mixed reality extras like Passthrough, performance optimization for standalone hardware (Quest is basically mobile-grade, treat it as so), and playtesting with actual humans who aren't you.

Getting it out the door (Parts 13-14): Submitting to the Meta Horizon Store, and what happens after launch, because "I shipped it" and "people are playing it" are two very different things. 

 

What You Won't See Here

Every deep technical rabbit hole! This blog series is deliberately the streamlined version, one concept, one working example, one clear next step per post. If you want the full depth, line-by-line implementation, every edge case, the stuff that would triple the length of each post, you want to read another blog!

 

Who This Is For

If you know your way around Unity but have never touched XR, you're in the right place. If you're VR-curious but a little intimidated by the ecosystem, also you. The one thing I'm assuming when writing the articles is that you know basic to intermediate C# and Unity editor familiarity.

As said, the series will be published in the beginning of the fall season. Stay up to date by subscribing to the feed, or follow any of my socials. I'll announce it there..so you won't miss a thing!

~ 

Unity Events vs UnityEvent vs C# Events: Which One Should You Actually Use?

If you've ever Googled "how do I make a button call a function in Unity" and ended up more confused than when you started (which happens a lot in my case - yes I'm looking at you CodeMonkey!), you're not the only one.

"Unity Events," "C# events," and "UnityEvent" all sound like the same thing said three different ways. 

Well, they're not. Surprise! 

 

They're three genuinely different tools, each with their own tradeoffs, and picking the wrong one for the job is how you end up with either a spaghetti mess of references or a UnityEvent doing something a plain C# delegate would've handled in one line.

Let's sort out what's actually what.

 

First, Let's Kill the Naming Confusion

Here's the actual breakdown:

C# events        → the native "event" keyword, built into the language
C# delegates     → Action, Func, and custom delegate types
UnityEvent        → UnityEngine.Events.UnityEvent, the Inspector-serializable one
"Unity Events"    → the loose, informal term people use for any of the above

That last one is the troublemaker! When someone says "just use a Unity Event," they might mean the actual UnityEvent class, or they might just mean "wire up an event, using the inspector." 

Context matters people! 

For the rest of this article, I'll be specific and call out which one I mean, so you don't end up in the same boat. Let's just make it clear, once and for all!!

10 ScriptableObject Patterns Every Unity Developer Should Know (Part 3) Factory Pattern, AI Behaviors & Global Configuration

Over the last two articles, we've explored seven practical ways to use ScriptableObjects beyond simple data storage.

We've covered everything from Data Assets and Runtime Sets to Item Databases and Spawn Tables. Hopefully by now it's becoming clear that ScriptableObjects aren't just a convenient place to store numbers, colors or sprites, they're powerful architectural tools that can help keep your project organized as it grows.

In this final part, we'll look at three more advanced patterns that are particularly useful in larger projects.

Don't worry if some of these seem a little intimidating at first, you probably won't need all of them on your next game. In fact, you may never need them at all, but knowing about it is a great addition to your programmer's toolbox.

Remember, good architecture isn't about using every design pattern you know. It's about choosing the simplest solution that solves the problem in front of you.

Let's jump in.

 

10 ScriptableObject Patterns Every Unity Developer Should Know (Part 2) Variable Assets, Ability Definitions, Item Databases

In the previous article, we explored three of my favorite ScriptableObject patterns:

• Data Assets

• Runtime Sets

• Event Channels

If those patterns help organize your project, the next four we're covering today help organize your gameplay. They're all about making your game easier to balance, extend, and maintain without constantly diving into your code.

As with every design pattern, these aren't solutions looking for problems. They're practical techniques that shine in the right situations, and as always, can become overkill if used everywhere.

Let's jump in!