Dicey Table

FEATURES

A real physics table, and everything you need to build for it

DiceyTable is a browser-based tabletop simulator with an honest physics simulation underneath it — and a complete editor on top, so the games you play on it can be the games you make.

0installsIt is a web page
8seatsPlus spectators
7dice presetsd4 through d20
6collider typesBox to full mesh
200+sound clipsPositional 3D audio
12model formatsConverted in-browser

THE SHORT VERSION

A physics tabletop and the tools to build for it — both in a browser tab

DiceyTable is two things that fit together. The first is a 3D table with a real physics simulation on it, where you and up to seven other people can pick things up, throw them, deal them, hide them and knock them over, in the same room, in real time, with nothing to install. The second is a full editor for making the games that run on it — modelling cleanup, art conversion, rules code and publishing to GitHub, all from inside the same site.

Because the table simulates physical objects rather than implementing a particular game, almost anything you can put on a real table works on this one.

It is just a web page

No installer, no launcher, no plugin. Renderer, physics and networking load as one web app, so a table is a link you can send to anyone.

Players connect to each other

Gameplay runs peer-to-peer over WebRTC data channels. Our server only introduces players and keeps the room list; your moves never round-trip through it.

Games are open, not locked in

Every game is a mod: a public GitHub repo with models, art, a manifest and optional TypeScript rules. Mod scripts run sandboxed, so playing one is safe.

01 — THE TABLE

Sit down and play

The table is the product. It runs the physics, draws the scene, plays the sound and keeps everyone in sync — and it does all of it inside the browser you already have open.

A game of chess in progress on the DiceyTable table, with the in-game toolbar across the top and the player's seat shown bottom-left
A live table: the board and pieces are simulated objects, and the toolbar along the top is the whole in-game UI.

Play the games

Open a published mod from the catalogue and it loads with its board, pieces, decks and rules already in place — or start blank and set one up yourself.

Real rigid-body physics

A Bullet/Ammo physics world drives every piece, with mass, friction, bounce and damping set per object. Gravity is deliberately a little softer than Earth's so pieces stay readable as they move.

  • Box
  • Sphere
  • Capsule
  • Cylinder
  • Convex hull
  • Full mesh

Physics means almost any game

Nothing about a specific game is baked in. You get the primitives and the constraints that hold them together, and the rules are yours to write.

  • Cards
  • Decks
  • Dice
  • Tokens
  • Boards
  • Bags
  • Card holders
  • Custom models
  • Zones
  • Snap points
  • 3D text
  • Vector lines
  • Decals
  • Joints

Dice that actually tumble

Presets roll on convex-hull colliders with a randomised impulse and spin axis. Shake a die in your hand to charge the throw and that spin carries into it.

  • d4
  • d6
  • Rounded d6
  • d8
  • d10
  • d12
  • d20

Hands-on interaction

Six tools share the table. Flick a piece by pulling back and releasing; shake a deck to shuffle it, or shake a whole selection to sweep it into one shuffled pile.

  • Grab
  • Flick
  • Draw
  • Stamp
  • Transform
  • Ping

Sound that comes from somewhere

The host reads impacts and settles straight out of the physics simulation and maps them onto seventeen actions across eight material types, so cardboard, wood, metal and plastic each sound like themselves.

  • 200+ clips
  • 17 actions
  • 8 materials
  • Positional 3D

Up to eight seated players

Eight coloured seats plus spectators, each seat with a private hand. Hidden cards are stripped out of the data before it leaves the host — not just hidden in the renderer.

  • 8 seats
  • Spectators
  • Private hands
  • Automatic host migration

Tuned to stay in the browser

The table broadcasts only what changed, stops broadcasting entirely while everything is at rest, and streams compressed GPU textures. That is what keeps a busy table playable on an ordinary laptop.

And it works in VR

Put on a headset and the same table becomes room-scale, with articulated hand tracking that picks pieces up by pinching.

  • Per-device controller models
  • Hand tracking
  • In-headset menus
  • Palm hand of cards
  • Teleport
  • Smooth locomotion

Save the table, come back later

Name and save a snapshot at any point, and the host autosaves in the background. Saves are schema-versioned and migrated forward, so an old table still opens.

Close-up of a marble chess board with rendered pieces resting on a wooden table

WHY IT GENERALISES

Everything on the table is a real object

Pieces are not sprites on a grid. They have mass, a collision shape and a material, they fall over, they slide, they land on top of each other, and they make the noise you would expect when they do. That is why one table can run a chess set, a deck-builder, a dice game and whatever you invent on a Tuesday.

Lock a piece so nobody nudges it. Flip it, tap it, rotate it, split a stack, combine a stack, deal a hand, reveal to one team. Snap it to a point or a grid, or ignore both and throw it.

