pixijs-ticker

import { Application } from "pixi.js";
 
const app = new Application();
await app.init({ width: 800, height: 600 });
 
app.ticker.add((ticker) => {
  // deltaTime: dimensionless scalar, ~1.0 at 60fps
  sprite.rotation += 0.1 * ticker.deltaTime;
 
  // deltaMS: real milliseconds (speed-scaled, capped)
  sprite.x += (200 / 1000) * ticker.deltaMS; // 200 pixels per second
 
  // elapsedMS: raw milliseconds (no scaling, no cap)
  console.log(`Raw frame time: ${ticker.elapsedMS}ms`);
});

import { Application, UPDATE_PRIORITY } from "pixi.js";
 
const app = new Application();
await app.init({ width: 800, height: 600 });
 
// INTERACTION (50) > HIGH (25) > NORMAL (0) > LOW (-25) > UTILITY (-50)
// app.render() is registered at LOW by the TickerPlugin
 
app.ticker.add(
  (ticker) => {
    // Physics runs before normal-priority callbacks
    updatePhysics(ticker.deltaMS);
  },
  undefined,
  UPDATE_PRIORITY.HIGH,
);
 
app.ticker.add((ticker) => {
  // Default priority (NORMAL = 0), runs after HIGH but before render
  updateAnimations(ticker.deltaTime);
});
 
// Pass `this` as the second argument to preserve context on class methods
class GameSystem {
  public speed = 5;
  public position = 0;
 
  public update(ticker: Ticker): void {
    this.position += this.speed * ticker.deltaTime;
  }
}
 
const system = new GameSystem();
app.ticker.add(system.update, system);
app.ticker.remove(system.update, system); // must match both fn and context

import { Ticker } from "pixi.js";
 
const ticker = new Ticker();
 
ticker.maxFPS = 30; // Cap at 30fps (skips frames to maintain interval)
ticker.minFPS = 10; // Cap deltaTime so it never exceeds 10fps worth
 
// If maxFPS < minFPS, minFPS is lowered to match
// If minFPS > maxFPS, maxFPS is raised to match

import { Sprite, Assets, Application } from "pixi.js";
 
const app = new Application();
await app.init({ width: 800, height: 600 });
 
const texture = await Assets.load("bunny.png");
const sprite = new Sprite(texture);
app.stage.addChild(sprite);
 
sprite.onRender = (renderer) => {
  sprite.rotation += 0.01;
};

import { Ticker, UPDATE_PRIORITY } from "pixi.js";
 
// Ticker.shared: singleton, autoStart=true, protected from destroy()
const shared = Ticker.shared;
 
// Ticker.system: separate instance used by engine background tasks,
// independent of the main scene ticker. It's a plain Ticker instance
// (autoStart=true, _protected=true) with no intrinsic priority; listeners
// are typically added at UTILITY priority by convention.
const system = Ticker.system;
 
// new Ticker(): custom instance, autoStart=false, you manage the lifecycle
const custom = new Ticker();
custom.autoStart = true; // start when first listener is added
custom.add((ticker) => {
  console.log(ticker.deltaMS);
});
 
// One-shot callback that auto-removes after firing
custom.addOnce(() => console.log("fires once"), null, UPDATE_PRIORITY.NORMAL);
 
// When done:
custom.stop();
custom.destroy();

import { Application } from "pixi.js";
 
const app = new Application();
await app.init({ autoStart: false });
 
// Pause and resume the built-in render loop at any time.
app.start();
app.stop();
 
// Or drive the loop yourself (headless, visibility-gated, fixed timestep, etc.)
function animate() {
  app.ticker.update(); // fires registered callbacks
  app.render(); // renders the stage
  requestAnimationFrame(animate);
}
animate();

import { Application } from "pixi.js";
 
const app = new Application();
await app.init({ width: 800, height: 600 });
 
app.ticker.speed = 0.5; // Half speed (slow motion)
app.ticker.speed = 2.0; // Double speed
 
// speed affects deltaTime and deltaMS, but NOT elapsedMS

app.ticker.add((dt) => {
  bunny.rotation += dt;
});

app.ticker.add((ticker) => {
  bunny.rotation += ticker.deltaTime;
});

class MySprite extends Sprite {
  updateTransform() {
    super.updateTransform();
    this.rotation += 0.01;
  }
}

class MySprite extends Sprite {
  constructor() {
    super();
    this.onRender = this._onRender.bind(this);
  }
  private _onRender() {
    this.rotation += 0.01;
  }
}

app.ticker.add((ticker) => {
  // Tries to move 100px/sec but deltaTime is ~1.0, not ~16.67
  sprite.x += (100 * ticker.deltaTime) / 1000;
});

app.ticker.add((ticker) => {
  // Using deltaMS for time-based movement
  sprite.x += (100 / 1000) * ticker.deltaMS;
  // Or using deltaTime as a frame-rate multiplier
  sprite.x += 1.5 * ticker.deltaTime;
});