CF

Learn Unity DOTS and Make an Awesome Game!

18h 40m 50s
English
Paid
Added to CourseFlix

Learn Unity DOTS and Make an Awesome Game! is a 90-lesson 18 hours 40 minutes self-paced course by Code Monkey (Hugo Murracas cardoso). Master Unity DOTS and create large-scale high-performance gaming systems based on the principles of Data-Oriented Design .

Course facts

Lessons
90
Duration
18 hours 40 minutes
Language
English
Added to CourseFlix
October 2026
Instructor
Code Monkey (Hugo Murracas cardoso)
Price
Premium

Master Unity DOTS and create large-scale high-performance gaming systems based on the principles of Data-Oriented Design. This course will help you transition from the traditional object-oriented approach to a modern way of organizing data and computations that unlocks the full potential of Unity.

What Unity DOTS is and why it's needed

Unity DOTS is a tech stack developed for creating games with a vast number of objects, complex simulations, and high-performance demands. DOTS is based on multithreading, efficient data organization, and a high-level optimization compiler.

What you will learn in this course

Mastering key Unity DOTS technologies

  • Creating Entities, Components, and Systems
  • Using the DOTS Baking System for data preparation
  • Working with the Job System for task distribution across threads
  • Code optimization using the Burst Compiler
  • Building Entity Queries and effective data filtering
  • Combining DOTS with classic Game Objects
  • Using DOTS Physics and Raycasting
  • Creating and configuring Entity Spawning systems
  • Working with the DOTS Animation System
  • Implementing Flow-field Pathfinding for massive units
  • Creating your own DOTS Event System

Practice: creating an RTS game

During the course, you will develop a full-fledged RTS game using DOTS and implement many key game mechanics.

What will be created during development

  • Unit selection and control system
  • Fog of War with dynamic updates
  • A zombie horde with hundreds and thousands of characters
  • Construction of buildings and infrastructure
  • Resource management system
  • Mini-map with event display
  • Unit production queue
  • Various types of combat and work units
  • Defensive structures

Skill level requirements

The course is not intended for beginners. Unity DOTS requires an understanding of basic C# and confident work with Unity. It's recommended to first master the basic concepts of Game Objects, scenes, components, and project architecture.

Who this course is for

  • Developers at the Intermediate and Advanced levels
  • Those who want to enhance their game's architecture
  • Those aiming to create large-scale projects with thousands of objects
  • Those looking for modern approaches to optimization and performance

By mastering Unity DOTS, you will be able to create next-level games — fast, large-scale, and technologically advanced.

Who teaches Learn Unity DOTS and Make an Awesome Game!? Code Monkey (Hugo Murracas cardoso)

Code Monkey (Hugo Murracas cardoso) thumbnail

Code Monkey is an educational project focused on game development using Unity, created by independent developer Hugo Cardoso. The project is aimed at teaching game programming in C# and working with the Unity engine, from basic principles to advanced architectural solutions.

The main feature of the school is its practical approach: instead of separate, disjointed lessons, students create complete game projects, learning not only the Unity API but also design principles, optimization, building game systems, and writing maintainable code.

Code Monkey's materials include free video tutorials on YouTube, full paid courses, articles, and project examples. Over the years, the project has become one of the most well-known independent educational resources for Unity and C#.

Before launching the educational project, Hugo released his own games through the studio Endless Loop Studios, and then focused on creating educational materials. His teaching style is based on explaining the reasons behind engineering solutions, rather than just demonstrating ready-made code.

In his courses, Hugo pays close attention to:

  • the architecture of game projects;
  • SOLID principles and clean code;
  • event-driven systems;
  • performance optimization;
  • building scalable game mechanics;
  • practical application of modern Unity features.

Today, Code Monkey is considered one of the most authoritative independent educators in Unity training, and his free materials and courses are widely used by both beginner and experienced game developers to enhance their skills.

What lessons are included in Learn Unity DOTS and Make an Awesome Game!?

This is a demo lesson (10:00 remaining)

Watch the first 10 minutes free. One payment unlocks all 90 lessons here and every other premium course. No auto-renew.

