The process of improving something to make it more effective or efficient.
The process of improving something to make it more effective or efficient.
Optimization refers to improving performance without sacrificing quality. Many discussions focus on "poor optimization" when games don’t run smoothly, but the reality is that results vary widely depending on hardware and settings. Creating a simple app with high-resolution video can highlight how well software handles different environments. Just because assets differ across engines doesn’t mean something is unoptimized—balance between quality and efficiency matters most. Smaller teams often struggle to test and scale for thousands of configurations, so focusing on core performance gains is key.
Optimization mainly involves balancing quality and performance. In games, this is usually achieved by minimizing less noticeable graphics elements such as AO or lighting, which slightly reduce visuals but boost overall speed. For instance, you can achieve 90% of the quality with 30% more performance by lowering the lighting quality from ultra to high. (Red Dead Redemption 2)
Optimization involves incorporating tailored scripts and shifting away from standard code. A customized driver might handle a particular task four times quicker than a generic version thanks to specific hardware capabilities. Seeking methods to reach the same outcome more efficiently. The quicker data is processed, the more efficient the graphics card becomes. Reducing output at the end while maintaining quality is key. This could mean trimming half of an asset's data—visually unchanged yet boosting frame rates significantly. If a similar project delivers better results, it’s not optimized. Whether it's assets or engines... the goal is to achieve comparable quality with improved performance. A game doesn’t need a full engine; it just simplifies future development. For those using public engines like Unreal, Unity, Godot, etc., you’re largely dependent on developers. Choosing an unoptimized engine shifts responsibility to them. That’s why game engines are valuable—they get refined over time, and your focus should be where it matters most in creation.
Because titles have different requirements and titles function uniquely, the system powering Red Dead Redemption must excel at creating expansive open worlds quickly. This ensures smooth loading so there are no noticeable breaks in the experience. Conversely, the RE Engine used for Resident Evil might not suit games needing such breadth, as it’s designed for more limited, semi-open environments typical of certain styles. I’ll describe my project as unoptimised if it struggles on both budget and high-end systems, fails to scale across different CPU configurations, or shows little improvement between low and ultra settings. You can’t fully address these issues in PC gaming. While we often grumble about game performance problems at launch, it’s impossible to cover every possible setup—100 CPUs, 50 GPUs, countless RAM options spanning multiple generations with various drivers. This complexity is why consoles or tightly controlled platforms like Apple’s are more appealing for development. There’s usually just one or a few viable configurations; the more options, the harder it becomes to optimize. Optimisation splits into two areas: actual improvements—like crafting faster algorithms or hardware for specific tasks—and increasing efficiency, which means minimizing wait times while doing work. Beyond engines, this includes solutions such as Nvidia’s RT cores for real-time ray tracing or technologies like DirectStorage and resizable BAR support to ease loading challenges.
I once developed a Java program for playing Go. One of the toughest challenges was handling the board updates when stones were removed. To simplify coding, I re-drew the entire board state each time a move occurred. This ensured any removed pieces were cleared and kept the visual representation in sync with reality. While functional, this approach was inefficient and slow compared to what it could have been. It was especially noticeable on older systems, though it was clear even on my main desktop. The game would refresh completely whenever a stone was placed, because everything was redrawn from scratch. After realizing the issue, I optimized the process by determining which stones were removed and updating only those specific areas instead of re-rendering the whole board. This required significant effort, possibly more than writing the graphics itself. The result was a much smoother experience across all devices. This example highlights why many games are released with limited optimization—prioritizing speed over performance. If a game focuses mainly on quick execution, it tends to be poorly optimized. Conversely, those that prioritize smoothness generally achieve better results.