Owing to feedback we have received from the community, we at dddice have decided to make a change to our community dice library. We will be making inclusion of dice in the library an explicitly opt-in feature.

As we have begun to monetize the service, we want to make sure that everyone who has dice included in the community library understands and agrees to let us use their creations in this way. In support of this, we have added a paragraph to section 11 of our end user license agreement to be more explicit on this point. Please do review that before you add your dice to the community library.

We will be changing the dice creation process to have dice hidden from the library by default, and include a button to add your dice to the library.

For now, only Patreon supporters will be able to list their dice in the library. Everyone will still be able to share dice they have created with their friends directly – either though share links or via GMs sharing their dice tray. All dice currently in the library will be removed, and if you want them added back, you will need to go through and re-add them.

We value your feedback so keep it coming either via, our Discord, or our contact from.

It's been quite the journey since the project kicked off in October 2021. The app, the community, the dice have developed quite a lot in that time. We are now ready to take the next step in that journey and move the software into beta!

On April 11th, there will be a few changes. The most exciting being the marketplace launch. But first, we want to focus on what is staying the same.

🔒 What won't change

dddice —  its platform, its integrations, its roll rooms, its stream overlays, the dice editor, the API — will remain free to use, no signup required.

You will still be able to create as many custom dice and roll rooms as you want, and share those dice with your friends using share links.

We believe this is essential for dddice goblins to be able to convince their whole party to use the platform.

🚀 What will change

The biggest change will be updates to our Patreon rewards. We will be following the model of other TTRPG apps editors and creative communities and making the community-created dice exclusive to Patreon supporters. Everyone can still browse the community collection, but only Patreon supporters may add the dice to their digital dice box.

To maintain your ability to play all the games you might want to play, there will be a small collection of completely free dice. This collection will support the most common systems — Dungeons & Dragons, Pathfinder, World of Darkness, World of Darkness 5e & Call of Cthulhu. Some lesser-played systems will also have free dice — Mouse Guard, Coriolis, Alien, and The Living Dead.

Each week, we will select a handful of the best community-created themes to feature on our marketplace landing page. These themes will be free for everyone to add to their digital dice box during that week.

The other big change is the Marketplace. We will start selling dice on April 11th to coincide with National Board Game Day. Many of you have already added some offerings into your wishlist, and now will be your time to finally add them to your digital dice box.

🤔 Why the change?

Many of you have asked over the years, “how do you all make money”? The answer is we don’t, not really. While we do have our wonderful Patreon supporters, the money coming in from that does not yet cover our operating costs. We hope that by increasing the value of the Patreon subscription and selling premium dice, we can build a sustainable company and community that will be a part of the amazing things to come for TTRPGs.

Happy Rolling! 🎲

~ Celeste Bloodreign & nullfish

While DMing with Owlbear I realized I needed more functionality for running my own games, so I created HP Tracker. Starting out as a simple tool for DMs to track Token HP with per player visibility, it now features a wide array of functionality, including creature statblocks. While dddice existed as a standalone extension in Owlbear, I really wanted to give my users the ability to roll damage directly from the HP Tracker statblocks while also supporting outside rolls from D&D Beyond and if possible others.

1️⃣ Phase 1 — Research

As with all software development projects I started out researching the possibilities.

There was:

• Adding a fork of the Owlbear dice roller to HP Tracker
• Doing everything from scratch
• Use one of the existing dice rollers
• Find a dice roller with an SDK or API

Pretty quickly, it became clear that there was one solution that stood out — dddice! dddice offers a well documented SKD and if that wasn't enough an API. Also, after a quick chat with nullfish, he gave me some pointers on where to start. So I made my decision that HP Tracker should get a full integration with dddice.

2️⃣ Phase 2 — Getting Started

Before starting with the implementation, I thought about all the features I wanted to implement. Because of the nature of Owlbear extensions, HP Tracker is basically a bunch of websites (token overview, statblocks, ...) that are connected to Owlbear via the OBR SDK. The main extension window and the stat block popover are each their own “website”. I needed a React Component to handle the dddice stack, but also to limit the roll to only one of the opened “websites”. In other words, I didn't want someone to click on the main extension window and then for the dice to roll atop every popup my extension made.

So the basic structure was:

• Each HP Tracker site gets the dddice-component which can be used to log in, change settings and roll dice
• A new transparent overlay is added where all dice rolls will be rendered
• A roll log is shown every time the overlay finishes a roll

Sounds simple enough! Let's go!

3️⃣ Phase 3 — But Wait! What about Edge Cases?

A thing I needed to keep in mind was, some Owlbear users were maybe already using the dddice extension. So a renderless mode needed to be added to HP Tracker. Because of dddice's client-server-model rolling in one extension and rendering in a second is easy. Synching rolls across apps is one of its basic features! The solution for HP Tracker is adding a toggle button to switch the rendering on or off.

Turning off dice rendering in HP Tracker led to the roll log no longer being displayed. Using dddice's event handlers made this easy to solve. I was able to hook directly into the roll events using the interface exposed by the ThreeDdiceAPI object in the dddice SDK.  

All other edge cases that popped up during development were quick to solve too, either by reading the SDK documentation or asking the very helpful dddice developers for help (Thank You Celest Bloodreign!).

4️⃣ Phase 4 — Gold Plating

Initially, my plan was to just add roll buttons to HP Trackers integrated Statblocks. However, using the dddice integration sped up the whole process so much I was able to add more functions for my users. I added: CustomRoll-Buttons, QuickRoll-Buttons, hidden rolls and more! All in all, integrating dddice into HP Tracker took about two weeks of programming in the evenings. Beating my initial estimation of two months by a lot.

🔍 Developer Findings

As I was using typescript for my implementation, I found that some operations were necessary when interacting with the dddice SDK. And as I found myself repeating them more than once I decided to wrap them into function (as developers tend to do). Here is a collection of some functions that others might also find useful.

🧑 Get the Participant

A lot of the times you want to know who exactly something belongs to. Whether it's a die roll or just look if a user is already part of a room. You end up getting the user from the SDK/API then getting the room and then looking if the user is registered as a participant in the room.

You can use this information to add the user to a room (if the participant is not found). Or change the participants username so you can later use it, e.g., in the roll log (dddice uses this to display the D&D Beyond Character names in their rolls).

My solution for this are the following two function:

export const getDiceUser = async (rollerApi: ThreeDDiceAPI) => {
    return (await rollerApi?.user.get())?.data;
};

export const getDiceParticipant = async (rollerApi: ThreeDDiceAPI, roomSlug: string | undefined, user?: IUser) => {
    let diceUser: IUser | undefined = user;
    if (diceUser === undefined) {
        diceUser = await getDiceUser(rollerApi);
    }
    if (diceUser && roomSlug) {
        const diceRoom = (await rollerApi.room.get(roomSlug))?.data;
        // @ts-ignore we test diceUser in the if above it will not be undefined
        return diceRoom?.participants.find((p) => p.user.uuid === diceUser.uuid);
    }
    return undefined;
};

An example where I use this is this function

export const prepareRoomUser = async (diceRoom: IRoom, rollerApi: ThreeDDiceAPI) => {
    const participant = await getDiceParticipant(rollerApi, diceRoom.slug);
    const name = await OBR.player.getName();

    if (participant && participant.username !== name) {
        await rollerApi.room.updateParticipant(diceRoom.slug, participant.id, {
            username: name,
        });
    }
};

The purpose is getting the current participant and making sure that when they roll a die, the participant username is set to their Owlbear username. So you can see at first glance which of the Owlbear user rolled the dice.

🔌 Initialize and connect to dddice

