Unity 6.3 LTS Web builds for portals: settings that matter

Unity’s Web platform has a dozen settings that change what a portal sees: file names, compression, download size, memory use and the headers your build expects. This guide walks through them as documented in the Unity 6.3 LTS manual and maps each one to what CrazyGames, Poki and YouTube Playables publish (as of 2026-10-01). For the server side of compression, see Serving compressed web builds.

Which manual this follows

Unity’s documentation version list currently marks Unity 6.3 LTS and Unity 6.0 LTS as supported LTS versions, 6.6 as the newest supported release and 6.7 as beta. Every Unity link here points at the 6000.3 manual. Settings move between versions, so check the manual for your exact editor version.

Build profile settings

In File > Build Profiles > Web (reference):

• Development Build must be off for anything you upload. Unity’s distribution size page says development builds are neither compressed nor minified.
• Code Optimization defaults to Shorter Build Time. Disk Size with LTO favors small output, and Unity recommends it for mobile web on its mobile optimization page. Runtime Speed with LTO is the alternative when CPU time matters more than bytes. Both LTO options build slowly, so use them for release builds.
• Texture Compression can override the Player setting with ETC2, ASTC (both described as widely supported on mobile) or DXT (desktop).

Publishing settings

These live under Player settings > Web > Publishing Settings (reference).

Setting	Unity says	Portals say
Compression Format	Gzip (default), Brotli or Disabled. The recommended settings page suggests Brotli.	Poki: Disabled. YouTube: avoid pre-compression; Brotli not available. CrazyGames: Brotli.
Decompression Fallback	Off by default. Adds a JavaScript decompressor and .unityweb names, costs loader size and WebAssembly streaming.	Not addressed by the three portals on the pages checked.
Name Files As Hashes	Names each file after an MD5 hash of its uncompressed content.	Poki: on.
Data Caching	Recommended. Caches the .data file in browser storage.	Poki: enable.
Debug Symbols	Off, External or Embedded.	Not addressed.
Enable Exceptions	Recommended page: None, with WebAssembly 2023 for exceptions without overhead.	Poki’s page says “Explicitly Thrown Exceptions Only” in one list and None in another. CrazyGames: None only if the game never relies on try/catch, otherwise the default; never Full With Stacktrace.

Some notes on these rows:

• Data caching inside iframes. Unity’s browser compatibility page says Safari does not support IndexedDB for content running in an iframe. Portals embed games in iframes, so expect no data cache for Safari players. The cache page mentions both the Cache API and IndexedDB for this feature.
• Debug symbols. Unity’s own pages disagree. The Player settings page recommends External for release builds, while the recommended-settings page says to turn symbols Off for the final release. External ships a .symbols.json file that players never need. Off keeps the upload smaller.
• WebAssembly 2023. The Player settings page lists the browser minimums for this feature set as Chrome 91, Firefox 89 and Safari 16.4. YouTube Playables requires compatibility with all browsers YouTube supports, so check those minimums against your audience before turning it on.

Code stripping

The recommended Player settings for size are API Compatibility Level .NET Standard 2.1, IL2CPP Code Generation “Optimize for code size and build time”, and Managed Stripping Level High. Unity warns that High can break reflection paths and may need a link.xml. Poki’s Unity guide asks for Strip Engine Code on and Managed Stripping Level High, falling back to Medium if the game breaks.

The distribution size page describes the typical failure. An AssetBundle loaded at runtime needs a class that was stripped from the main build, and the console shows “Could not produce class with ID”. The fix is a reference to that class, or an entry in link.xml. Load every AssetBundle and scene in a stripped release build before you submit.

Memory

From the Player settings page:

• Initial Memory Size defaults to 32 MB.
• Memory Growth Mode: Geometric is recommended.
• Maximum Memory Size defaults to 2048 MB, which the page calls the recommended setting. It allows up to 4096 MB but mentions known Firefox and Chrome bugs above 2048 MB.

The memory page explains why this matters. The heap is one contiguous block, and growing it can crash the game if the browser cannot find a large enough block. For mobile browsers, Unity recommends setting Initial Memory Size to your game’s typical heap usage. The .data file is also unpacked into browser memory and stays there uncompressed, so a large .data file costs memory as well as download time. AssetBundles load into the Unity heap and can be unloaded.

