Type Alias ApplicationSettings

ApplicationSettings: {
    antiAlias: boolean;
    backgroundColor: string;
    batcher?: new (renderer: any) => Batcher;
    blendMode: BlendMode;
    cameraClass?: new (
        minX: number,
        minY: number,
        maxX: number,
        maxY: number,
    ) => Camera2d;
    compositor?: new (renderer: any) => Batcher;
    consoleHeader: boolean;
    failIfMajorPerformanceCaveat: boolean;
    gpuTilemap: boolean;
    highPrecisionShader: boolean;
    legacy: boolean;
    physic: PhysicsType;
    powerPreference: PowerPreference;
    preferWebGL1: boolean;
    renderer: RendererType | Renderer;
    scale: number | "auto";
    scaleMethod: ScaleMethod;
    scaleTarget: HTMLElement;
    subPixel: boolean;
    transparent: boolean;
    verbose: boolean;
} & (
    | { canvas?: never; parent: string
    | HTMLElement }
    | { canvas: HTMLCanvasElement; parent?: never }
)

Type Declaration

antiAlias: boolean
whether to enable or not video scaling interpolation
Default
```
false
```
backgroundColor: string
the CSS background color of the parent element that holds the canvas. Applied during initialization to prevent a white flash before the first render. Set to "transparent" to disable, or any valid CSS color value.
Default
```
"#000000"
```
Optionalbatcher?: new (renderer: any) => Batcher
a custom batcher class (WebGL only)
blendMode: BlendMode
the default blend mode to use ("normal", "multiply", "lighter", "additive", "screen")
Default
```
"normal"
```
OptionalcameraClass?: new (minX: number, minY: number, maxX: number, maxY: number) => Camera2d
Default camera class instantiated for any Stage that does not explicitly provide its own cameras. Set to Camera3d to opt every stage in the app into perspective rendering by default. Stages can still override per-instance via super({ cameras: [...] }) or per-class via super({ cameraClass: Camera2d }). Built-in stages (e.g. the loader screen) explicitly use Camera2d regardless of this setting.

WebGL requirement. Camera classes whose static defaultSortOn === "depth" (Camera3d and any subclass) need the WebGL renderer — perspective projection, depth attachment and mesh draw all live in the WebGL backend. Pairing such a cameraClass with renderer: video.AUTO on a system where AUTO falls back to Canvas emits a console.warn at construction time and produces a non-functional render. Use renderer: video.WEBGL to get a hard throw instead.
Default
```
Camera2d
```
Optionalcompositor?: new (renderer: any) => Batcher
a custom batcher class (WebGL only)

