How to Reduce Playable Ad File Size Without Losing Polish

Most oversized playables are heavy for boring reasons: unresized PNGs, loose sprites, unused engine code, and one feature too many. Here is how to audit a build and cut it down without making it look cheap.

By the PlayableRun team··8 min read

Key takeaways - Weight in a playable usually comes from a few large assets. Find them first with a sorted file list instead of guessing. - Resize every image to the size it is actually displayed, then convert to WebP. Use lossy for backgrounds and lossless only where edges need to stay sharp. - Pack small images into sprite atlases, trim transparent padding, and reuse one asset in several ways (flip, tint, scale) before adding another. - Audio, fonts, unused engine code, and extra levels are the usual hidden costs. Most playables need far less of each than they ship with. - Decide what to leave out at the design stage. Cutting a feature early is cheaper and cleaner than compressing it later.

Why size matters more in a playable than in a video

A video ad streams. It can start playing before it has fully downloaded. A playable generally has to arrive in full before the first interaction works, because the code, the art, and the logic all need to be there.

That has two consequences. A heavy build loads slowly on a weak connection, and a slow load means the player sees a blank or half-built screen and leaves. And networks set their own size caps, so a build that is too large may be rejected outright.

I won't quote caps here. They differ by network and placement, and they change. Check the current spec in the network's own documentation before you start, write the limit at the top of your project notes, and design toward a budget somewhat below it. That leaves room for the last-minute additions that always arrive.

Start with an audit, not with compression

Before you touch a single image, find out where the weight is. Unzip the build (if you're unsure what is inside the package, What Is an HTML5 Ad? What's Inside the ZIP walks through it) and sort every file by size. This works the same whether you hand-built the playable or exported it from a tool like PlayableRun.

You will usually see a pattern:

  • A handful of large images, often backgrounds or character art exported at far more resolution than the screen needs.
  • One or two audio files.
  • A bundled script that includes a whole engine or library, much of it unused.
  • Fonts, sometimes several weights, sometimes with full language coverage.

Write down the rough share each category takes. Start with the largest and work down. Squeezing a small icon set while a huge background sits untouched is wasted effort.

Images: resize first, then change format

Resize to the display size

The most common waste is an image that is much larger than it appears on screen. A background authored for a tablet-size canvas but displayed on a phone, or a character sheet exported at full source resolution, carries pixels no one will see.

Work out the largest size each image is ever drawn at, allowing for high-density phone screens, and export at that size. Do not go further. If an element is only ever shown small, make a small version of it.

Convert to WebP

WebP generally produces smaller files than PNG or JPEG at comparable visual quality, and it supports transparency. That makes it a good default for playable art. The MDN guide to image file types covers the formats and their browser support, and web.dev's guidance on serving WebP explains the practical side.

A few rules of thumb:

  • Lossy WebP suits photographic or painterly backgrounds, gradients, and anything with soft detail. Small artifacts disappear into the texture.
  • Lossless WebP suits flat UI, pixel art, text rendered into an image, and anything with hard edges where compression halos would show.
  • Check alpha edges closely. Lossy compression can leave faint fringes around transparent cutouts, which looks sloppy against a bright background.
  • Compare before and after at the actual display size on a real phone, not zoomed in on a monitor.

Support is strong in current browsers and webviews, but not every older device in your traffic is current. Test on the oldest OS versions you still buy, and keep a fallback plan if a format fails to render.

Reduce color and detail where the eye will not notice

Backgrounds behind a busy foreground rarely need full detail. Blurred or darkened backdrops compress well and also keep attention on the playable object. Heavy noise, film grain, and fine texture are expensive to compress and often add nothing in a few seconds of play.

Sprites: fewer files, less padding, more reuse

Pack into atlases

A sprite atlas combines many small images into one larger sheet and a small data file that says where each sprite sits. It reduces the number of requests and the overhead that comes with many tiny files, and it usually makes rendering cheaper too.

Pack by use, not by type. Everything shown on the first screen belongs together; everything that appears only on the end card can sit in its own sheet.

Trim transparent padding

Exported sprites often carry empty margins. Trim them, and let the atlas data store the offset. Large transparent regions cost size and also waste memory on low-end devices. Be careful about atlas dimensions: some engines prefer certain texture sizes, and an oversized sheet can cost more than two sensible ones.

Reuse before you add

Many assets can be derived from one source:

  • Flip a character or arrow instead of drawing both directions.
  • Tint one gem, coin, or button into several colors in code.
  • Nine-slice a button or panel so one small image stretches to any size.
  • Scale a single glow or particle texture for many effects.

