A game’s performance is a lot like your appendix… you only notice it when something is wrong. And when it is wrong, it becomes all that you can think about. The game stops being fun because lag makes it feel unfair or unengaging and, as developers ourselves, our greatest fear is ruining a player’s experience.

There are a lot of things we do at Admix to prevent that, and they’re usually subtle behind-the-scenes features that users will never think about. Some examples: the fact that our plugin is just 1mb in build, the intricacies of our sophisticated ad renderer during runtime, and – the focus of today’s article – something that we’ve started calling Smart Load.

What is Smart Load?

Because In-Play ads are placed within a game scene non-intrusively, there are far fewer limits on developers as to how many ads they can place in their game. A 30-second interstitial now and then is okay, but having one for every 10 seconds of gameplay will ruin a game’s retention. In-Play doesn’t have that problem because it doesn’t interrupt anything, so they don’t impact retention at all. Because of that, some of our partner developers place upwards of 100 ads in their game scenes and if we were to try and render all those ads all the time, that game’s performance would tank.

Smart Load is the solution to that problem, only rendering the ads closest and most visible to the player to minimize CPU impact during runtime.

Before we explain the equation behind that, it’s good to understand the actual lifecycle of ad placements in general during runtime.

The technical lifecycle of an In-Play ad

Before the player enters the scene

When a player loads a scene that includes In-Play ads, before any graphics of any kind are rendered, all ad placements in that scene are subscribed to the Smart Load feature. In other words, Smart Load is made aware of all potential ad locations in the 3D space so that it can calculate what ads to render and when to render them in relation to the primary player camera.

Smart Load queues and renders ads

Imagine a sphere around the player character’s primary camera. This sphere is invisible to the player, but any In-Play ad placement that enters that sphere triggers Smart Load to initiate the adRequestExecutor script and dynamically request, bid for, purchase, and render (via a second script called LoadAndRender) an appropriate ad in less than a frame of gametime. The sphere is big and intelligent enough to ‘hide’ ads loading so that this entire process is invisible to the player.

We’ll go more in-depth on the renderer in a future article.

Note that adRequestExecutor runs sequentially not concurrently, so only one ad request is being made at a time. This also keeps CPU load low, but also makes the fact that ad loading is generally unnoticeable to players even more impressive. At times, a sequence of more than ten ads could be queued in the adRequestExecutor via Smart Load and all render before the player knows that anything even happened.

The moments immediately after an ad is rendered

As part of the LoadAndRender script, each individual ad placement will be given a tracker which our servers pick up, allowing us to display data for each individual placement on the Developer Platform – a custom portal for developers to track and manage their placements.

At the same time, a rotation counter starts that determines when a new placement is bidded on and rendered (assuming the player is still close enough for Smart Load to take effect). The gaze process also begins which measures each ad’s individual viewability, which is essentially a measure of how visible an ad is in relation to player character based on several data metrics – but that’s a topic for another in-depth article too.

An ad placement moves out of Smart Load’s area of influence

Once an ad leaves Smart Load’s “sphere”, it becomes inactive which frees up CPU for the game as a whole.

Throughout this entire process, Smart Load is constantly managing ad load and queuing to minimize the impact on a game to unnoticeable levels.

Just how smart is Smart Load?

By this point, you know that this clever feature is constantly watching a game’s environment to maximize performance through intelligently loading ads. While that’s accurate, it’s actually a massive simplification of the many, many things that Smart Load does on a moment-by-moment basis.

For example, imagine a scenario where a player enters a game scene and there are 100 ads in Smart Load’s “sphere of influence”. The ads are pointing in all directions, some are tiny, some are huge, some are hidden behind game objects (which would be picked up by our ad fraud detection measures anyway). Long story short, there are ads everywhere. It wouldn’t be that smart of Smart Load to bid on and render ALL of these placements because many of them won’t actually be visible to the player, so how can Smart Load prioritize which ones to load with ads?

In order to know which of these placements is most visible, we need to determine how much screen space each one fills up. That’s a lot easier to say than do in a 3D environment, because even a huge ad placement can take up a tiny amount of screen if it’s far away. And of course, players might be looking at these ads at any angle you can imagine which further complicates screen real estate calculations.

We can get around both of these issues by theoretically rotating the ad placement to face the player camera and measure a*b / w*h – where a and b are the placement’s dimensions and w and h are the player’s viewport dimensions.

Smart Load Admix

Through this metric, we can dynamically sort all ads on screen based on how viewable (and therefore valuable) they are, then select around 10 of them to render. All other placeholders are released from the render queue to, once again, minimize CPU impact but Smart Load is constantly checking to see if these alternative placements become more viewable than one that’s currently being rendered.

And that’s not all. The parameters of that ‘sphere of influence’ can be tweaked on our side in the backend (essentially changing the radius of effect) to adapt to different genres or settings. That also allows you to find your game’s balance between maximum profit and maximum performance.

One piece of an even smarter whole

Smart Load, or The Priority Manager as some of our devs still call it, is a big part of what makes the Admix plugin so efficient. 

But it’s far from the only part.

This article should have given you an initial understanding of just how much problem solving is involved on a moment-to-moment basis, but stay tuned for more in-depth articles on our pioneering tech coming soon.



Jump in, it's freeeeee 🎉

You’re in good company. Over 500 game devs
worldwide are working with us already!

Get started


Admix Discord

Come and chat with other game devs or throw your questions at the Admix team.

Facebook Group

Learn from our group of 10,000+ creators and founders as they build brilliant games.


Watch the latest videos in our home-grown series What a Game, In-Game Monetisation, and Game Day.

Stay on top of the game! 🎮

The latest game industry trends & updates every Friday in your inbox (no spam).

Secured By miniOrange