What portals publish about memory:

• CrazyGames disables Unity games on iOS by default because of memory crashes, and may enable them once a game has enough plays. It also disables games on Chromebooks that do not run smoothly on a 4 GB RAM device. It manages the device pixel ratio for Unity games itself: 1 on iOS and low-memory Android, native elsewhere.
• YouTube Playables says a game MUST NOT exceed a peak JavaScript heap of 512 MB. Its FAQ points Unity developers to Unity’s memory documentation. Whether YouTube’s measurement includes Unity’s WebAssembly heap is not stated on the pages checked, so do not assume the Unity heap is excluded.

Threads

Unity’s technical limitations page says C# threads are not supported on the Web, so System.Threading timers do not fire. It recommends Awaitable or coroutines instead. Enable Native C/C++ Multithreading is experimental. It needs a secure context and the Cross-Origin-Opener-Policy, Cross-Origin-Embedder-Policy and Cross-Origin-Resource-Policy headers, and the Player settings page recommends leaving it off except to evaluate future features. On a portal you cannot add those headers, and YouTube’s FAQ states that additional HTTP headers are not available. A multithreaded build also produces a .mem file (Build folder), which the script below detects.

The template’s index.html

The built-in templates are Default, Minimal and PWA, and the PWA template adds a web manifest and service worker. For a portal build, start from Minimal or a custom template. Per the template structure page, the page needs a <canvas>, the loader script and a call to createUnityInstance(canvas, config, onProgress). That call reports progress from 0.0 to 1.0. A fragment following that page and the build configuration page:

<canvas id="unity-canvas" tabindex="0"></canvas>
<div id="bar"></div>
<script src="Build/{{{ LOADER_FILENAME }}}"></script>
<script>
  var buildUrl = "Build"; // relative: absolute paths fail on CrazyGames and YouTube Playables
  var config = {
    dataUrl: buildUrl + "/{{{ DATA_FILENAME }}}",
    frameworkUrl: buildUrl + "/{{{ FRAMEWORK_FILENAME }}}",
    codeUrl: buildUrl + "/{{{ CODE_FILENAME }}}",
#if MEMORY_FILENAME
    memoryUrl: buildUrl + "/{{{ MEMORY_FILENAME }}}",
#endif
#if SYMBOLS_FILENAME
    symbolsUrl: buildUrl + "/{{{ SYMBOLS_FILENAME }}}",
#endif
    streamingAssetsUrl: "StreamingAssets",
    companyName: "{{{ COMPANY_NAME }}}",
    productName: "{{{ PRODUCT_NAME }}}",
    productVersion: "{{{ PRODUCT_VERSION }}}",
  };
  createUnityInstance(document.getElementById("unity-canvas"), config, function (progress) {
    document.getElementById("bar").style.width = 100 * progress + "%";
  }).catch(function (message) {
    console.error(message);
  });
</script>

The config also accepts devicePixelRatio. Unity says setting it to 1 can help performance on low-end mobile devices. Leave it unset for CrazyGames, which already sets the DPR for Unity games. matchWebGLToCanvasSize: false lets you size the render target yourself. The relative Build/ path matters on every portal here: CrazyGames and YouTube Playables both require relative paths. For keyboard focus inside the portal iframe, see Keyboard input and focus.

Read the settings back from a build

File names reveal several publishing settings. The script checks compression, fallback, hashed names, a .mem file from a multithreaded build, and a shipped .symbols.json. It prints a warning for each one that conflicts with what a portal publishes:

// file: examples/snippets/unity-webgl-builds-for-portals/unity-build-files.mjs
// unity-build-files.mjs: read Unity Web publishing settings back from a Build folder's file names.
// File naming follows the Unity 6.3 manual ("Web Build folder", "Deploy a Web application").
// Portal notes reflect each portal's published docs as of 2026-10-01; re-check them before relying on them.

const base = (p) => p.split('/').pop();