Deprecated
since 18.1.0 — use batcher instead
consoleHeader: boolean
whether to display melonJS version and basic device information in the console
Default
```
true
```
failIfMajorPerformanceCaveat: boolean
if true, the renderer will fail if the browser reports a major performance caveat (e.g. software WebGL). Set to false to allow WebGL on machines with blocklisted GPU drivers or software renderers.
Default
```
true
```
gpuTilemap: boolean
Enable the WebGL2 procedural shader path for orthogonal tile layers. When true (default), eligible layers render via a single quad per tileset + a fragment shader doing per-fragment GID lookup, bypassing the per-tile draw loop entirely. Layers that don't qualify (Canvas/WebGL1, non-orthogonal, collection-of-image tilesets, tilerendersize "grid", non-zero tileoffset, oversampled beyond the shader's overflow window) fall back to the legacy path automatically. Set to false to disable globally.
Default
```
true
```
highPrecisionShader: boolean
enable high precision shaders (WebGL only). When false, shaders prefer "mediump" precision for better performance on some mobile GPUs, falling back to "lowp" if "mediump" is not supported. When true (default), the highest precision supported by the device is used. This setting is ignored by the Canvas renderer.
Default
```
true
```
Example
```
import { Application, device } from "melonjs";
const app = new Application(800, 600, {
    parent: "screen",
    // prefer lower shader precision on mobile for better performance
    highPrecisionShader: !device.isMobile,
});
```
legacy: boolean
whether to enable legacy mode (enables deprecated video.init() entry point)
Default
```
false
```
physic: PhysicsType
The physics system to use. Accepts:
- "builtin" (default) — the built-in SAT physics adapter
- "none" — disables physics; World.step skips the simulation, the world container behaves like a pure scene graph
- a PhysicsAdapter instance — e.g. new MatterAdapter() from @melonjs/matter-adapter, or any third-party adapter
- { adapter: PhysicsAdapter } — explicit form, reserved for future per-app physics options
The adapter's physicLabel becomes world.physic so user code can branch on the active engine without importing the concrete adapter class (app.world.physic === "matter", etc.).
Default
```
"builtin"
```
powerPreference: PowerPreference
a hint to the user agent indicating what configuration of GPU is suitable for the WebGL context. To be noted that Safari and Chrome (since version 80) both default to "low-power" to save battery life and improve the user experience on these dual-GPU machines.
Default
```
default
```
preferWebGL1: boolean
if true the renderer will only use WebGL 1
Default
```
false
```
renderer: RendererType | Renderer
Renderer to use. Three built-in modes (constants from me.video):
- CANVAS — HTML5 Canvas backend. No shader / mesh / Camera3d support.
- WEBGL — requires WebGL. Throws at new Application(...) time if WebGL is unavailable (driver-blocklisted GPU, perf-caveat failure, etc.). Use this when your scene needs Camera3d, Mesh, ShaderEffect, Light2d or GPU tilemap — you'd rather fail fast than render a stuck blank canvas.
- AUTO — try WebGL, silently fall back to Canvas if unavailable. Application construction always succeeds. The WebGL-only subsystems (Camera3d, Mesh, ShaderEffect, Light2d, GPU tilemap) silently stop working under the Canvas fallback — if your scene depends on any of those, use WEBGL instead.
Or pass a custom Renderer subclass instance for full control.
Default
```
AUTO
```
scale: number | "auto"
enable scaling of the canvas ('auto' for automatic scaling)
Default
```
1
```
scaleMethod: ScaleMethod
screen scaling modes
Default
```
"manual"
```
scaleTarget: HTMLElement
the HTML Element to be used as the reference target when using automatic scaling (by default melonJS will use the parent container of the div element containing the canvas)
subPixel: boolean
whether to enable sub-pixel rendering (avoid sprite flickering when using transforms)
Default
```
false
```
transparent: boolean
whether to allow transparent pixels in the front buffer (screen).
Default
```
false
```
verbose: boolean
whether to enable verbose mode (additional console output for debugging)
Default
```
false
```

{ canvas?: never; parent: string | HTMLElement }
- Optionalcanvas?: never
- parent: string | HTMLElement
  the DOM parent element (or its string ID) to hold the canvas in the HTML file
{ canvas: HTMLCanvasElement; parent?: never }
- canvas: HTMLCanvasElement
  an existing canvas element to use as the renderer target (by default melonJS will create its own canvas based on given parameters)
- Optionalparent?: never

Type Alias ApplicationSettings

Type Declaration

antiAlias: boolean

Default

backgroundColor: string

Default

Optionalbatcher?: new (renderer: any) => Batcher

blendMode: BlendMode

Default

OptionalcameraClass?: new (minX: number, minY: number, maxX: number, maxY: number) => Camera2d

Default

Optionalcompositor?: new (renderer: any) => Batcher

Deprecated

consoleHeader: boolean

Default

failIfMajorPerformanceCaveat: boolean

Default

gpuTilemap: boolean

Default

highPrecisionShader: boolean

Default

Example

legacy: boolean

Default

physic: PhysicsType

Default

powerPreference: PowerPreference

Default

preferWebGL1: boolean

Default

renderer: RendererType | Renderer

Default

scale: number | "auto"

Default

scaleMethod: ScaleMethod

Default

scaleTarget: HTMLElement

subPixel: boolean

Default

transparent: boolean

Default

verbose: boolean

Default

Optionalcanvas?: never

parent: string | HTMLElement

canvas: HTMLCanvasElement

Optionalparent?: never

Settings

`Optional`batcher?: new (renderer: any) => Batcher

`Optional`cameraClass?: new (minX: number, minY: number, maxX: number, maxY: number) => Camera2d

`Optional`compositor?: new (renderer: any) => Batcher

`Optional`canvas?: never

`Optional`parent?: never