We may earn an affiliate commission when you visit our partners.
Penny de Byl and Penny Holistic3D

What do you think optimisation of a game project is? Do you think it's writing really efficient code or getting your game to run as fast as possible? Is it a task you do days before release or from the very start?  Not sure where to start? Well, this course is for you.

Read more

What do you think optimisation of a game project is? Do you think it's writing really efficient code or getting your game to run as fast as possible? Is it a task you do days before release or from the very start?  Not sure where to start? Well, this course is for you.

Designed for Without even thinking, you'll be pulling up the Unity profiler and investigating CPU and GPU bottlenecks like a pro. You'll find hints and tips on improving the performance of your game starting with the script and moving onto art assets and finally physics. There are plenty of hands-on exercises designed to give you skills in forensic debugging that will be valuable to you far into the future.

This course uses Unity 2020.2 or 2020.3 but is also compatible with Unity 6.

You will learn about:

  • Performance Budgets

  • The Unity Profiler

  • C# Optimisation Tricks for the Unity API

  • Art asset optimisation settings

  • Audio file usage and settings

  • Tips and tricks for getting more from the Unity Physics system

What people are saying about Penny's courses:

  • A great and engaging course that teaches you a lot about the Unity Profiler which is key to optimising the games. It is a valuable skill that people look for. It's in a tutorial format which is my preferred method of learning.

  • Allow me to say how hugely important this is for a person who is interested in certain types of game design. Creating games where you can create AI behaviors that support emergent situations.

  • I honestly love Holistic's teaching approach and I've never learned so much within a few hours about coding effectively with such detailed explanations.

This course focuses on developing student skills in identifying and solving performance issues in their game development projects.  By the end, they will find the use of the Unity Profiler second nature and be able to identify many CPU and GPU bottlenecks in their's and other's Unity projects.

Enroll now

What's inside

Syllabus

In this section you will gain and overview of the course and learn how to join in student discussions in the social media forums.

In this video students will gain an overview of the course contents.

Read more

H3D has a bustling online student community.  Here's how to get involved.

How to contact us

Here's how to get the best experience from studying this course and answers to some popular student questions.

While this course was developed in a previous version of Unity, we've tested the projects and they work with Unity 6. This video is a guide to help you adjust your learning in this course to use Unity 6.

Think you know what optimisation means with respect to computer games development? This section might open your eyes!

In this lecture the teacher will challenge the students to a optimisation task.

In this lecture students will be asked to consider how they approached the exercise in the last lecture and reflect on what they came up with as a solution.

In this lecture students will gain an understanding of what optimisation is and how important it is to always be considered part of a project.

In this video students will learn how a frame is defined and how to work with frames per second and milliseconds to define them.  They will also discover the role that the CPU, GPU and VSync play in determining frame rate.

In this video students will learn what goes into the creation of a performance budget and the items they must consider right from the start of their game project.

By the end of this section students will be familiar with the Unity profiler and how to launch and read the data produced.

In this lecture students will be introduced to the Unity Profiler and taught how to connect it with development builds as well as how to get it up and running.

In this lecture students will take a closer look at the hierarchy view in the profiler to identify where their code is running.

In this lecture students will learn where to find the performance markers for the GPU.

By the end of this section students will have learned where performance savings can be made with scripting for the Unity API.

In this lecture students will develop a strategy to test different versions of API calls to determine the one that gives the best performance.

In this lecture students will be challenged to use the skills they've learnt thus far to test the performance of other lines of code.

In this lecture students will learn what it means to cache values at the beginning of code to use later in updates to reduce expensive method calls.

In this lecture students will be challenged to test their understanding of caching.

In this lecture students will learn how to question if one method of coding is more optimised than another and trial the code out to check for performance metrics.

In this lecture students will learn how to use Coroutines to increase performance when running AI behaviour script.

In this lecture students will gain an understanding of what garbage collection is and how it affects the performance of their projects.

In this lecture students will force the creation of garbage to see how it effects memory cleanup.

In this lecture students will learn that even testing for a null game object can effect performance.

In this lecture students will learn about the costs in performance incurred by using strings.