Each time HP Tracker is started the user needs to be connected to dddice, so I have a function – with some wrapper code I don't include here –  which is basically the auth flow I'm using (roller being an instance of ThreeDDice). I also removed some functions and replaced them with their internal logic to make the code-flow more readable:

roller.initialize(canvas, await getApiKey(room), { autoClear: 3 }, `HP Tracker`);
        if (roller.api) {
            const diceRoom = await getDiceRoom(roller.api, room);
            if (diceRoom) {
                const user = (await roller.api?.user.get())?.data;
                if (user) {
                    const participant = diceRoom.participants.find((p) => p.user.uuid === user.uuid);
                    if (participant) {
                        await prepareRoomUser(diceRoom, roller.api);
                    } else {
                        try {
                            const userDiceRoom = (await roller?.api?.room.join(diceRoom.slug, diceRoom.passcode))?.data;
                            if (userDiceRoom) {
                                await prepareRoomUser(userDiceRoom, roller.api);
                            }
                        } catch {
                            /**
                             * if we already joined. We already check that when
                             * looking if the user is a participant in the room,
                             * but better be safe than sorry
                             */
                        }
                    }
                    roller.connect(diceRoom.slug, diceRoom.passcode, user.uuid);
                }
            }
            return true;
        }

What this does:

1. Initialize the dddice API and let it know which application is connected
2. Get the room that is used for this session (there is some internal logic there to make sure we get the right room)
3. Get the dddice user
4. Check if the user is already a room participant
   a. User is already a participant, make sure the correct username is set
   b. User is not a participant, join the room and then make sure the username is correct
5. Connect the ThreeDDice instance to the room with the current user

And the rest is beautifully rendered 3D dice 🎲

🎉 Conclusion

I loved every step of the way. Each little progress got me excited, and the dice rendering is one of the best I've seen across all digital dice rollers. If anybody is still on the fence of using dddice for their project, don't be! It's one of the best developer experiences I had in a long time.

This is a guest post written by Josh, the developer of HP Tracker. You can check out HP Tracker in the Owlbear Rodeo extension library or find his other work (and blog posts) at bitperfect.at.

I'm sure some of you have seen a cool looking dice set, but thought it would look better with different colours. Though, when you try to remix it you find that the set was made using a coloured texture background, and there's only so much you can do with the colour settings.

Here's an example of what I mean, this is an old remix of my Poison Envy set that is still using a coloured texture, I've given it a red colour filter and the center of the dice has turned black, not red, why is that?

🖤 Why so black?

It's to do with how the colour settings work. The diffuse colour is like painting, or printer ink. It doesn't add colour, it subtracts it. In other words, as far as light is concerned, it's actually the opposite colour being removed.

Think of printing on paper. If you mix yellow ink and cyan ink you get green, because the opposite of yellow is blue and the opposite of cyan is red, so you're taking away blue and red from the white paper, leaving green.

So in this case, by adding a red filter we've actually removed green and blue, there's not much blue in there anyway, and green - green = black.

The outer edges of the dice appear red as the underlying texture has a green to yellow transition and yellow is red + green, so removing green from the yellow colour means we still have red left.

🔦 Using emissive colours

So what if we want to do the opposite and add colour? That's what the emissive colour settings are for! They add colour like a light shining onto the dice. When a red emissive colour is set it turns the dice yellow, not red, and also turns the black borders red, we don't want that, and if we apply both?

Not ideal 😢.  If the dice only had 1 or 2 colours, it wouldn't be so bad, but if there's more, and especially if there are gradients, it gets a bit more tricky. How do we resolve this? — outline textures and emissive maps!

🍴 Make remix friendly textures

The first thing is to make an outline texture. This texture is layered on top of the background texture, much as one would do in an image editor like photoshop. Therefore, the part we want to include here is the part that is not affected by the colour gradient in the original texture. We could also include a part of the dice that is a solid colour that is different from the rest of the die, or the metal part if you're using metal. For the poison envy dice in this example, it's the black border.

We can take the texture, crop it to a single side if it's a full dice texture, modify it so that only the border is visible, then colour it white.

When we set this texture as the "Diffuse Map" in the "Face Outline" section we can now see the border. When changing the outline colour setting from the colour menu, you'll see that we can now control the colour of the border independently of the rest of the die. The emissive colour is still being applied over it, however – green colour is having red added to it. We don't want that.

We could remove the emissive colour, but then the center of the die appears black again, so there's still a bit more work to do.

🦸‍♀️ Emissive map to the rescue

Next thing we need is an emissive map, this is an image that controls how strongly the emissive colour is applied to the dice.

For now let's just start with a copy of the outline map we used above and colour it black instead of white, when we add it as the “Emissive Map” in the “Face Outline” section, the border now shows up as green even with both of the emissive colours set to full red.

So what happened? And wait, two different emissive colour options?

There are two things that are important in the emissive maps: transparency and brightness. Any part of the emissive map that is black will prevent any emissive colour from being applied. Black means “no light here”.

Any part that is transparent, will apply the base emissive colour, and any part that is white will apply the outlineEmissive colour. Let's try setting those to 2 different colours and changing the emissive map just to demonstrate.

Let's also get rid of the coloured base background texture, as that is always adding green, now we can see more clearly how the colours are mixing, the white part of the map allowing the blue outlineEmissive colour to mix with the red diffuse colour, while the transparency allows the yellow emissive colour to cover the rest.

📦 Remixable colour gradients

To get that center-to-edge gradient to be colour setting controlled, we need to make edits to the emissive map. Let's create a square and set its colour to a round gradient. We'll set the center colour to black and the edge to either transparent or white, depending on which colour setting we want to key into –  transparent for base emissive, white for outline emissive. Layer this underneath the black layer for the border, then re-upload.

We can now see the red colour in the center transitioning to yellow at the edges. Now it's just a matter of adjusting the colour settings so see how remixable it really is! Of course if we're not happy with the gradient we can always adjust the emissive map.

🎨 Don't want the colours mixing?

As we can see there is some colour mixing happening. A blue emissive colour on a red diffuse colour results in magenta. If we want to go the extra mile and have the emissive colour be independent of the diffuse colour we need to modify and re-upload the outline map to prevent the colours from mixing too much.

We can achieve this by adding a radial gradient. Place this underneath the white border layer. Set the centre to transparent and the outer edge to black. The black colour in the map prevents the diffuse and outline colours from showing. This leaves only the emissive colours, allowing us to even use black as an emissive colour when usually setting an emissive colour to black would do nothing.

Once you're done with updating that one die in the set, you can repeat the process to make outline and emissive textures for the rest of the set – and you're done!

🗺️ How the maps combine

Often the outline diffuse and emissive maps should be opposites (white and transparent become black, black becomes white or transparent). Depending on what you want to achieve they might not follow that pattern, I've made a handy chart to help clarify when you should use black, white or transparent in each map.

Keep in mind that if emissive colours are allowed to mix with the diffuse/outline colours, the darker the emissive colour is, or the brighter the diffuse/outline colour is, the weaker the effect.

🎲 Conclusion

The Poison Envy dice set uses a simple gradient, so the outline and emissive maps weren't too difficult to make. A more complicated arrangement of colours – such as the Star Teller set –  just means you need more detailed map textures.

If you're decent at image editing, you should be able to filter out specific colours from the original coloured texture to be black/white/transparent without too much difficulty. Here we can see how the emissive map is applied.  The transparent parts show on the dice as pink/yellow, and the white parts show as cyan/green.

I hope this helps with your dice making!