A match-style game rarely needs a unique image for every tile color. A runner rarely needs a separate asset for each lane marker. Ask of every new asset whether an existing one, modified, would do.

Audio: the single file that surprises people

One music track can outweigh the rest of the build. Decide early whether the playable needs music at all. Many users watch with sound off, and a good playable should read clearly in silence anyway.

If you do keep sound:

  • Use one short loop instead of a full track, and make the loop point clean.
  • Prefer a compressed format that current browsers support. The MDN audio codec guide lists the options and trade-offs.
  • Keep sound effects very short, and reuse the same one for similar actions.
  • Trim silence at the start and end of each file.
  • Do not start audio before the first tap. Browsers and webviews restrict autoplay, so sound that waits for interaction is both safer and cheaper.

Fonts, libraries, and code

Fonts

A full font family with every weight and language is a common hidden cost. Use one weight, or a system font stack, where the design allows. If a custom font is part of the brand, subset it to the characters you use. If you localize, remember that subsetting too aggressively breaks other languages, so plan the character set with your translations in mind. How to Localize Playable Ads: Start With Screen One covers what changes per language.

Engine and library code

If the playable runs on a game engine or rendering library, check what ships. Unused modules, debug code, and editor tooling are common. Minify scripts, remove anything the playable never calls, and use tree-shaking if your build tool supports it. A small playable rarely needs physics, a scene editor, and a full UI toolkit at once.

Inlining

Some networks require everything in a single file, which means assets are encoded as text inside the HTML. That encoding makes binary data larger than the original file. If you must inline, compress each asset first, and avoid inlining anything you could drop entirely.

What to leave out

Compression only goes so far. The largest savings come from deciding not to build something. Common candidates:

  • A second level or mode. Most playables should show one core action well and move to the end card. A short loop is easier to understand than a sampler.
  • Long intros and logo animations. They cost size and delay the first tap.
  • Rich particle and screen-shake effects that need several textures. Keep one effect that confirms success and drop the rest.
  • Video clips. If a sprite animation or a few frames can carry the point, use that.
  • Unused states. Fail screens, tutorials for three different mechanics, and settings menus rarely earn their weight.
  • Extra locales in the build. Ship the languages you are actually targeting.

When you are unsure, ask what the player would notice if it vanished. If the answer is nothing, remove it. If the answer is "the game would feel less satisfying," keep the one piece that does that job and drop its siblings. The end card deserves care too, since it is where the install decision happens; see Playable Ad End Card: Design the Last Moments.

A repeatable workflow

  1. Set the budget. Read the target network's current spec and set an internal ceiling below it.
  2. Audit. Sort files by size and note where the weight sits.
  3. Cut features first, then resize, then convert, then compress.
  4. Rebuild after each change and record the new total, so you know what each step bought.
  5. Compare visually on a device, not only in a desktop preview.
  6. Run your QA pass with the final package. Playable Ad QA Checklist Before You Upload covers load behavior, click paths, and the checks that catch problems after compression.

Keep the original, full-quality assets in a separate folder. You will want them when a network spec changes or a new placement needs a different balance.

A short, honest note on tools

Optimization is easier when it is part of the build and not a rescue job at the end. If you generate playables from an app listing, look at what the export contains and apply the same audit before you upload. You can see example outputs on the demos page and try the workflow with a free account.

Frequently asked questions

›What is the file size limit for a playable ad?

It depends on the network and sometimes on the placement, and networks change their specs. Check the current requirements in the network's own documentation before you build, and treat the limit as a budget to design against, not a target to squeeze under at the last minute.

›Is WebP safe to use in playable ads?

WebP is supported by current browsers and webviews on both major mobile platforms, but older devices in the wild can lag behind. Test on the oldest OS versions you still buy traffic from, and keep a PNG or JPEG fallback if a network or device fails to render the WebP.

›Should I remove audio from a playable ad to save size?

Often you can. Audio is frequently one of the largest single assets, and many users play with sound off. If you keep sound, use one short compressed loop and a few brief effects, and make sure the ad still works when muted.

›Does a smaller playable always perform better?

No. A smaller file loads sooner, which helps, but cutting the wrong things can make the ad unclear or dull. Cut weight that players never notice first, then test whether any visible cuts change results.

›Does base64 inlining make a playable bigger?

Yes. Encoding binary assets as text inflates them, so inlining is a cost you accept only when a network requires a single self-contained file. Compress assets before inlining, not after.

Sources

Turn your store listing into a playable

Paste an App Store or Google Play link and get an HTML5 playable you can test in minutes. The first one is free.

Keep reading