In this lecture students will examine two specific cases in the Unity API that allow the use of integer values over strings and how to implement these for the best performance.

In this lecture students will discover if the performance optimisation strategies they applied to the challenge were correct.

In this lecture students will discover which method of comparing a game object's tag is more efficient and why.

By the end of this section students will have extended their understanding of several design patterns, algorithms and data structures that improve performance.

In this lecture students will learn how to create a static class and use it in place of an actual singleton.

In this lecture students will learn how to turn a global management class into a pure singleton.

In this lecture students will begin performance testing with Arrays, Dictionaries, Lists and HashSets in order to determine which one is better based on their use.

In this lecture students will discover how different container data structures perform in searching and removing items.

In this lecture students will learn how to create a very simple object pool.

In this lecture students will learn how to repurpose the object pool for different game objects.

In this lecture students will discover the difference in performance between using structures and classes.

In this lecture students will investigate uses of structures that don't help improve performance.

In this lecture students will learn how to use visibility and distance to enable and disable scripts to optimise performance when many NPCs are in the game world.

By the end of this section students will have gained an understanding of how they can optimise art assets and rendering to speed up their frame rates.

In this lecture we will take a quick look at the frame debugger in the profiler and how you can quickly identify one common performance affecting setting.

In this lecture students will get an overview of the render pipeline and the processes that occur within it.

In this video Unity's different rendering pipelines will be explained and the difference between forward and deferred lighting discussed.

In this lecture students will learn about drawcalls and begin investigating the things that game objects and properties that cause them.

In this lecture students will learn how GPU Instancing and Batching can improve on a games graphics performance.

In this lecture students will learn how UV values and texture atlases work and try them out with respect to a cube filled world.

In this lecture students will learn how to combine meshes at runtime to provide better performance.

In this lecture students will revisit all the methods covered concerning drawcalls and batching and consider what could be best for their project.

In this lecture students will learn how to use the tools in Unity to optimise the use of sprites.

In this lecture students will learn the best way to use mipmaps in their games.

In this lecture students will learn how level of detail works and how to set it up in Unity.

In this lecture students will test out the performance between using LODs over a single model for rendering at distances.

In this lecture students will learn how to optimise the user interface of their game project through understanding how canvases batch and redraw.

By the end of this section students will understand the best format for game assets as well as some tweaks for optimising audio.

In this lecture students will learn why it is important to work with image files with sizes that are powers of 2.

In this lecture students will learn about how audio files are loaded, how to control this process and how the size of audio files effects memory usage.

In this lecture students will learn some extra tips for enhancing the performance of audio in their game projects.

By the end of this section students will have discovered areas within the Unity physics system where performance savings can be achieved.

In this lecture students will learn why different collider types are more efficient than others and experiment with their profiling.

In this lecture students will learn how to use less colliders in a rag doll to optimise performances as well as a way to introduce layers for even more performance.

In this lecture students will learn about some extra tweaks they can make to speed up the physics effects in their game projects.

By the end of this section students will have revised the content of the course and been given some suggestions of where to continue their studies.

In this lecture Penny will do a wrap up of the course content.

This link provides further information on the courses you can look at taking based on your interests and skill level.

Save this course

Save The Ultimate Guide to Video Game Optimisation to your list so you can find it easily later:
Save

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in The Ultimate Guide to Video Game Optimisation with these activities:
Review C# Fundamentals
Strengthen your understanding of C# fundamentals to better grasp the scripting optimization techniques taught in the course.
Show steps
  • Review basic C# syntax and data types.
  • Practice writing simple C# scripts.
  • Familiarize yourself with object-oriented programming concepts.
Review 'Unity in Action, Third Edition'
Deepen your understanding of Unity and its features to better optimize your game projects.
Show steps
  • Read chapters related to performance optimization.
  • Experiment with the techniques in a sample Unity project.
  • Apply the techniques to your own game projects.
Review 'Game Programming Patterns'
Learn common game programming patterns to write more efficient and maintainable code, improving game performance.
Show steps
  • Read chapters related to optimization patterns.
  • Implement the patterns in a sample Unity project.
  • Analyze the performance impact of each pattern.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Profile and Optimize a Simple Scene