View Pricing
0:00
/
#1: Welcome
All Course Lessons (90)
#Lesson TitleDurationAccess
1
Welcome Demo
02:15
2
Final Game Playthrough
03:47
3
Overview
13:40
4
What is DOTS
11:32
5
Create Project and Install Packages
04:57
6
Unity Layout
06:06
7
Visual Studio Setup
04:58
8
Assets Import
03:14
9
Post Processing and Lighting
03:38
10
Setup Complete, Download Project Files
01:48
11
DOTS Subscene Baking
13:35
12
Create Component and Unit setup
20:55
13
Unit Mover System
16:14
14
Unit Move Physics
09:53
15
Intermission
00:48
16
Mouse World Position
10:48
17
Click to Move
21:38
18
Move Job System
17:06
19
Unit Selection Single
23:35
20
Unit Selection Multiple, UI Setup
23:25
21
DOTS Physics Raycast
16:55
22
Generate Move Positions
10:50
23
Unit Events
16:16
24
Enemies, Factions
09:06
25
Find Target and Shooting
23:55
26
Health
16:53
27
Bullet
13:29
28
Entity Spawning
17:14
29
Shooting Improvements
13:32
30
Zombie Spawner
08:16
31
Random Walking
16:32
32
Health Bar
20:56
33
Shoot Light
10:02
34
Melee Attacks
17:26
35
Move Override
12:42
36
Part 1 Fixes
05:15
37
RequireForUpdate
03:32
38
Find Target Closest
07:12
39
Lose Target
04:45
40
Target Override
09:50
41
Set Target when Hit
02:59
42
Converting Systems to Jobs
19:14
43
Animation System Overview
04:01
44
Animation System Basics
08:33
45
Blob Assets
12:43
46
Storing Multiple Animation Data
11:51
47
Changing Animations
04:39
48
Animation Event Logic
09:35
49
Attack Animations
10:37
50
Animation Job System
08:58
51
Animation Baking
31:39
52
Unit Scout
05:02
53
Building Zombie Spawner
17:38
54
Building Tower
07:21
55
Building Type SO
07:08
56
Building Barracks
25:02
57
Building Barracks UI
28:35
58
Building Placement Manager
11:05
59
Building Placement Manager UI
18:08
60
Building HQ
14:01
61
Camera Manager
09:15
62
Fix Jobs Memory Leaks
04:32
63
Grid System Overview
03:19
64
Create Grid System
13:12
65
Grid System Debug
16:03
66
Flow Field Pathfinding Overview
06:03
67
Flow Field Pathfinding
16:54
68
Flow Field Debugging
04:55
69
Pathfinding Walls
08:30
70
Unit Follow Pathfinding Overview
02:40
71
Flow Field Follower
12:40
72
Multiple Units Follow Path
07:08
73
Multiple Flow Fields
07:58
74
Pathfinding Raycast Optimization
13:11
75
Pathfinding on All Movement
06:10
76
Pathfinding Update Obstacles
10:52
77
Pathfinding Jobs
40:07
78
Minimap
07:04
79
Fog of War
30:29
80
Resources and Harvesters
28:49
81
Building and Unit Cost
06:37
82
Building Construction
16:07
83
Horde
08:36
84
Ragdolls
14:58
85
Main Menu, Scene Loading
08:52
86
Map Design
06:40
87
Stress Test and Performance Refactoring
16:44
88
Polish
23:38
89
Congratulations on completing the course!
01:34
90
BONUS: Multiplayer
39:54
Watch the other 89 lessons

One payment unlocks this course and every other premium course. No auto-renew.

See plans

What courses are similar to Learn Unity DOTS and Make an Awesome Game!?

More courses by Code Monkey (Hugo Murracas cardoso)

Frequently asked questions

Should I already know Unity before starting?
You'll be better placed if you're comfortable navigating Unity and reading gameplay code. The course starts with project creation, package installation, editor layout, and Visual Studio setup, so you get help setting up the project. After that, it moves into entities, components, systems, and unit movement. If you've only just started programming, those sections may take extra time. The focus is learning a different way to structure game logic, rather than learning programming from scratch.
What kind of game will I actually build?
You'll build an RTS game, with selectable units, movement commands, combat, and buildings. The project also includes dynamically updated fog of war and zombie hordes involving hundreds or thousands of characters. That gives you a practical reason to use DOTS: you're organizing and updating many units rather than working with a single character. Expect to work on gameplay systems as well as performance-oriented code, including spawning enemies, finding targets, handling damage, and placing buildings.
Is this useful if I'm used to working with regular GameObjects?
Yes, especially if you want to explore a different approach to games with lots of active objects or complex simulations. You'll work with entities, components, and systems, shifting attention toward how data is stored and processed. The course also addresses combining DOTS with classic GameObjects, so it isn't limited to treating the two approaches as separate worlds. The RTS project gives you concrete gameplay problems to work through while making that transition.
Does it go beyond a basic introduction to DOTS?
Yes. You start with setup and the core entity-based structure, but the work extends into threading with the Job System, optimization with Burst, physics, animation, and flow-field pathfinding for large groups of units. You'll also build a DOTS event system. The emphasis is applying those techniques within an RTS project, not just understanding the terminology. For example, converting systems to jobs connects the threading work to gameplay logic you've already been developing.
What tools and Unity systems will I be working with?
You'll work in Unity, with Visual Studio setup included near the beginning. On the DOTS side, you'll use Entities, the baking workflow, the Job System, and the Burst Compiler. Those serve different purposes: preparing entity data, organizing gameplay logic, distributing work across threads, and optimizing code. You'll also use DOTS Physics and raycasting for gameplay interactions. Package installation is part of the setup, but no particular Unity or package version is specified here.
How much time should I set aside to finish it?
Expect 18 hours and 40 minutes of video across 90 lessons. That's the viewing time, not the total time you'll spend building along. Setting up the project, writing code, testing mechanics, and revisiting unfamiliar DOTS concepts will add to it. There's no fixed completion schedule given, so plan around your own pace. If you want to implement the RTS systems yourself rather than only watch, leave room between videos to try things in Unity.
What could I use from this course in a different game?
The reusable part is the way you organize data and update large numbers of entities. Entity queries, baking, job-based processing, and Burst optimization aren't tied to RTS gameplay. You'll also practice systems such as spawning, targeting, physics interactions, and animation that can be relevant elsewhere. The project puts those ideas into a specific game, but you can carry the underlying patterns into other Unity projects where many objects need to be processed efficiently.