Required for the website to function properly. Cannot be disabled.
Workshop Game Library
These aren't polished products. They're teaching tools built during workshops to demonstrate specific mechanics, math models, and architectural patterns for social casino development. Each game isolates a particular concept—weighted reels, bonus triggers, progressive systems—so you can see exactly how the logic works under the hood.
Try the Slot Simulator
This demo shows a basic five-reel slot with configurable RTP, weighted symbol distribution, and hit frequency controls. Built to teach core reel mechanics and probability modeling for social casino games.
What You'll Find Here
RNG-Based Mechanics
Games using Mersenne Twister and cryptographic RNG implementations. You'll see how proper seeding works, how to avoid bias in weighted selections, and how to implement verifiable fairness checks that players can audit.
Math Model Examples
Complete PAR sheets with symbol weights, payline configurations, and RTP calculations. Each game includes spreadsheets showing expected values, variance calculations, and hit frequency across different bet levels.
Bonus State Machines
Free spin triggers, progressive pick games, and multi-stage bonus rounds. These demonstrate state management patterns, transition logic, and how to handle complex feature interactions without creating race conditions.
Progressive Systems
Linked jackpot pools with contribution rates, tier overflow mechanics, and must-hit-by logic. Shows how to manage shared state across sessions, handle concurrent claims, and implement seed values after wins.
Reel Strip Architecture
Different approaches to reel layouts: physical stops vs virtual reels, expanding wilds, cascading symbols. You'll see how changing strip length affects volatility and how to balance symbol distribution for target RTP.
Client-Server Patterns
Server-authoritative game loops with client prediction for responsive UI. Includes replay systems, session recovery after disconnects, and validation patterns to prevent manipulation while keeping play smooth.
Understanding Workshop Games
Built for Education
These games exist to make abstract concepts concrete. Instead of reading about RTP calculations, you implement one. Instead of discussing state machines, you debug one. Each game was built during a specific workshop to solve a specific learning problem.
They're intentionally simple. No art pipelines, no sound design, minimal UI polish. The complexity is in the systems, not the presentation. A three-reel slot with clean math teaches more than a feature-heavy game with hidden calculations.
We keep previous workshop builds available so you can see how implementations evolved. Version one might use a naive weighted selection. Version two optimizes with alias method. Version three adds replay validation. Seeing that progression helps more than just seeing the final result.
Implementation Details
Most games use vanilla JavaScript with Canvas for rendering. No framework overhead—just direct manipulation of game state and draw calls. This keeps the code readable and makes it easier to port concepts to other languages.
Server components run on Node with WebSocket connections. State updates happen server-side, clients send input and receive display commands. You'll see the same patterns scaled from single-player demos to multi-session progressive pools.
- Deterministic RNG with known seeds for testing and verification
- Server-authoritative game loop at 30 ticks per second
- Client interpolation for smooth reel spins without server involvement
- Complete session logs with replay capability from any point
- Configurable math models—change RTP, volatility, hit frequency in real-time
Working with Demo Code
All workshop games include source code and documentation. You can modify parameters, break things intentionally, and see what happens. The best way to understand variance is to set RTP to 150% and watch the math fail. Set hit frequency too high and feel the gameplay turn into noise.
Each game has a configuration file with comments explaining every parameter. Symbol weights, payout multipliers, bonus trigger thresholds—everything's exposed. Change the values, run simulations, compare results against the PAR sheet math.
These aren't production-ready. No error handling for edge cases. No optimization for mobile. No accessibility features. They're learning tools. Take the patterns, understand the logic, then implement them properly in your own projects with appropriate engineering rigor.