Apply the Unity Profiler skills learned in the course to identify and resolve performance bottlenecks in a basic game scene.
Show steps
  • Create a simple Unity scene with basic objects and scripts.
  • Use the Unity Profiler to identify CPU and GPU bottlenecks.
  • Implement optimization techniques to improve performance.
  • Re-profile the scene to verify the improvements.
Document Optimization Techniques
Solidify your understanding of optimization by creating a guide or cheat sheet summarizing the key techniques covered in the course.
Show steps
  • Review the optimization techniques covered in the course.
  • Create a document summarizing each technique.
  • Include examples and best practices.
  • Share your document with other students for feedback.
Optimize an Existing Game Project
Apply the optimization techniques learned in the course to improve the performance of a real-world game project.
Show steps
  • Choose an existing game project to optimize.
  • Profile the project to identify performance bottlenecks.
  • Implement optimization techniques to improve performance.
  • Re-profile the project to verify the improvements.
  • Document the optimization process and results.
Contribute to Unity Open Source Projects
Gain practical experience in optimization by contributing to open-source Unity projects and addressing performance issues.
Show steps
  • Find an open-source Unity project on GitHub.
  • Identify performance issues in the project.
  • Implement optimization techniques to improve performance.
  • Submit your changes as a pull request.

Career center

