CF

2048 with Bevy ECS

1h 40m 27s
English
Paid
Updated September 2026

2048 with Bevy ECS is a 25-lesson 1 hour 40 minutes self-paced course by Andrew Schmelyun. Building the classic 2048 board game is used here as a compact, contained way to learn Bevy's entity-component-system model in Rust.

Course facts

Lessons
25
Duration
1 hour 40 minutes
Level
All levels
Language
English
Updated
2026-09-11
Instructor
Andrew Schmelyun
Price
Premium

Building the classic 2048 board game is used here as a compact, contained way to learn Bevy's entity-component-system model in Rust.

What the project covers

  • Spawning and rendering tiles on the screen
  • Handling user input to move and merge tiles
  • Keeping score and querying game resources

Because the game logic stays small, it also doubles as a focused playground for core Rust concepts like references and ownership, which come up naturally as you wire up Bevy's systems.

Additional

https://github.com/rust-adventure/2048

Who teaches 2048 with Bevy ECS? Andrew Schmelyun

Andrew Schmelyun thumbnail

Andrew Schmelyun is a US developer and Laravel / DevOps educator who publishes long-form tutorial content on the Laravel-with-Docker stack and on the engineering side of running PHP services in production. His written tutorials and YouTube videos cover the operational concerns most Laravel material skips.

His CourseFlix listing carries three Andrew Schmelyun courses: Develop and Deploy Laravel Applications with Docker, Self-Made SaaS Course (a from-scratch Laravel SaaS build), and the unrelated indie game-dev 2048 with Bevy ECS. Material is paid and aimed at PHP developers ready to take operational responsibility for their own services.

What lessons are included in 2048 with Bevy ECS?

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Initializing a new Bevy Project
All Course Lessons (25)
#Lesson TitleDurationAccess
1
Initializing a new Bevy Project Demo
02:27
2
Changing the name of the Window
02:02
3
Adding a 2d Camera
02:02
4
Spawning the 2048 Board
03:49
5
Using Color to change the look of the board
01:42
6
Changing the color of the background
01:21
7
Filling out the board with tile placeholders
06:28
8
Defining associated functions on structs
02:44
9
Spawning Tiles with rand to Start the Game
07:01
10
Showing Point values on Tiles
04:33
11
Updating Tile display when Point values change
03:49
12
Listening for keyboard input
04:45
13
Sorting tiles with Ord
03:32
14
Updating tile Position with Transforms
06:05
15
Board Shifts in 4 directions
01:54
16
Spawning new tiles with events
07:09
17
Keeping Score
05:42
18
Setting up the UI around the game
01:29
19
Live Updating the Score Display
06:39
20
Are there any moves left?
01:06
21
Playing, GameOver, and other states of play
08:12
22
Interactive Button systems
02:36
23
Starting a new game
07:44
24
Tracking High Scores
02:21
25
Animating tiles when board shifts happen
03:15
Unlock unlimited learning

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

Learn more about subscription

What courses are similar to 2048 with Bevy ECS?

More courses by Andrew Schmelyun

Frequently asked questions

What prerequisites are needed for the course?
A foundational understanding of the Rust programming language is recommended before taking this course. The course involves concepts such as references and ownership, which are integral parts of Rust. Familiarity with these concepts will help in grasping the Bevy ECS framework used to build the 2048 game.
What will I build during the course?
Participants will build a version of the 2048 game. The course covers spawning tiles, handling user input, keeping score, and implementing various game states. It integrates foundational Bevy concepts to create a 2D board game environment, complete with interactive elements and a scoring system.
Who is the target audience for the course?
The course is ideal for developers interested in game development using Rust and the Bevy ECS framework. It's suitable for those who have an understanding of Rust and want to explore how to apply it in game development environments, specifically for building board-oriented games like 2048.
How does the course depth compare to similar courses?
This course provides a focused approach to building a specific game, 2048, using Bevy ECS. While it may not cover advanced game development concepts, it offers a practical introduction to Bevy systems and Rust language concepts, providing a good starting point for beginners in game development.
Which specific tools or platforms will I use?
The course uses the Bevy ECS framework extensively for game development. Participants will learn to initialize a new Bevy project, manipulate 2D cameras, and handle various game dynamics through Bevy's systems. The course also incorporates the Rust programming language to manage game logic and structure.
What topics are not covered in the course?
The course does not cover advanced game development topics such as 3D graphics, multiplayer networking, or mobile platform deployment. It focuses specifically on 2D board game mechanics using Bevy ECS and Rust, which is suitable for beginners looking to grasp the basic concepts.
Can the skills learned in this course be applied to other areas?
Yes, the skills acquired in this course can be transferred to other areas of game development and software engineering. Understanding Bevy ECS and Rust's concepts of references and ownership will be beneficial in other projects that require efficient memory management and game state handling.