ApplicationOptions reference

Every option accepted by app.init(options). Options come from three type sources merged into a single interface:

• AutoDetectOptions → base renderer options (width/height/resolution/etc.)
• PixiMixins.ApplicationOptions → plugin options (resizeTo, autoStart, sharedTicker, culler)
• System defaults → each renderer system (background, view, hello, GC, context, backbuffer, events, graphics) contributes its own options

Options with no default are unset unless you pass them. Partial<ApplicationOptions> means everything is optional.

View / canvas

Configures the main canvas and how it maps to CSS pixels.

await app.init({
  width: 1280,
  height: 720,
  resolution: window.devicePixelRatio,
  autoDensity: true,
  antialias: true,
});

Background

Controls the clear color applied each frame.

await app.init({
  backgroundColor: 0x1099bb,
  backgroundAlpha: 1,
});

Renderer preference

Picks which renderer gets created.

preference: array form

Passing an array to preference restricts autoDetectRenderer to exactly the listed renderers, in the given order. Any renderer not in the array is excluded entirely — the array doubles as a blocklist.

// Try WebGPU first, then fall back to WebGL. Never use Canvas2D.
await app.init({ preference: ["webgpu", "webgl"] });

// Only ever use Canvas2D (e.g. in a WebGL-disabled environment).
await app.init({ preference: ["canvas"] });

// Skip WebGPU entirely while keeping the default webgl → canvas fallback order.
await app.init({ preference: ["webgl", "canvas"] });

Contrast with the string form, which falls through the full default priority if the first choice fails:

// Tries webgpu, then webgl, then canvas — all three are candidates.
await app.init({ preference: "webgpu" });

Use the array when you need to guarantee a renderer is never picked (e.g. WebGPU is broken on a target device, or you want to forbid Canvas2D's feature subset).

Shared rendering

Apply to every renderer type.

await app.init({
  roundPixels: true,
  hello: true,
});

Graphics

Graphics rendering options.

await app.init({
  bezierSmoothness: 0.75,
});

Ticker (TickerPluginOptions)

Controls the built-in render loop.

See pixijs-ticker for the ticker API itself.

await app.init({
  autoStart: false,
  sharedTicker: false,
});

function loop() {
  app.renderer.render(app.stage);
  requestAnimationFrame(loop);
}
loop();

Resize (ResizePluginOptions)

The plugin listens for resize events on window and calls renderer.resize(). You can reassign app.resizeTo at runtime, and call app.resize(), app.queueResize(), or app.cancelResize() from user code.

await app.init({
  resizeTo: window,
});

Culler (CullerPluginOptions)

Opt-in plugin (must extensions.add(CullerPlugin) to activate).

import { CullerPlugin, extensions } from "pixi.js";

extensions.add(CullerPlugin);

await app.init({
  culler: { updateTransform: true },
});

Events

await app.init({
  eventMode: "static",
  eventFeatures: {
    move: true,
    globalMove: false,
    click: true,
    wheel: true,
  },
});

Accessibility

Accessibility options. Pass these on the top-level init options.

See pixijs-accessibility for the full accessibility API.

await app.init({
  accessibilityOptions: {
    enabledByDefault: true,
    activateOnTab: true,
    deactivateOnMouseMove: true,
  },
});

WebGL-only options

Applied when the WebGL renderer is selected.

await app.init({
  preference: "webgl",
  webgl: {
    preferWebGLVersion: 2,
    useBackBuffer: true,
    powerPreference: "high-performance",
  },
});

WebGPU-only options

await app.init({
  preference: ["webgpu", "webgl"],
  webgpu: {
    powerPreference: "high-performance",
  },
});

Garbage collection

All time values are milliseconds.

Deprecated (GC — prefer the unified options above)

TextureGCSystem and RenderableGCSystem still accept these, but they've been deprecated since 8.15.0 in favor of gcActive/gcMaxUnusedTime/gcFrequency. Passing them still works for the deprecation window but logs warnings.

await app.init({
  gcActive: true,
  gcMaxUnusedTime: 60_000,
  gcFrequency: 30_000,
});

Per-renderer overrides

webgl, webgpu, and canvasOptions are merged over the top-level options once the selected renderer is known:

await app.init({
  antialias: false,
  webgl: { antialias: true, useBackBuffer: true },
  webgpu: { antialias: true },
  canvasOptions: {
    /* canvas-specific */
  },
});

If WebGL wins, the renderer sees antialias: true + useBackBuffer: true. If WebGPU wins, just antialias: true. The three sub-keys are stripped before the options reach the renderer.