Learners who complete The Ultimate Guide to Video Game Optimisation will develop knowledge and skills that may be useful to these careers:
Unity Developer
A Unity developer uses the Unity game engine to create interactive experiences, simulations, and games. This course helps a Unity developer profile and optimize projects within the Unity environment. By understanding the Unity Profiler, the developer can identify and address CPU and GPU bottlenecks. The emphasis on C# optimization tricks for the Unity API specifically enhances a Unity developer's ability to create high-performing applications. The Unity Developer will be able to optimize audio and physics.
Game Programmer
A game programmer brings video game ideas to life through code. This role involves writing efficient and optimized code to ensure smooth gameplay and optimal performance. This course helps develop skills in forensic debugging as well as identifying CPU and GPU bottlenecks. One who wishes to become a game programmer should take this course to understand the Unity Profiler and apply strategies in scripting, art asset usage, and physics to create high-performing games. A game programmer needs to understand performance budgets and how to optimize the Unity API.
Technical Artist
The technical artist serves as a bridge between the art and programming teams, optimizing art assets for performance and ensuring they work seamlessly within the game engine. This course dives into art asset optimization settings and rendering pipelines. A technical artist will benefit from the course's sections on draw calls, batching, texture atlases, and sprite optimization. This course is particularly useful for a technical artist as it explains the various ways to optimize scenes to ensure the art assets are performant.
Mobile Game Developer
A mobile game developer specializes in creating interactive and engaging gaming experiences for mobile devices. These developers usually have to squeeze a highly detailed game into a small computational package. Mobile game development requires a deep understanding of optimization techniques to ensure smooth performance on a variety of devices. This course helps developers to optimize art assets, audio files, and physics interactions to deliver a seamless gaming experience on mobile platforms. This knowledge is useful for a mobile game developer.
Gameplay Engineer
A gameplay engineer focuses on implementing and refining the interactive elements and mechanics of a game. This course will help those who are interested in becoming game play engineers by teaching them how to optimize C# code to increase performance and decrease game lag. The insights into the Unity Profiler equips gameplay engineers with the ability to identify and address performance bottlenecks in their code. A gameplay engineer needs to understand how to create an enjoyable experience for the user.
AI Programmer
An AI programmer is responsible for developing and implementing artificial intelligence systems in games. This course enables a prospective AI programmer to increase performance when running AI behavior script. An AI programmer will benefit from learning about static classes, singletons, and object pools, as well as learning about structures versus classes in Unity since large AI systems can eat up huge computational resources. An AI programmer needs to consider the performance of their AI systems.
Graphics Programmer
A graphics programmer specializes in the visual aspects of video games, focusing on rendering techniques, shader development, and optimization of graphics performance. This course may prove vital in building a foundation in art asset optimization settings, understanding the render pipeline, and optimizing UI elements. Understanding draw calls, GPU instancing, and batching directly applies to the responsibilities of a graphics programmer. This course will give a graphics programmer a better understanding of level of detail allowing them to optimize performance.
Extended Reality Developer
An extended reality developer creates immersive experiences using virtual reality or augmented reality technologies. Optimization is paramount in XR development to achieve comfortable frame rates and prevent motion sickness. This course helps developers to identify and address CPU and GPU bottlenecks, optimize art assets, and fine-tune physics interactions for optimal performance. An extended reality developer should take this course to learn about what to optimize.
Simulation Engineer
A simulation engineer develops and optimizes simulations for various purposes, such as training, research, or entertainment. This role often involves creating realistic and high-performing simulations. This course will help a simulation engineer by teaching them about physics, art assets, and audio optimization. The in-depth coverage of the Unity Profiler and performance budgeting helps fine-tune simulations for optimal performance. A simulation engineer needs knowledge of these domains.
Game Designer
A game designer is responsible for the overall design and player experience of a video game, making decisions about gameplay, mechanics, and level design. While not directly programming focused, optimization awareness is crucial for a game designer. This course helps a game designer to understand performance constraints and how to balance visual fidelity with frame rate by understanding performance budgets. A game designer can use this knowledge to make informed design decisions that lead to optimal performance by considering the trade-offs with art assets.
Software Engineer
Software engineers apply their knowledge of computer science to build software and applications. This course provides an overview of performance budgets, the Unity Profiler, and C# optimization tricks for the Unity API. Software engineers work in all sorts of industries and the ones that can write high performance code and debug existing code are valuable assets to any organization. This course may be useful for software engineers who are working on real-time systems or memory constrained systems because it will help them identify performance bottlenecks in their code.
Tools Programmer
A tools programmer creates custom tools and workflows to assist game developers in their tasks, such as level design, art creation, and scripting. This role requires a deep understanding of the game engine and its performance characteristics. This course may be beneficial to a tools programmer because it discusses performance budgets and optimizing the Unity API. A tools programmer can use this knowledge to make tools that are performant and do not slow down the game development team.
Machine Learning Engineer
A machine learning engineer develops and implements machine learning algorithms and models. This role requires an understanding of data structures and algorithms. This course may be helpful to a machine learning engineer since the course discusses data structures and algorithms and the performance metrics of each. A machine learning engineer will benefit from learning about static classes, singletons, and object pools, as well as learning about structures versus classes in Unity.
Backend Developer
A backend developer primarily focuses on developing and maintaining the server-side logic, databases, and infrastructure that support online games. This role helps to ensure seamless multiplayer experiences. While this course is not primarily focused on backend development, a backend developer may find value in the course due to the fact that efficient data structures can help the server run smoothly. This course will help a backend developer understand the performance gains from various data structures.
Quality Assurance Tester
A quality assurance tester identifies and documents defects in software and games. While not directly involved in development, understanding optimization techniques can help testers identify performance-related issues. This course helps a QA tester understand the Unity Profiler and to identify CPU and GPU bottlenecks. A Quality Assurance Tester with this knowledge can provide more specific and actionable feedback to the development team, leading to a smoother player experience.

Featured in The Course Notes

This course is mentioned in our blog, The Course Notes. Read one article that features The Ultimate Guide to Video Game Optimisation:

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in The Ultimate Guide to Video Game Optimisation.
Provides a catalog of useful design patterns specifically tailored for game development. It offers practical solutions to common problems encountered in game programming, including performance optimization. It valuable resource for understanding how to structure code for efficiency and maintainability. This book is useful as additional reading to provide more depth to the course.
Provides a comprehensive guide to Unity development, covering a wide range of topics including scripting, art asset optimization, and physics. It offers practical examples and step-by-step instructions for building games in Unity. It useful reference for understanding the Unity engine and its features. This book is useful as a reference text to provide more breadth to the course.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.

Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.

Find this site helpful? Tell a friend about us.

Affiliate disclosure

We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.

Your purchases help us maintain our catalog and keep our servers humming without ads.

Thank you for supporting OpenCourser.

© 2016 - 2025 OpenCourser