This is a guest post written by NatoPotato, one of our featured community dice creators. You can check out all his dice on his creator page and give them a remix, send him a discord friend request @nat0p0tat0 (zeros, not ohs), or check out his steam workshop creations!

The landscape of online TTRPG play has seen substantial growth in recent years. Platforms like Twitch and YouTube host vibrant communities of D&D and other RPG streams, while numerous new Virtual Tabletops (VTTs), character generators, and GM toolkits have emerged into the limelight. In tandem, a variety of apps boasting dice rolling features have been developed to cater to these online players. Here, we aim to highlight a selection of our preferred tools.

To keep this list concise, we've focused on dice rollers that meet these three key criteria:

1. Cross-Platform Compatibility: Available for Windows, Mac, Linux, iOS, and Android.
2. Online Functionality: Allows dice rolls to be shared in live multiplayer settings.
3. 3D Visuals: Provides visually appealing dice animations akin to physical dice.

dddice

dddice has significantly expanded its scope by prioritizing digital dice portability. It's become the favored dice roller for many new VTT and dice projects. Notably, it's integrated with diverse platforms like Tabyltop (a new VTT), QuestBound (a customizable RPG rules engine), and an upcoming multifaceted platform called AllTheRPGs, encompassing social media, universal character sheets, and RPG event planning.

Additionally, dddice integrates seamlessly with popular VTTs like Roll20, Foundry VTT, Owlbear Rodeo, and TaleSpire, and interfaces with character builders such as D&D Beyond and Pathbuilder 2e. It offers a suite of tools for D&D Live streamers, including overlays for roll results, rolls themselves, and a Stream Deck plug-in. With access from 18 different locations, users can enjoy dice animations anywhere they are connected.

👍 Pros

1. 10k+ community created dice themes
2. No signup required, start rolling in seconds
3. Support for Dungeons & Dragons, Pathfinder, World of Darkness, Fate, Call of Cthulhu, Genesys and Fantasy Flight Star Wars
4. Customize 3D dice via an easy-to-use editor or more robust API
5. Share custom dice with your friends
6. Streamer support
7. Support for third-party apps via API and SDK

👎 Cons

1. Not a VTT, doesn't do character creation or automation of characters natively so you'll have to use a plugin to handle this
2. No native app support (but mobile works well enough!)
3. Lack of custom shapes, no gem d4s or d100 balls

D&D Beyond

D&D Beyond is great tool you are playing D&D. If you play online then chances are you may already use this, but to those just starting their online RPG experience, this is worth checking out.

The dice offering of D&D Beyond is not as robust. The biggest con here is only the user rolling the dice sees the actual 3D dice roll, the party just gets the final number in a pop up. It's a shame too, because some of the dice sets are really beautiful and some are only available via pre-orders. Sure, having rare dice is cool, but rolling them in front of your friends is cooler.

👍 Pros

1. You probably already use D&D Beyond for your character sheets
2. Beautifully animated 3D dice

👎 Cons

1. Party members only see results, not the animated dice
2. Limited, but growing die selection (additional themes are $6+)
3. No dice outside the standard set used for D&D
4. No customization of the dice

Roll20

Roll20 is a full-fledged, super popular VTT. It does have 3D dice, but unfortunately it's offering is the slimmest of all on this list. There is one theme, and the color is matched your player color. If all you want is the dice, this probably isn't for you, but if VTTs are your thing this is a strong choice.

👍 Pros

1. Super popular VTT
2. Just a bit of config to enable the 3D Dice

👎 Cons

1. Roll20 is a full VTT, users need to create an account and create a game to roll 3D dice
2. The color of the die matches your player color, no other customization options
3. Not all dice types are rollable in 3D, Fudge dice are the notable exception
4. Lacks proper mobile support

Dice So Nice (for Foundry VTT)

This is our second VTT option. Dice So Nice is a plug-in for Foundry VTT, also a very popular VTT. Unless you are already on the Foundry platform this is the highest investment in time and money required roll 3D dice.

If you are already using Foundry or are keen to get started with it, this might be the choice for you.

Users are able to customize there dice, and there are a few modules in the Foundry VTT module listing that add more dice to the options. You can also buy sets from RollSmith.com that come in the form of a paid Foundry VTT module

👍 Pros

1. Integrated into Foundry which many people use already
2. Independent dice creators sell dice sets

👎 Cons

1. One-time purchase of $50
2. Need to self-host or pay for hosting to roll with your party
3. Foundry has a steep learning curve
4. Lacks proper mobile support
5. Players can't bring their own dice, the GM needs to install the dice into the world

Owlbear Rodeo 2.0

I'm sure you have all heard about Owlbear Rodeo. It's a super simple VTT that is easy, intuitive and your players can get playing no sign up required.

Last year the 2.0 version was released, an improved dice roller. This time you can see what other people roll!

👍 Pros

1. Physics based rolling that rolls and tumbles identically on everyone's screen
2. Fast and easy to use, just like the rest of Owlbear Rodeo

👎 Cons

1. No dice customization
2. Can only roll one color of dice at a time
3. Only the standard D&D  dice are available

Honorable Mentions

This section is for notable dice rollers that didn't make the top 5 but still fit the criteria.

Lets Role

Has a shop with some really nice 3d dice!

Fantasy Grounds

A popular VTT with 3D dice you can roll!

Conclusion

There are many ways to get your roll on! All it takes is finding the right tool for you and your party.

For us, 3D dice are a must, without them, part of the core essence of the game is lost.

If you play online with a VTT or character sheet that has them already build in, and you are happy with the dice choices provided, you are set! If you play in more than one game and want to bring your dice with you, or you want to try your hand an 3D dice crafting, give dddice a look!

Happy Rolling 🎲

If you're interested in joining our growing community, join our Discord, follow us on X (formerly known as Twitter), join the subreddit, and stay tuned for more updates.

If you had to pick one thing that all tabletop RPGs have in common, you'd probably say it's rolling dice. I knew from the beginning that dice rolling mechanics would play a huge part of my app, but deprioritized a nice interface in favor of the more niche features I wanted to bring to the community. When I found out that the fantastically approachable dddice SDK lets you integrate a 3D dice rolling UI with almost no effort, I was instantly sold. Here's a quick overview of my strategy for integrating my app with dddice.

🧪 The Use Case

My name's Curt and I'm the creator of a tabletop role-playing game engine called Quest Bound. Quest Bound is an application for creating custom TTRPGs or recreating your favorite ones in a digital format. You could think of it as making your own "D&D Beyond", but for any tabletop RPG. Once your ruleset and custom, automated character sheets are created, you can make a character and bring it to the table or virtual tabletop.

That, of course, means rolling dice. From anywhere within Quest Bound, users may open a dice panel, select any number of dice and roll. Quest Bound will provide the UI for dice selection, authentication and switching between rooms--all wrappers around the dddice API. The dddice SDK will provide the 3D rolling animations and real time connection to sync rolls between platforms.

🎲 Rolling without Friction

One of the (many) advantages of using dddice is giving users the ability to sync rolls between platforms. This is crucial for integrating Quest Bound with virtual tabletops, but I also wanted to lower the friction to rolling as much as possible. Quest Bound is often used as a platform for solo play, so needing to authenticate with the online dice roller would be a non-starter.

Fortunately, the dddice API has an endpoint for creating a guest user that requires no authentication. Guest users can roll, create and join rooms, giving Quest Bound all the functionality it needs without requiring users to login. Perfect!

Of course, users should have the option of authenticating with their dddice account as well. Authenticated users can choose 3D dice from their Digital Dice Box and select from their existing rooms.