The in-game toolbar: Add Items, Controls, Undo, End Turn, Cam, Chat, Save, Log, Exit, Settings and Help
One toolbar, and the rest of the screen is the game.

02 — THE EDITOR

Make the game, then publish it, without leaving the site

Import the art, clean it up, lay out the scene, write the rules, fill in the store page and push the finished mod to a GitHub repository — end to end, in the browser, without ever opening a terminal or running a git command.

The DiceyTable editor: projects and hierarchy panel on the left, 3D viewport with a transform gizmo in the centre, component inspector on the right and the asset browser along the bottom
The full editor — hierarchy, viewport, inspector and asset browser, with the GitHub sync state in the status bar.

Build the scene

A hierarchy tree for the room, table, lights and player zones, and an inspector that puts the entity, its render settings and its rigidbody on one panel.

  • Move / rotate / scale gizmos
  • World or local space
  • Frozen and Live modes
  • Full undo and redo

A real code editor, in the page

Rules are written in TypeScript in an embedded Monaco editor — the same one that powers VS Code. It compiles in the browser as you save, and only the compiled output runs, sandboxed.

  • Strict type checking
  • Inline diagnostics
  • API autocomplete
  • Compiles on save

Import and convert your art

Drop in a .glb, or a .gltf with its buffers and textures and the editor packs them into one self-contained GLB. Everything else is converted in the browser on the way in, and a zip of PBR maps sharing a name is recognised and wired up as a finished material.

  • GLB
  • glTF
  • FBX
  • OBJ
  • COLLADA
  • STL
  • PLY
  • 3DS
  • 3MF
  • OFF
  • LWO
  • DirectX .x
  • PNG
  • JPEG
  • WebP
  • GIF
  • BMP
  • AVIF
  • ZIP

Optimise models before you ship

Every model gets an inspection report — triangles, vertices, meshes, materials, embedded texture sizes — with warnings for what is oversized. Then fix it in place; the untouched original is preserved, so revert is one click.

  • Clean up and weld
  • Simplify to a % of triangles
  • Re-encode textures to WebP
  • Recompute normals
  • Generate tangents
  • Split into parts

Optimise images and textures too

Resize with an aspect lock and a power-of-two ladder, re-encode to WebP, or compress to KTX2 with Basis — ETC1S for colour maps, UASTC for normals and detail — entirely in the browser.

  • sRGB
  • Mipmaps
  • Filtering
  • Anisotropy
  • Wrap mode
  • Crop and annotate
  • Layer-based paint

Materials, decks and presets

A material editor with a live preview sphere and a full PBR inspector, drag-to-assign onto objects and room surfaces. A deck builder takes your card images, lets you reorder and label them, and composes the sprite sheet the runtime needs.

The editor hierarchy panel showing the room, floor, walls, ceiling, lights, table and player zone entities
Hierarchy
The editor inspector panel with Entity, Render and Rigidbody sections expanded
Inspector

DIRECT MANIPULATION

Edit the thing, not a config file

Select an entity and its components are right there: enabled state, name, position, rotation and scale; render type, surface and material; rigidbody type, mass and friction. Change a value and the viewport updates.

Drop a material onto an object to assign it. Place snap points by hand, or lay out a whole grid of them with rows, columns and spacing. Frame the selection, switch between world and local axes, and undo anything.

The editor asset browser toolbar with Upload, New Folder, New Material, Import Material, New Script and New Deck actions, and Models, Materials, Textures, Scripts and Decks folders
Models, materials, textures, scripts and decks — one asset browser, and everything in it is a file in your repo.
The editor's Publish to GitHub dialog showing the connected GitHub account, the linked repository, a commit message field, and a Publish button that promotes the working branch to main

NO TERMINAL REQUIRED

Straight into GitHub, with no manual work

Connect your GitHub account once. From then on the editor can create a brand-new repository for you from inside the site, and your edits check themselves into a working branch in the background as you go.

When you are happy, hit Publish. The editor pushes the whole file tree as a single commit, promotes the working branch to main, and registers the mod so it appears in the catalogue and is immediately playable. You never clone, stage, commit, branch or push anything yourself.

No GitHub account? The editor still works completely — drafts live in your browser's own storage and you can export the whole project as a file. Publishing is the one step that needs a GitHub connection, because a published mod's assets are served from its repo rather than from us.

03 — AFTER YOU PUBLISH

Your mod gets a page, and people can play it

Publishing needs a title, a summary, a cover image and at least one screenshot — the editor checks before it lets you ship. In return your mod gets a real listing.

  • Description
  • Screenshot gallery
  • Tags
  • Player count
  • Favourites
  • Ratings and reviews
  • Play statistics

GET STARTED

Pick a side of the table

Play something someone else built, or go and build one. Neither needs an install.