SKAkash GherWeb Developer & HTML5 Game Specialist
HomeCase StudiesProjectsBlogWritingStudioStoreLabsAbout
All Case Studies

Creative case study

PixiJS Slot Game Engine

20 April 2026
Sky
by sky
2 min readSlot GamePixiJSGame Engine

A high-performance, configurable slot machine engine built with PixiJS v8 — from spinning reels and win-line evaluation to bonus rounds and sound management.

PixiJS v8TypeScriptGSAPHowler.jsSpine
Case
Blogs
Writings
Studio
Labs
Home
Projects
Store
About

Client

iGaming Studio

Role

Lead Game Developer

Year

2026

Discipline

HTML5 Game Engine

PixiJS Slot Game Engine
Doodle concept visual

Reduced time-to-ship for new slot themes from 6 weeks to under 10 days by building a fully data-driven engine.

The hero image is loaded from the MDX coverImage field. Replace the demo URL with your own gameplay capture, PixiJS canvas screenshot, or rendered artwork.

50+ types

Reel symbols

60 FPS

FPS target

< 1 day

Theme swap time

On this page

  • The Brief
  • Architecture
  • Reel Physics & Animation
  • Win Presentation System
  • Performance Optimization
  • Result

Akash Gher

High-performance web experiences

Case StudiesProjectsStudioStoreLogin

© 2026 Akash Gher. All rights reserved.

The Brief

The client needed a reusable slot engine that could ship multiple game themes on a tight schedule. The key constraint was that artists and designers had to be able to swap out a theme — symbols, background, paytable, colors, sounds — without touching any engine code.

Architecture

The engine is split into two layers: the core engine and the theme manifest.

The core engine handles all game logic: reel spinning physics, symbol evaluation, win-line calculation, RTP simulation, and bonus round state machines.

The theme manifest is a single JSON file that declares symbol definitions, reel strips, paytable multipliers, asset paths, and sound cues. Swapping a theme is literally swapping one JSON file and an asset bundle.

Reel Physics & Animation

Standard slot reels feel cheap when they just teleport symbols into place. I implemented a physics-based spin using GSAP:

  • Anticipation: the reel briefly pulls back before launching.
  • Overshoot: it spins past the target by a configurable amount.
  • Settle: it springs back to the final position with an easing curve.

This gives each spin a satisfying, weighty feel without requiring complex physics simulation.

Win Presentation System

Win celebrations are handled by a dedicated Win Presenter that sequences:

  1. Win line highlights (animated polyline paths over winning symbols).
  2. Symbol win animations (Spine skeletal animations).
  3. Coin burst particle effects using PIXI.ParticleContainer.
  4. Score counter animated via GSAP numerical tween.
  5. Audio layering — base win sound, then a multiplier sting for big wins.

Each stage is orchestrated by a SequenceRunner class that manages async chain logic cleanly.

Performance Optimization

  • All symbol textures are packed into a single atlas per theme, cutting draw calls from ~100 to under 5 per frame.
  • Spine animations are cached and pooled to avoid costly instantiation mid-session.
  • Background scenes use layered PIXI.TilingSprite for parallax without Canvas API overhead.

Result

The engine powers 4 live slot titles. Each new theme was delivered in under 10 days, against a previous industry baseline of 5–6 weeks.

More Case Studies

You might also like

View all
iGaming Math Config Architecture
9 June 2026

iGaming Math Config Architecture

A technical deep-dive into how production iGaming studios store, version, and serve complex game math configurations across operators, jurisdictions, and variants.

Remote Gaming Server (RGS) Architecture
8 June 2026

Remote Gaming Server (RGS) Architecture

A complete blueprint of an enterprise iGaming backend system: from the Seven-Layer Model and 48ms game transaction loops to GLI compliance and scaling pipelines.

Lish Programming Language
6 June 2026

Lish Programming Language

An educational compiler project translating academic Computer Science theory into a working plain-English general-purpose compiler that compiles directly to zero-overhead x64 assembly.