Here's the plan – Quest Bound users who login for the first time will have a dddice guest user created on their behalf, which will be used to roll. At anytime, they can authenticate with their dddice account to select a room and choose a theme from their Digital Dice Box.

⚒ Working with the dddice SDK

The SDK is a pleasure to use. Instantiating it requires only a ref to a canvas element and the user auth token. I made a custom hook, useDice, that took the canvas ref as an argument. The rest of the authentication logic is held within the hook.

That logic mostly boiled down to two functions, plus a few helpers to wrap the API endpoints.

export const authenticateDddiceUser = async (): Promise<DiceUser> => {
  // These are pulled from Cookies
  const authUserToken = getToken();
  const guestUserToken = getGuestToken();

  const token = authUserToken ?? guestUserToken;
  const isGuest = !authUserToken;

  if (token) {
    const user = await getUser(token);
    const { roomSlug, roomName, roomPasscode, rooms } = await getLastRoom(token, isGuest);
    return {
      roomSlug,
      roomName,
      roomPasscode,
      userToken: token,
      username: user.data.username,
      userId: user.data.uuid,
      rooms: !isGuest ? rooms : [],
      isGuest,
    };
  }

  const res = await bootstrapGuestUser();
  return res;
};

const bootstrapGuestUser = async () => {
  const userToken = await createGuestUser();
  setGuestToken(userToken);

  const { slug, name } = await createRoom(userToken);
  // This slug is used in the getLastRoom function
  localStorage.setItem('dddice-guest-room', slug);

  const guestUser = await getUser(userToken);

  return {
    roomSlug: slug,
    roomName: name,
    userToken,
    userId: guestUser.data.uuid,
    username: guestUser.data.username,
    rooms: [],
    isGuest: true,
  };
};

Just like that, 3D dice rolling across Quest Bound!

🔑 Third Party Authentication

When it comes time for users to login to their dddice account, you can follow the third party auth flow. All you have to do is create an activation code, then poll for that code's usage. Once the user accepts the code in another tab, you can retrieve their token from the readActivationCode endpoint.

Create a new instance of the SDK with the new token and be sure to provide it within the authorization header of the dddice API calls.

🚀 Conclusion

Working with the dddice SDK was a great experience. Within a couple of hours, Quest Bound had a robust dice rolling mechanism with 3D elements, authentication and real time syncing between platforms. I'm looking forward to following the latest dddice features and continuing to build out this integration.

This is a guest post written by Curt, the founder of Quest Bound. You can sign up for Early Access, or follow Quest Bound's development on their blog, insta or join their discord!

Symbiotes are a unique take to third-party extensions that the developers at Bouncyrock are taking to allow the community to expand its functionality. The name symbiotes is very apt. Unlike other extension methodologies the symbiote is not subordinate to TaleSpire nor given free rein to change everything. Rather, TaleSpire allows the symbiote to run alongside (especially during full screen mode) and each can enhance the other via an API. Very symbiotic if you ask me! I’m not going to go into the technical details, you can get a much better explanation from the dev logs on the subject or in the official docs. I will, however, share my experience building a symbiote for my own app dddice!

I get into the details at the Bouncyrock Dev Blog – read the rest over there.

With the release of particle effects in v0.13.0 we have had some really cool submissions. These effects can really bring out the elemental nature of the dice. Read on for a list of dice to enhance the viauals of your elemental attacks!

🔥 Fire

The first dice that come to mind for fire are the coal dice! Complete with licks of flame.

Coal - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

This dice set is only available to our Patreon supporters. Support us on Patreon to get access.

A second option is the Fireball dice by handa. There are no particle effects on this one, but the coloration says it all!

Fireball - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

🥶 Cold

There are so many options for cold damage but I have limeted myself to two. The first is  Jötunnsteinn! This dice set by handa is so cold that they cause snow to fall.

Jötunnsteinn - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

The second is Snow by Amira with a snow flake motif.

Snow - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

🤢 Poison

There is a bit of a debate as to which color represents poison. Some say green and some say purple. Whicheber camp you fall in we have a dice set for you! First up is Poison Envy by NAT0P0TAT0.

Poison Envy - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

For team purple we have a dice set that was creatred using our "remix" feature. A purple version of Poison Envy called Arkalist by Archvirtualist.

Arkalis - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

💀 Necrotic

Necrotic dammage is the type of death, disease and wasting away. We have two sets by user j3str3.

The first is Purple Haze. I personally assocatre necrotic damage with purple. Combine that with the skull on the 20 ans it really fits.

Purple Haze - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

The second is Skull and Roses. The stringy red patterns reminds me of veins. Its very mecabre when combined with the skull imadry. So Skul, much Necrotic.

Skull and Roses - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

🌩️ Lightning and Thunder

While I do understand the technical differences between lightning and thunder damage, visually, they always tend to lump together in my mind. Our first entry, Heart of the Storm by j3str3 is a good example. featuring a lightning bolt and a blue, textured and shiny surface; is it lightning, is it thunder or is it both?

Heart of the Storm - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

The second takes a much smaller approach to the subject, the dice set Sparks by boss9o5. With images of sparks, or maybe fireworks in the side. Sparks could definitely do some lightning damage, but fireworks would be thunder (or maybe a but of fire too). Seeng my point yet?

Sparks - 3D Dice for Dungeons & Dragons | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live or connect with tools such as Roll20, Foundry VTT, and D&D Beyond to bring your dice collection everywhere.

dddice

🎲 Dice dice everywhere!

these are but a small sample of the 5000+ community created dice available. Most of these have been created using our dice editor. Its very powerful yet accessable. I look forward to what you all create and to expand this list as the rest of the damage types get some representatives .

If you're interested in joining our growing community, join our Discord, follow us on Twitter, join the subreddit, and stay tuned for more updates.

In previous blog posts I have explained how to upload dice set via our API, and even how to use Blender to update the dice models. In this article I will walk you though the process of creating a set of dice completely within Blender and use the dddice API to upload it so you can roll it on our platform.

To follow this workflow you will need Blender, as well as a plugin called SimpleBake. SimpleBake is unfortunately not a free tool. As of the time of this writing it costs $16 USD. Its possible bake all the texture you need without it, but its a cumbersome process, the money was well worth it.

🎬Getting Started

To get started, use this Blender file that has our basic dice geometries. Be careful how you modify these models. Any rotation will have consequences in the physics engine that could cause your dice to show incorrect faces, or even land on edge.

Alternatively you can download these fbx files and import them into blender

📂Opening the template file

Once you open the template file you should see something like the above. These are the basic dice meshes. Its perfectly possible to create really amazing dice without touching the mesh at all. In fact, most of our featured themes all share these meshes.

In our blog post about how we created our pride month dice, we explain the 3 sets of UV coordinates that have been defined in our meshes. You can also get exported UV templates from our documentation on dice creation.

Next we will hop over to the Shading tab, and with a bit of cooking show magic, create ourselves a material using the node based shaders.

🥧Baking the models

We suggest you watch the SimpleBake tutorial video to understand all the options so that you can select the right ones for your shader. For example, SimpleBake isn't able to auto-detect which textures to bake, you need to select them. However here are some important parameters you need for things to import correctly into dddice:

Make sure all models have the UV Coordinate set "UV_Packed" selected as active.

Bake your textures at 1024 x 1024.

Use these "Export Settings":

• Check "Export Bakes"
• Check "Export mesh"
• Check "Sub-folder per object"
• Set "Export Form" to GLTF 

📃Making the manifest

Uploading exported glTF dice via the API is a much simpler process than the method described in other blog posts. The reason for this is that all texture and shader data is packed in the gLTF files, so none of that needs to be detailed in the manifest.

Here is an example of a gLTF manifest

