We're excited to announce that we're open sourcing the code we used to create an interactive experience that synchronized data for over 3,000 users at major tech events, demonstrating the power and scalability of our newly released Realtime library.

Multiplayer Infinite Craft


One key part of this was making the Super<Game>, which was based on Infinite Craft, multiplayer. The game consists of combining different elements to create new ones, fostering creativity.

Users would start with the essential elements: "Fire", "Water", "Earth", "Wind", "Coffee", "JavaScript", and "Developer". After combining "Fire" and "JavaScript", an AI would analyze the combination and create "Firebase".


Because these events would gather a huge number of people (sometimes 3.5k people), we couldn't synchronize every new element among everyone. This was mainly because the gameplay would not be fun; instead, it would be confusing and stressful. By the end of these events, that would add up to 16k elements. Can you imagine how to display 16k non-structured elements on a mobile screen?

We took a different approach by making it a bit of a race. Everyone would play with a single instance, but in case they found a first discovery (meaning no one before had tried this combination), new points were added to the user, and everyone at the event would get a push notification. With more points, there was a greater chance to win a big prize at the end of the day.

Adding Real-time

We had build with a Next.js project, using our @superviz/realtime package, which offers a WebSocket infrastructure, that is based on a Publisher/Subscriber (PubSub) design pattern. This allowed for efficient event-driven communication between different instances of the application.

For this, we had created two different channels, the default and the game. The default channel was the communication of the whole experience, it would tell if an activation has awarded points to the user, and would sync across other parts of the system (mostly syncing user dada). We had a dedicated channel for the game, that would notify every one that was listening to the new.element event.

When someone combined two elements, it would send a request to our API. The API would analyze if the user was valid and if the element combination already existed in our database. If neither of these conditions were met, it would send a prompt to OpenAI to create the element. Before returning the result, we would update the database and publish several events.

1
await Promise.all([
2
  defaultChannel.publish("activation.game.update", {
3
    userId: user.id,
4
    points: quantity,
5
  }),
6


7
  gameChannel.publish("new.element", {
8
    element,
9
    user,
10
    points: quantity,
11
  }),
12
]);

On the frontend of the game, we would listen to the new.event and add a push notification using toast. Like so:

1
const handleGameUpdate = (message) => {
2
  const userFromMessage = message.data.user;
3
  const element = message.data.element;
4


5
  if (userFromMessage.email ===
6
    JSON.parse(localStorage.getItem(USERDATA_KEY) as string))
7
    return;
8


9
  toast(userFromMessage?.name + " just discovered " + element.name.toUpperCase() + " and has more chance of winnin!");
10
};
11
  
12
useEffect(() => {
13
        gameChannel.subscribe("new.element", handleGameUpdate);
14
}, []);

But the application magic happened on the dashboard and with the other event being dispatched.

A playful dashboard


On our stand, we had a giant TV to display the dashboard. It was designed to be both informative and mesmerizing, displaying real-time updates of player activities and discoveries. It was a visual representation of every single participant activity. Not only kept participants informed of their scores but also fueled friendly competition and excitement throughout the event.

The dashboard was inspired by the popular multiplayer game Agar.io. Much like how players in Agar.io grow by consuming smaller cells, our dashboard represented each participant as a dynamic entity that expanded as they gained points.


The design concept revolved around creating a visually engaging and intuitive representation of real-time data. Each participant was depicted as a circular entity, with concentric rings expanding outward to indicate their score and level of engagement. This organic, cell-like visualization not only made the data easy to interpret at a glance but also added an element of gamification to the event experience. We also would add transparency to those users that were offline to showcase our recent released presence feature.

Behind the scene

To make this happen, this page would listen to every single event, and that was plenty! This is the list of the listening events the page was subscribed:

1
defaultChannel.subscribe("activation.start", handleActivationStart);
2
defaultChannel.subscribe("activation.complete", handleActivationComplete);
3
defaultChannel.subscribe("activation.game.update", handleGameUpdate);
4
gameChannel.subscribe("new.element", handleGameUpdate);
5


6
defaultChannel.presence.subscribe("presence.leave", (message) =>
7
  handleParticipantStatusChange(message.id, false)
8
);
9
defaultChannel.presence.subscribe("presence.joined-room", (message) =>
10
  handleParticipantStatusChange(message.id, true)
11
);
12
defaultChannel.presence.subscribe("presence.update", (message) =>
13
  handleParticipantUpdate(message)
14
);

Let's break down those events our dashboard listens to and explore how each contributes to creating a dynamic, real-time experience:

Activation events: The dashboard listens for activation.start and activation.complete events, which add a progress ring when an activation starts and add a complete ring when it finishes. The rings were added based on the order that the person would participate in the activations, providing a real-time visual story of their journey through the event.

The activation.game.update event was responsible for showcasing real-time progress in the game. It updates the player's score, which is visually represented by expanding the ring around their entity on the dashboard.


Game updates: It subscribes to new.element events from the game channel, which would display a toast notification with the new element created. This feature gathered people around the screen to see what others were creating in real-time, creating a sense of community and shared excitement.

We had seen the creation of beautiful elements, like “Real-time communication”, “Web sockets”, “Collaboration environment”, “Remote work” and funny ones like “Intergalactic coffee”!

Presence events: The code subscribes to various presence-related events, which play a crucial role in maintaining an up-to-date representation of participant activity. These events include:

  • presence.leave: Triggered when a participant goes offline, causing their representation to become semi-transparent on the dashboard.
  • presence.joined-room: Fired when a participant comes online. For new participants, a new cell would enter the screen. For returning participants, it would restore the brightness of their existing cell. This effect allows participants and organizers to easily spot who is currently active in the event.

This real-time updating creates a dynamic, engaging experience for all participants, showcasing the power and versatility of the Realtime library in handling multiple simultaneous events and updates.

Hackathon AI meets Realtime


We recently hosted an Super Hackathon 2.0, with the challenge: AI meets Realtime challenge, pushing the boundaries of innovation by combining artificial intelligence with real-time communication technologies.

Participants were given the freedom to create anything they could imagine, much like our Super<Game>! (But we couldn’t participate in our own hackathon with this project 😢)

The hackathon saw impressive projects that leveraged our Realtime library alongside various AI technologies. The creativity and innovation displayed by the participants were truly remarkable. If you're curious about the winning projects and want to explore how they combined AI with real-time capabilities, we invite you to read our detailed blog post about the hackathon winners. It's a great source of inspiration and showcases the potential of our Realtime library when paired with AI.

After many requests, it’s open source

The overwhelming enthusiasm for our game didn't end with the events. Participants were eager to continue playing, explore without limitations, and people were legitimately addicted to the gameplay. We heard your requests loud and clear!

Now that our new Realtime library is officially released, we're excited to announce that we're making the code for this project open source! This allows you to not only continue playing but also gain a better understanding of how everything works behind the scenes.

You can find the repository on our GitHub page. We encourage you to clone it, experiment with it, and maybe even contribute your own improvements or variations.

Happy coding and crafting!