CF

Learn Unity DOTS and Make an Awesome Game!

18h 40m 50s
English
Paid

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
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)

You can watch up to 10 minutes for free. Subscribe to unlock all 90 lessons in this course and access 10,000+ hours of premium content across all courses.

Watch all 90 lessons from $6.67/mo
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
Unlock unlimited learning

Get instant access to all 89 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

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

More courses by Code Monkey (Hugo Murracas cardoso)

Frequently asked questions

What Unity or programming knowledge should I have before enrolling?
The supplied material does not state formal prerequisites or a required level of programming experience. Setup lessons cover Create Project and Install Packages, Unity Layout, Visual Studio Setup, and Assets Import. The sequence then moves into DOTS Subscene Baking, components, systems, physics, and jobs. Familiarity with Unity projects and programming concepts would therefore be useful preparation, but it is not listed as an enrollment requirement. The stated learning goal is a transition from traditional object-oriented development to organizing data and computations around Data-Oriented Design.
What game and mechanics will I build during the course?
The practical project is an RTS game built with Unity DOTS. Named lessons cover Click to Move, single and multiple unit selection, enemies and factions, target finding, shooting, health, bullets, melee attacks, and Entity Spawning. A Zombie Spawner and Random Walking add enemy behavior, while building lessons include a tower, barracks, HQ, and a Building Placement Manager with UI. The description also identifies dynamically updated Fog of War, a zombie horde with hundreds or thousands of characters, and Flow-field Pathfinding for large groups of units.
Is this course relevant if I already make games with traditional Unity GameObjects?
The course is positioned around moving from a traditional object-oriented approach to Data-Oriented Design, making that transition a central reason to consider it. The description explicitly includes combining DOTS with classic GameObjects rather than treating them as unrelated workflows. Its examples focus on RTS units, zombie hordes, and systems with large numbers of objects. If the goal is to understand how entities, components, systems, jobs, and data preparation fit into Unity development, those topics are named in the material. No specific professional experience level is stated.
How does the scope differ from a short DOTS introduction?
The supplied outline extends beyond explaining What is DOTS into a connected game project. It lists 90 lessons, with the first 60 progressing from setup and unit movement to combat, animation, and buildings. Topics include RequireForUpdate, Converting Systems to Jobs, Blob Assets, Animation Event Logic, and Animation Baking. The description also names the Burst Compiler, Entity Queries, Flow-field Pathfinding, and a custom DOTS Event System. That establishes a broader project-based scope than an introductory overview, although the material does not provide a direct comparison with any particular competing course.
Which tools and Unity technologies are explicitly included?
Unity and Visual Studio are explicitly named, with lessons for project creation, package installation, editor layout, and development environment setup. The DOTS technologies listed include Entities, Components, Systems, the Baking System, the Job System, and the Burst Compiler. Physics work includes DOTS Physics Raycast and Unit Move Physics. Animation lessons cover Blob Assets, storing multiple animation data, changing animations, animation events, jobs, and baking. The supplied information does not specify Unity or package version numbers, so it cannot establish compatibility with a particular existing project configuration.
Does the supplied outline include multiplayer networking or publishing to a specific platform?
Neither multiplayer networking nor deployment to a named platform is identified in the supplied description or the first 60 lesson titles. The listed work instead focuses on local game systems such as unit selection, movement, targeting, combat, animation, spawning, and building placement. No lessons shown name matchmaking, network synchronization, dedicated servers, or store publishing. Because the course has 90 lessons and only the first 60 are provided, this is a limitation of the available information rather than proof that those subjects never appear. Platform support is also unspecified.
Which concepts could carry over to other Unity projects or further study?
The transferable topics named in the material include Data-Oriented Design, entity-component-system organization, data preparation through baking, multithreaded task distribution with the Job System, and optimization with the Burst Compiler. Entity Queries and data filtering are also listed. Practical examples such as Converting Systems to Jobs, Entity Spawning, DOTS Physics Raycast, and Animation Baking connect those concepts to game systems. The description links DOTS to large object counts and complex simulations, so the subject matter is relevant beyond the RTS example. No job placement or career outcome is promised.