{
  "id": "bloodreign-gltf",
  "version": "1.0.0",
  "api_version": "2.0",
  "name": "gLTF demo",
  "description": "First anniversary dice redone in gLTF",
  "label": {
    "color": "#ffffff",
    "background_color": "#1f1f1f"
  },
  "meshes": {
    "d4": "d04.glb",
    "d6": "d06.glb",
    "d8": "d08.glb",
    "d10": "d10.glb",
    "d10x": "d10x.glb",
    "d12": "d12.glb",
    "d20": "d20.glb"
  }
}

As you can see, you only need the generic metadata (id, version, api_version, name, description, and label) plus the meshes section.

If you are making a set of dice that isn't the standard d4 to d20 set, you will need to add other sections like available_dice or values. If you are using gLTF meshes, the vert_shader, frag_shader, textures, and uniform keys are ignored, but all the others can be used.

More details can be found in our previous post on the API.

↗Uploading via the API

Once you have you manifest definition written out it is time to upload it all with the API. You should read the documentation to familiarize yourself with uploading a theme. When I upload my themes I use a bash script to automate most of it. I ❤ automation.

To use this script you will need node.js and jq installed as well as a bash run environment.

#!/usr/bin/env bash
shopt -s nullglob
shopt -s extglob
API_URI='https://dddice.com'

# set the working dir
WORKING_DIR=${1:-.}
WORKING_DIR=${WORKING_DIR%/}
MANIFEST="${WORKING_DIR}/manifest.json"

# increment the minor version number
# this is the part that needs node.js and jq
# you can comment these out safely if you don't have them
# you will need to increment the version number by hand
VERSION=$(jq -r ".version" "$MANIFEST")
VERSION=$(npx semver -i patch "$VERSION")
CONTENTS=$(jq ".version=\"${VERSION}\"" "$MANIFEST")
echo -E "${CONTENTS}" > "$MANIFEST"

# build the curl command
COMMAND="curl --header 'Authorization: Bearer ${API_KEY}' --header 'Accept: application/json' -F manifest='<${MANIFEST}'"