/** Pure: takes file paths, returns what the names reveal plus warnings worth reading. */
export function describeUnityBuild(paths) {
  const names = paths.map(base);
  const has = (re) => names.some((n) => re.test(n));
  const main = names.filter((n) => /\.(wasm|data|framework\.js)(\.(gz|br|unityweb))?$/i.test(n));

  const build = {
    found: has(/\.wasm(\.(gz|br|unityweb))?$/i),
    decompressionFallback: has(/\.unityweb$/i),
    compression: has(/\.(wasm|data|js)\.br$/i)
      ? 'brotli'
      : has(/\.(wasm|data|js)\.gz$/i)
        ? 'gzip'
        : has(/\.unityweb$/i)
          ? 'unknown'
          : 'disabled',
    externalDebugSymbols: has(/\.symbols\.json/i),
    multithreaded: has(/\.mem(\.(gz|br|unityweb))?$/i), // .mem only exists for multithreaded builds
    hashedNames: main.length > 0 && main.every((n) => /^[0-9a-f]{32}\./i.test(n)),
  };

  const warnings = [];
  if (!build.found) warnings.push('No .wasm file: point this at the Build folder of a Unity Web build.');
  if (build.compression === 'brotli' || build.compression === 'gzip') {
    warnings.push(
      `Pre-compressed (${build.compression}): the host must send Content-Encoding. ` +
        "Poki's Unity guide asks for Disabled; YouTube Playables advises against pre-compression.",
    );
  }
  if (build.compression === 'brotli') warnings.push('YouTube Playables says Brotli is not available.');
  if (build.decompressionFallback) warnings.push('Decompression Fallback: larger loader, no WebAssembly streaming.');
  if (build.multithreaded) {
    warnings.push('Native C/C++ multithreading needs COOP, COEP and CORP headers that portals may not send.');
  }
  if (build.externalDebugSymbols) warnings.push("Debug symbols file shipped: Unity's recommended release settings turn them off.");
  if (build.found && !build.hashedNames) warnings.push("Name Files As Hashes is off: Poki's Unity guide asks for it on.");
  return { ...build, warnings };
}

// file: examples/snippets/unity-webgl-builds-for-portals/inspect-unity-build.mjs
// inspect-unity-build.mjs: print the publishing settings a Unity Web build's file names reveal.
// Usage: node inspect-unity-build.mjs <path-to-build-output>
import fs from 'node:fs';
import { describeUnityBuild } from './unity-build-files.mjs';

const root = process.argv[2];
if (!root) {
  console.error('Usage: node inspect-unity-build.mjs <path-to-build-output>');
  process.exit(1);
}
const files = fs.readdirSync(root, { recursive: true }).map((f) => String(f).replaceAll('\\', '/'));
const { warnings, ...settings } = describeUnityBuild(files);
console.log(settings);
for (const w of warnings) console.log(`warning: ${w}`);

node inspect-unity-build.mjs ./MyGame-Web

It cannot see Development Build, stripping levels or memory settings, which leave no trace in file names.

What to check before you submit

• Development Build is off, and the build was made from the profile you meant to use.
• Compression Format and Decompression Fallback match the target portal: Disabled for Poki, no pre-compression for YouTube Playables unless the FAQ’s conditions apply.
• Name Files As Hashes is on for Poki.
• Native C/C++ Multithreading is off, and there is no .mem file.
• No .symbols.json ships in a release upload.
• Every AssetBundle and scene loads in the stripped release build.
• Peak memory was profiled on a low-end phone, and Maximum Memory Size is no larger than the game needs.
• index.html uses relative paths and comes from Minimal or a custom template.
• Initial download size was measured to the portal’s line: see Measuring time to first frame. The build passes the portal readiness checker.

Limits of this guide

No Unity project was built for this guide. Settings, defaults and file names come from the Unity 6.3 LTS manual as published on 2026-10-01, and the script was only run against a folder of empty test files. Unity 6.0 LTS and 6.6 may differ. Portal notes are limited to CrazyGames, Poki and YouTube Playables. GameDistribution, GameMonetize, Y8 and itch.io were not checked for Unity-specific settings. For portal requirements beyond Unity settings, see /portals/, /portals/crazygames/, /portals/poki/ and /portals/youtube-playables/.