.avif)
Centegix
Retroware, a creative force in retro-inspired gaming, partnered with solo developer Ivan Suvorov to bring Iron Meat to life—a high-octane, Contra-like run-and-gun side scroller with couch co-op gameplay. Designed for both nostalgia and performance, Iron Meat blends pixel-perfect visuals with chaotic action and modern accessibility.
When Retroware took on publishing duties, the game’s design foundation was solid—but the technical infrastructure needed refinement. Azumo was brought in to help scale the project for commercial release, with responsibilities spanning optimization, feature development, and cross-platform porting.
The Challenge
At the time of engagement, the game was already deep into development. Integrating a new team midstream meant navigating legacy systems, solving persistent performance issues, and introducing best practices without derailing existing work.
One of the most pressing issues was related to performance. The camera setup - initially composed of three separate Unity cameras - created rendering challenges and frame rate drops. This, combined with inefficient canvas rendering, led to unstable visuals that could impact gameplay. Additional optimization pain points were buried within animation systems, level loading, and frequent object spawning—all of which taxed the engine and reduced responsiveness.
The structure of the codebase also presented complications. Much of the logic relied on MonoBehaviour Update loops and static classes, and all scripts were located in the root /Assets folder. With minimal use of design patterns and no modular architecture in place, making even small changes introduced unnecessary risk. Refactoring had to be done with care.
Beyond performance and code structure, Retroware was preparing the game for a broad commercial release—spanning Steam, Epic Games Store, GOG, PlayStation 4 and 5, Xbox One, Xbox Series consoles, and Nintendo Switch. Each platform introduced its own set of requirements, SDKs, environment variants, and integration challenges. Managing these without duplicating projects across environments would be critical to keeping development sustainable.
Their team consistently brings thoughtfulness, professionalism, and ownership, making them a valued extension of our internal team.
The Solution
Azumo embedded as a cross-functional development partner, working across optimization, system architecture, tool creation, and platform porting. Their approach brought long-term scalability without disrupting the creative intent of the game.
Optimization Overhaul
The team restructured the camera system from three to two—one for gameplay and one for rendering to texture. This improved render accuracy and cut performance waste. Canvas rendering was reworked using world-space and overlay strategies, stabilizing frame rates and fixing UI shader issues.
Figure 1. Camera Optimization Strategy
The original setup relied on three cameras, leading to instability and visual artifacts. Azumo implemented a streamlined two-camera configuration—one focused on gameplay logic, the other dedicated to rendering output via texture mesh—to stabilize pixel rendering and reduce resource load.
They also implemented a chunk-based culling system, subdividing levels and enabling/disabling animators only when visible. Flipbook animation replaced Unity’s default Animator system, significantly improving runtime efficiency—especially for high-volume sprite skins. Bullet and enemy systems were pooled and baked for fast reuse, with input calls and collision checks cached for additional gains.
Developer Tools and Feature Expansion
To improve iteration and QA, Azumo introduced a custom in-game console for live debugging, cheats, teleportation, and data testing. A dev dashboard accessible via shortcut enabled rapid testing across systems.
Figure 2. In-Game Debug Console for QA
Built directly into the game using Unity’s UI Toolkit and a console asset, this tool allowed testers to manipulate variables, skip levels, and simulate edge cases—all without leaving the game environment. It became critical for QA speed and coverage, especially across multiple platforms.
Additional tools included:
- Search for References Tool for asset cleanup and refactoring
- Custom Game Design Data Importer using Unity’s Scripted Importers
- Platform-Aware Input System with rebinding and localization support across 13 languages
- Full UI navigation compatibility for keyboard, mouse, touchscreen, and gamepads
Code organization was transformed using assembly definitions and DLLs, reducing build times and clearly separating platform dependencies.
Intelligent Porting Strategy
Rather than create separate Unity projects for each platform, Azumo implemented a streamlined environment management approach using C# preprocessor directives, define constraints, and partial classes. This modular method allowed different platform behaviors (e.g., saving, achievements, SDK integration) without code duplication—ensuring compiler errors surfaced early and avoided semantic bugs later in QA.
Console SDK integration was conducted using official dev kits and NDA-restricted documentation. Azumo handled performance testing, integration of achievements and activities (such as PS5’s Rich Presence), save systems, localization hooks, and metadata systems per platform.
Figure 3. Unified Multi-Platform Build Strategy
Instead of duplicating Unity projects across platforms, Azumo implemented a modular architecture using preprocessor directives, partial classes, and assembly definitions. This allowed one codebase to serve all platforms—avoiding rework and making platform-specific debugging far more manageable.
Results
The collaboration between Azumo, Retroware, and Ivan Suvorov transformed Iron Meat from an indie prototype into a robust, scalable, and shippable multi-platform product.
Performance Stabilization
Frame rate issues caused by Unity’s rendering pipeline and animator overload were eliminated, making the game stable even under high-intensity gameplay.
Cross-Platform Readiness
A single, unified codebase was used to deploy across 8+ platforms and distribution variants, from DRM-free demos to console stores - dramatically reducing overhead.
Faster QA and Debugging
In-game debugging tools and the dev dashboard accelerated iteration, reduced bug turnaround time, and empowered testing teams across environments.
Technical Maturity
What started as a hobby project evolved into a professionally-structured codebase ready for commercial launch - with flexible systems that future-proof the game for updates and expansions.
The Iron Meat project showcased how a structured, collaborative development model can transform a technically ambitious indie game into a scalable, platform-ready product. Azumo’s work across optimization, tooling, and porting delivered a unified codebase, improved performance, and the flexibility to meet multi-platform demands without compromising the game’s creative intent.
This case study highlights the value of embedding experienced engineering teams mid-project, demonstrating that with the right technical strategy and hands-on execution, even complex legacy systems can evolve into production-grade releases across console and PC platforms.