# find all the assets in the working dir
for asset in "$WORKING_DIR"/*.+(jpg|png|fbx|glb|gltf|mp3|wav|webp); do
    COMMAND="${COMMAND} -F $(basename ${asset})='@${asset}'";
done

# find all the shaders
for shader in "$WORKING_DIR"/*frag*; do
    COMMAND="${COMMAND} -F frag_shader='<${shader}'";
done
for shader in "$WORKING_DIR"/*vert*; do
    COMMAND="${COMMAND} -F vert_shader='<${shader}'";
done

# execute the curl command
bash -c "$COMMAND $API_URI/api/1.0/theme"

This script searches a directory for your asset files, then combines them with the manifest.json in the same directory and uploads them via curl. Super helpful. Make sure to generate your API key first and export API_KEY=<your api key here>.

I look forward to all the dice you will create with this API.

If you're interested in joining our growing community, join our Discord, follow us on Twitter, join the subreddit, and stay tuned for more updates.

Third-party extensions are a tried and true method of allowing the general community to add functionality to an existing piece of software. I'm sure I don't need to remind you of the plethora of browser extensions that have become available over the decades since browsers made such available. As of February 2023, Owlbear Rodeo 2.0 has expanded their application to allow third-party extensions. I will be taking you though what it was like building an extension for Owlbear, as a third-party developer.

I get into the details in a guest post on the Owlbear Rodeo Development Blog — You can read it over there.

Virtual Tabletops (VTT) have undoubtedly made tabletop role-playing games such as Dungeons & Dragons more accessible and approachable. VTTs and similar software have also helped other tabletop systems such as Pathfinder and Call of Cthulhu explode in popularity.

What is a VTT?

A Virtual Tabletop is a piece of software that offers useful tools to play tabletop role-playing games (TTRPGs) online and sometimes offline. There are many out there that offer immersive visualizations for players, faster automation for attack and damage rolls, and can even offer reliable communication tools with audio and video chat for your whole party. With all these tools available, you can practically replicate the experience of a real tabletop entirely online and this experience is extremely appealing to many.

VTTs can come with a cost however.

The Cost of VTTs

Many VTTs are subscription-based and only offer certain features behind a paywall. Others can be costly upfront and require a reasonable amount of tinkering to get just right. No one tool fits all parties, though many VTTs are trying, and this can lead to increased complexity and a steep learning curve.

With so many VTT options, starting a new TTRPG can sometimes feel like a daunting task.

Play TTRPGs, No VTT Required

There is another way to play tabletop role-playing games online.

Theater of the Mind is one of the purest and often the easiest way to play TTRPGs. To start, all you need is some dice and a good imagination.

Tools for Theater of the Mind

Tools such as dddice offer a simple, alternative interface to engage in your favorite tabletop role-playing games. dddice is a multiplayer 3D dice roller that allows you to roll, collect, and create 3D dice with your friends (or foes). There is no sign-up required and all features of dddice are completely free.

dddice promises and delivers on a single core component of all TTRPGs, rolling dice! No complicated map setup, character creation, or scene management - simply pick your favorite dice and start rolling. In combination with other free tools such as Discord or Zoom, starting a new TTRPG with your party has never been easier.

Still Want to Use a VTT?

Awesome! dddice can be combined with your favorite tabletop software such as Roll20, Foundry VTT, and even the Elgato Stream Deck!

Don't like paper character sheets? Try dddice's D&D Beyond plugin. Want to use maps in Foundry VTT? Try dddice's Foundry VTT plugin.

Use your favorite tools to automate character creation or create immersive maps and leverage dddice to roll click-clacks anywhere you are.

Conclusion

If you're looking for an easy way to play tabletop role-playing games online, dddice offers an infinite number of different dice and dice themes to choose from and let's you roll live with your party in seconds - no signup required!

If you're interested in joining our growing community, join our Discord, follow us on Twitter, join the subreddit, and stay tuned for more updates.

So what are you waiting for? Get rolling and have fun!

dddice is a simple platform to roll 3D dice with friends. Well ... we say simple but the infrastructure that powers over 60,000 rolls (and growing) has also grew in complexity. Our users depend on us for their game nights and there is nothing worse than something going wrong during a fun night with friends.

We sincerely value our amazing community and in order to support the next 1,000,000 rolls and users, we have taken on some unseen but necessary backend work to ensure we are shipping consistently stable and performant software.

If you enjoy articles about "how the sausage is made", then read on!

What powers dddice?

Since our humble beginnings, dddice has been powered by a monolithic PHP backend using MySQL and Redis databases to serve up pages and WebSocket connections. We believe in choosing boring technology that is predictable and dependable.

All of our sites have been hosted on a single Virtual Machine (VM) living in the cloud. During our growth, we only upgraded this server once - from a 2 vCPU/4GB RAM VM to a beefier 4 vCPU/8GB RAM VM.

This VM, up until now, powered our main application, several background workers, cron jobs, this blog, our documentation site, an internal company handbook, a WebSocket server, and a chromedriver instance used to generate previews for custom dice themes.

It wasn't much, but it was honest work and it served us well.

While nothing was particularly wrong with our VM, it was clear that dddice was growing and so were our users' expectations. We wanted to ensure that every single update was ready to handle the traffic that a large gaming group brought. Not only did we seek to meet our users' expectations, we wanted to exceed them. Obviously a single VM was not going to make the cut for a global-ready platform designed for everyone to enjoy.

In order to ready ourselves for a global audience, we began the arduous process of analyzing our MySQL tables, dissecting every bit of our infrastructure, and making the necessary changes needed to ensure we stay performant and stable throughout our growth.

Picking the right horses

Our company handbook meticulously outlines how to architect our applications. When we began, we set a high-standard to ensure everything we did was "portable". This meant if we wanted to drop a hosting provider or a particular service and move to another, we could with little to no changes to our codebase or deployment system. Take into consideration that dddice is built by two people working part-time, we needed processes in place to make changes sane to develop and deploy. Building a gaming service is no easy task especially given the high standards that gamers often have.

We have since adopted a new philosophy, "picking the right horses for the race." This means we carefully analyze our previous and future needs to pick infrastructure that makes sense for the next 1,000,000 users. Instead of writing messy configuration files for the sake of portability, we instead have decided to write the necessary interfaces that interact with the right services that provide us ultimate performance and stability.

So what are the right horses?

Our new infrastructure uses Fly.io as our hosting platform which allows us to deploy our application close to our users. Instead of a single VM hosted in Newark, NJ, we now have the luxury to deploy dddice anywhere our users are and serve pages and WebSocket connections fast. We can scale to dozens, hundreds, or thousands of servers anywhere in the world all with a single command.

We also dropped MySQL for Vitess, specifically hosted with PlanetScale as our database of choice. Instead of dealing with the headaches that come with MySQL read-write replicas, we now offload those tasks with someone we can trust. Our backend has been updated to support read-write replication which makes page loads faster for our global users. Similar to Fly, we can deploy multi-region databases with a single command.

All of our services and sites are reliably deployed using GitHub Actions which has replaced our growing mess of Terraform templates.

These services give us the peace-of-mind that growth spikes are not going to bring us to a grinding halt.

Testing, Testing ... Is this thing on?

We pride ourselves on stability; however, dddice is considered to be alpha software which means things can be expected to break from time-to-time. It is far from our intention, but we have been attempting to move fast to meet user demands.

v0.6.0 is the first release to heavily focus on testing which is providing more confidence in our systems. We have begun to focus on three fundamental types of testing for maximum assurance: unit, integration, and end-to-end.

Our unit tests are starting to capture the small user-interface nuances and bugfixes we make to ensure these work correctly through updates. Our integration tests are providing clarity into our API and how it responds to good and bad inputs. End-to-end tests are ensuring everything works together in harmony. While end-to-end tests are sometimes slow, we are focusing heavily in this department to ensure our tests capture and assure the exact user experience.

We hope in the next few minor releases (v0.7.x and on), we will start to transition from alpha software to something much more predictably stable.

Conclusion

We have made significant improves to our company culture, architecture, and infrastructure to best support the next cycle of growth. We continue to operate with a tiny-but-mighty team to build the best dice rolling service possible.

We are proud of the platform we built and the community we have fostered so far.

If you're interested in joining our growing community, join our Discord, follow us on Twitter, join the subreddit, and stay tuned for more updates.

We hope to dive deeper into some of our infrastructure in future posts.

Until then - happy rolling!

So your party has a night in a tavern. It's been a long journey and now everyone is looking forward to relaxing, having a pint of grog, and tossing some dice around (perhaps winning some copper?)

We've compiled a small list of dice games you can play while enjoying your stay at a tavern or anywhere your party might have a moment of downtime.

Liar's Dice

This game can be played with 2 or more players, no deception checks required.

How to Play

Each player begins by rolling 5 six-sided dice (5d6) while concealing their roll.

The first player begins by announcing any face value and the minimum number of dice that have that value. For example, a player can say, "I have two 3's" implying there are at least two dice rolls that are "3". Rolls of "1" can be considered "wildcards", meaning they can be used as a placeholder for another value.

The next player sitting clockwise from the first player then can make two choices: challenge the previous player by declaring, "LIAR", or raising the stakes by announcing they have more dice rolls at the given face value or a higher face value. For example, the next player can either say, "I have two 4's", a higher face value or, "I have three 3's", a higher quantity of the previous bid.

If a player declares, "liar", then all players reveal their dice and a winner is declared. If the challenger successfully finds the liar then they win, otherwise the original bidder wins.

You are free to choose how betting might work - whether it's copper, silver, or dice!

Avandra's Favor

Avandra's Favor or sometimes called "The Changebringer's Favor" is a simple dice game popularized by the critically-acclaimed Critical Role.

How to Play

The rules are simple, a player places a bet and rolls two six-sided dice (2d6).

The roll total must total 7 or 12. If the total is not these two numbers, the player loses and can choose to walk away or double their bet to roll an additional six-sided dice (1d6) in order to make the total equal 7 or 12. If one of these totals is reached, the player wins their bet.

Pig

Pig is a simple dice game that involves a single six-sided die (1d6). First player to score 100-points wins.

How to Play

Players take turns rolling a six-sided die (1d6) and adding the value to a running total; however, if a player rolls a "1", all points for that turn are lost.

A player can roll as many times as they like in a single turn. A player's turn ends when a "1" is rolled or the player decides to "hold".

The first player to score 100-points or more wins.

Chō-han

Another simple dice game that requires only two six-sided dice (2d6) and puts the Game Master front-and-center.

How to Play

The Game Master rolls two six-sided dice (2d6) and conceals the roll. Players then take turns betting if the roll is "Chō" (even) or "Han" (odd).  Players often bet by bartering bets between each other. Once all bets are placed, the Game Master reveals the dice and the winners collect their earnings.

Conclusion

There are a handful (😏) of dice games to play while your party has some downtime.

If you're looking for an easy way to play some of these games, dddice offers an infinite number of different dice and dice themes to choose from and let's you roll live with your party in seconds - no signup required! To conceal rolls, use the "Hidden Roll" feature and invoke mystery by revealing your rolls to other connected players.

If you're interested in joining our growing community, join our Discord, follow us on Twitter, join the subreddit, and stay tuned for more updates.

So what are you waiting for? Get rolling and have fun!

While we do have an editor for our online dice, one that let's you remix our themes or even create your own, it has its limits. If you want a truly unlimited dice creation experience you need to use the API, and core to that is understanding the dddice manifest definition.

Typically, a 3D model consists of meshes, shaders, and parameters to those shaders, aka uniforms. A dice set is, simply put, a collection of all the things that make up 3D models, enough to define all the dice in the set. The dddice manifest is what the API uses to bind all these pieces together.

Manifest example

The dddice manifest is a well-defined JSON object, here is an example:

{
  "id": "dddice-standard",
  "version": "1.0.0",
  "api_version": "2.0",
  "name": "Standard",
  "description": "Just your average set of dice, nothing too fancy.",
  "label": {
    "color": "#000000",
    "background_color": "#e3d12d"
  },
  "frag_shader": "shader.frag",
  "vert_shader": "shader.vert",
  "available_dice": [
    {
      "id": "d4",
      "type": "d4"
    },
    {
      "id": "d6",
      "type": "d6"
    },
    {
      "id": "d8",
      "type": "d8"
    },
    {
      "id": "d10",
      "type": "d10"
    },
    {
      "id": "d10x",
      "type": "d10"
    },
    {
      "id": "d12",
      "type": "d12"
    },
    {
      "id": "d20",
      "type": "d20"
    }
  ],
  "textures": [
    {
      "binding": "u_numberMap",
      "src": {
        "d4": "standard.png",
        "d6": "standard.png",
        "d8": "standard.png",
        "d10": "standard.png",
        "d12": "standard.png",
        "d20": "standard.png",
        "d10x": "standard_d10x.png"
      }
    }
  ],
  "uniforms": {
    "diffuse": {
      "type": "color",
      "value": {
        "r": 1,
        "g": 0.929,
        "b": 0
      }
    },
    "number": {
      "type": "color",
      "value": {
        "r": 0.463,
        "g": 0.424,
        "b": 0
      }
    },
    "specular": {
      "type": "color",
      "value": {
        "r": 0.1,
        "g": 0.1,
        "b": 0.1
      }
    },
    "shininess": {
      "type": "f",
      "value": 30
    }
  },
  "meshes": {
    "d4": "d04.fbx",
    "d6": "d06.fbx",
    "d8": "d08.fbx",
    "d10": "d10.fbx",
    "d10x": "d10.fbx",
    "d12": "d12.fbx",
    "d20": "d20.fbx"
  },
  "sizes": {
    "d4": 1,
    "d6": 1,
    "d8": 1,
    "d10": 1,
    "d10x": 1,
    "d12": 1,
    "d20": 1
  },
  "values": {
    "d4": [
      1,
      2,
      3,
      4
    ],
    "d6": [
      1,
      2,
      3,
      4,
      5,
      6
    ],
    "d8": [
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8
    ],
    "d10": [
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8,
      9,
      10
    ],
    "d10x": [
      10,
      20,
      30,
      40,
      50,
      60,
      70,
      80,
      90,
      0
    ],
    "d12": [
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8,
      9,
      10
    ],
    "d20": [
      1,
      2,
      3,
      4,
      5,
      6,
      7,
      8,
      9,
      10,
      11,
      12,
      13,
      14,
      15,
      16,
      17,
      18,
      19,
      20
    ]
  }
}

The src element

Before we get into each individual section, let's start with how we handle the src element. Everywhere in the manifest this can either be a string, or an object. The string is used to apply that value to all dice in the set; the object to define different sources for each die in the set. For example, we can use a string to define a single texture that is used for all dice in a set OR we can define an object to define different textures for different dice models.

Metadata

The first section above defines metadata about the die, the required ones are:

1. id – a unique ID following slug format to identify your dice to the system.
2. version – a version number for this die following semver 2.0.0. The API does not allow updating a version once submitted, so your id/version combo must be unique.
3. api_version – the version of the API you are targeting with your file. Right now only version 2.0 themes are allowed.
4. name –  the human readable name that is displayed to users, doesn't have to be unique.
5. description – the description you want for your dice, shows up on the dice share and info pages.
6. label – defines the colors used to display the name of your dice within the app, color is the font color and background_color is the... background color

Available Dice

The available_dice definition is an important bit of data that has effects on the rest of the manifest definition. It defines which dice are in the set, and what roll physics they use. You can read more about the data structure in our SDK documentation. The important thing to point out here is that the id's you select are used as the keys in the other objects in the file, particularly the src objects. If you are lazy and you intend for all of id, notation, and type to be equal, you can use a string instead of an object.

The second important point is that the order of this array is important. Its the order the dice are shown in to the user in previews. The final die is used if only one die can be shown.

Shaders

This section defines the 3D shaders to apply to you dice. You have 3 general options here: supply no shader info, add your shader code as a JSON-encoded string, or reference an external .frag, .vert or .glsl file. There are two keys: frag_shader for your fragment shade and vert_shader for your vertex shader.

In the example we reference external files shader.frag and shader.vert which define our fragment shader and vertex shader, respecitvely.

If you supply no shader information, the dice will default to the shader used by the dddice-standard theme. Its based on phong, and you can read about it in a previous blog post of ours. We also have an entire section of shader articles for you to read with articles that have details on how we built our other shaders.

Textures

This section is for specifying the textures that will be applied to your mesh. Its an array of objects. Each object has a binding key which is the uniform name to bind to and a src key which is the file name of the texture. As noted above, src can be a string, meaning a single file that applies to all dice in the set, or a src object (like in the example) where the file varies.

Our shaders are based off of three.js shaders, so look there for more details. For our standard shader we added u_numberMap on top of those from the MeshPhongMaterial of three.js.

The u_numberMap is a texture layer that contains the numbers to put on the faces. When a user rolls a "hidden" die, this texture isn't displayed (thus hiding the numbers). When that die gets unhidden, this texture is faded in.

Uniforms

This section defines uniforms that are passed to the shader. Like the textures (which are just really uniforms from the pov of the shader) we support the uniforms defined in the three.js shaders we stand on top of. You can set values for any uniforms the shaders expose here. Our standard shader supports all the uniforms defined in MeshPhongMaterial just like the textures.

The data model is based on the uniform data model of three.js, with one additional feature, a color uniform type. Despite what the linked doc says, the native underlying material we use (ShaderMaterial) doesn't support colors defined using rgb hex strings. So we added our own layer. If you use the color type you can use normal everyday hex strings. If you use vec3 you need to specify the colors in a linear color space, a float from 0 to 1.

In addition our standard shader defines a numbers uniform to tint the color of the u_numbersMap texture. If the numbers in that texture are in white, this becomes a coinvent way to change their color. It will also allow users who remix your die the most flexibility in changing the number's colors.

If you are not using a u_numberMap then the number uniform needs to be set to white . Otherwise the color acts as a diffuse color, and if not set it will make your die all black!

Sounds

The sounds section isn't included in the example above as its optional, but also a bit complicated. This section allows you to customize the sounds the dice make when they collide with each other during the roll and the sounds the dice make when "shaken" before a roll. You can also select a sound to play when a particular face is the final result. Check out our musical dice for an example of that!

{
...
"sounds":[
    {
      "on": "die.value",
      "src": "G4.wav",
      "value": 20
    },
    {
      "on": "die.collide",
      "src": "roll.mp3"
    },
    {
      "on": "roll.loading",
      "src": "shake.mp3",
      "value": ">=2"
    }
  ]
...
}

Collision Sounds

Sounds that roll on collisions need the on key set to die.collide. The src key then contains the name of the mp3 file to play. We recommend these sounds to be abut 1s in length and have little starting and trailing silence.

If you specify more than one die.collide sound, for each roll made, one of the sounds will be used at random.

Shake Sounds

Sounds that play during the "shaking your hand" animation. This is only applicable to the dice rooms on dddice.com at the moment. Set on to die.loading and src to the mp3 you want to play.

You can supply different sounds for different hand sizes using the value key. Its a simple conditional expression with an implied hand_size as the left-hand-side of the evaluation.

Rolled Sounds

Sounds can be played when a ceritian face is rolled. These will play once the roll animation copmletes and the die comes to rest with a particular face showing. Set the on to  die.value and the value to the index of the face to play the sound on.

Optional items

The rest of the keys meshes, sizes and values are purely optional. If you don't specify them, the values shown in the example will be used as defaults.

1. meshes – names of the .fbx files that define the geometries for the dice. Be careful if you edit these, at current the physical simulations don't get their data from the models. If you want to edit the uv coordinates, have at it!
2. sizes – want a huge d20? a tiny d6? edit these values.
3. values – these are the values that get displayed in the chat box when the die is rolled. They are indexed from 1 to max die face. If you do change this, make sure it aligns with your textures and uv coords.

Extending Other Themes

If all the above is daunting, and yeah it kinda is ... you can cut out a bunch of work by extending other themes. Include an extend key with the id of the theme you want to extend. Your new theme will inherit all the values from the theme you extend instead of the defaults. We used this to create the variations of dddice-standard and dddice-old-school. So yeah, programmers be lazy

Upload via the API

Once you have you manifest definition written out and all your textures ready, it is time to upload them with the API. You should read the documentation to familiarize yourself with creating a theme. When I upload my themes I use a bash script to automate most of it. I automation.

To use this script you will need node.js and jq installed as well as a bash run environment.

#!/usr/bin/env bash
shopt -s nullglob
shopt -s extglob
API_URI='https://dddice.com'

# set the working dir
WORKING_DIR=${1:-.}
WORKING_DIR=${WORKING_DIR%/}
MANIFEST="${WORKING_DIR}/manifest.json"

# incriment the minor version number
# this is the part that needs node.js and jq
# you can comment these out safely if you don't have them
# you will need to incriment the version number by hand though
VERSION=$(jq -r ".version" "$MANIFEST")
VERSION=$(npx semver -i patch "$VERSION")
CONTENTS=$(jq ".version=\"${VERSION}\"" "$MANIFEST")
echo -E "${CONTENTS}" > "$MANIFEST"

# build the curl command
COMMAND="curl --header 'Authorization: Bearer ${API_KEY}' --header 'Accept: application/json' -F manifest='<${MANIFEST}'"

# find all the assets in the working dir
for asset in "$WORKING_DIR"/*.+(jpg|png|fbx|glb|gltf|mp3|wav|webp); do
    COMMAND="${COMMAND} -F $(basename ${asset})='@${asset}'";
done

# find all the shaders
for shader in "$WORKING_DIR"/*frag*; do
    COMMAND="${COMMAND} -F frag_shader='<${shader}'";
done
for shader in "$WORKING_DIR"/*vert*; do
    COMMAND="${COMMAND} -F vert_shader='<${shader}'";
done

# execute the curl command
bash -c "$COMMAND $API_URI/api/1.0/theme"

This script searches a directory for any .fbx, .png, .frag, and .vert files, and then combines them with the manifest.json in the same directory and uploads them via curl. Super helpful. Make sure to generate your API key first and export API_KEY=<your api key here>.

I look forward to all the dice you will create with this API.

If you're interested in joining our growing community, join our Discord, follow us on Twitter, join the subreddit, and stay tuned for more updates.

Since the pandemic, more and more tabletop role-playing games have been happening online. This has fueled a huge surge in apps to help mediate the online experience - from Virtual TableTops (i.e. VTTs) to character sheet apps, encounter builders, and world builders. In this article we will be focusing on dice rollers.

Why use a dice roller?

Rolling dice is core to the tabletop role-playing experience, and sharing the suspense and uncertainty they create is second only to the socially interactive nature of the game.

There are a plethora of dice rolling apps that showcase a vast array of features for many different platforms. In order to make this list manageable, we feature dice rollers that meet the three requirements below:

1) Cross Platform: Users should be able to roll on Windows, Mac, Linux, iOS, and Android.
2) Online: Dice rolls should be shared with your party in a live multiplayer setting.
3) 3D: Dice rolls should look good and resemble physical dice.

dddice

Digital 3D dice roller | dddice

Roll 3D dice for tabletop roleplaying games live in your browser. Invite friends to roll live and run your next virtual session for free!

dddice

The newest offering on this list is dddice, having only been released in February of 2022. Despite still being in alpha, it has a full feature set and many 3D dice themes.

This app follows the philosophy of "do one thing and do it well", so if you want a more feature-rich experience for your tabletop gaming sessions, then one of the other apps might be for you. Their roadmap does list VTT integrations but they aren't a reality yet.

👍 Pros

1. Many 3D dice themes
2. No signup required, start rolling in seconds
3. Support for Dungeons & Dragons, Pathfinder, World of Darkness, Fate, and Call of Cthulhu
4. Customize 3D dice via an easy-to-use editor or more robust API
5. Share custom dice with your friends
6. Streamer support
7. Support for third-party apps via API and SDK

👎 Cons

1. New to the scene, not much publicity
2. No integrations with VTTs (yet)
3. Documentation to create own themes is lacking

D&D Beyond

D&D Beyond

An official digital toolset for Fifth Edition (5e) Dungeons & Dragons (D&D).

D&D BeyondMichael Galvis

D&D Beyond is great tool you are playing D&D. If you play online then chances are you may already use this, but to those just starting their online RPG experience, this is worth checking out.

The dice offering of D&D Beyond is not as robust. The biggest con here is only the user rolling the dice sees the actual 3D dice roll, the party just gets the final number in a pop up. It's a shame too, because some of the dice sets are really beautiful and some are only available via pre-orders. Sure, having rare dice is cool, but rolling them in front of your friends is cooler.

👍 Pros

1. You probably already use D&D Beyond for your character sheets
2. Beautifully animated 3D dice

👎 Cons

1. Party members only see results, not the animated dice
2. Limited, but growing die selection (additional themes are $6+)
3. No dice outside the standard set used for D&D
4. No customization of the dice

Roll20

Roll20

Roll20 brings pen-and-paper gameplay to your browser with features that save time and enhance your favorite parts of tabletop games.

Roll20

Roll20 is a full fledged, super popular VTT. It does have 3D dice, but unfortunately it's offering is the slimmest of all on this list. There is one theme, and the color is matched your player color. If all you want is the dice, this probably isn't for you, but if VTTs are your thing this is a strong choice.

👍 Pros

1. Super popular VTT
2. Just a bit of config to enable the 3D Dice

👎 Cons

1. Roll20 is a full VTT, users need to create an account and create a game to roll 3D dice
2. The color of the die matches your player color, no other customization options
3. Not all dice types are rollable in 3D, Fudge dice are the notable exception
4. Lacks proper mobile support

Dice So Nice (for Foundry VTT)

Dice So Nice! | Foundry Virtual Tabletop

Dice So Nice!, a Module available for Foundry Virtual Tabletop

Foundry Virtual TabletopSimone

This is our second VTT option. Dice So Nice is a plug-in for Foundry VTT, also a very popular VTT. Unless you are already on the Foundry platform this is the highest investment in time and money required roll 3D dice.

If you are already using Foundry or are keen to get started with it, this might be the choice for you.

👍 Pros

1. Integrated into Foundry which many people use already
2. Built on top of Major's 3D Dice Roller (see below) so shares many of the features and themes
3. Independent dice creators sell dice sets

👎 Cons

1. One-time purchase of $50
2. Need to self-host or pay for hosting to roll with your party
3. Foundry has a steep learning curve
4. Lacks proper mobile support

Major's 3D Dice Roller

Major's 3D Dice

Online 3D dice roller

MajorsplaceMajorVictory

Majors 3D Dice is at the core of the Dice So Nice plug-in for Foundry VTT. If you liked the dice above but don't want the overhead of buying Foundry, give this one a try.

The dice customization options are plentiful but not very precise. You can choose a few parameters and these influence the dice that are generated.

👍 Pros

1. Dice to support many systems with exotic dice including Genesys, Star Wars, and Fate
2. Plethora of different dice style attributes that can be combined to make dice from

👎 Cons

1. User Interface is not intuitive, looks clunky
2. No true detailed dice customization

Honorable Mentions

This section is for notable dice rollers that didn't fit the 3 criteria but I thought we're worth mentioning because they came close, and are notable.

Rolz

No 3D rolls but features a multiplayer experience.

Teal3D

A basic 3D dice roller with no customization. The oldest one on this list. The original version seems to be down, but mirrors exists and does not have multiplayer functionality.

Conclusion

There are lots of options to roll digital click-clacks!

Winner: If you're looking to get rolling in seconds, dddice looks to be a solid choice. With no signup required and lots of themes to choose from, your party is sure to have a good time rolling for whatever system your party plays.

If your party is looking for a more robust tabletop experience complete with character sheets, a VTT might be what you're looking for. However, with dddice's API and SDK integrations, they may soon be a worthy contender for your favorite VTT.

So what are you waiting for? Start rolling on dddice in seconds now!