Coming from the infamous Bhoos game jam, we had a winner, Carrom game made by two Bibeks (Bibek Panthi and Bibek Basyal) duo of Bhoos. Many of the developers created physics based games with realtime elements using React Native, like Carrom, Air Hockey.

React Native, though great for apps, showed its limitations when it came to animating physics-heavy elements in real-time. Hence, we started looking for alternatives.

The Search for the Right Game Engine

Our journey began with curiosity and a little frustration. We asked ourselves: What engine would bring Carrom to life without overcomplicating things?

Unity came first. It iss powerful and industry-standard, but felt bulky for a simple 2D board game. Its 3D focus and larger build sizes were unnecessary for what we wanted.
Godot was next. It looked promising, lightweight, and beginner-friendly.
And then came Defold, which, at that time, felt like the perfect middle ground.

Why Defold?

Defold felt like the perfect fit for the Carrom Game we were trying to make, as it was:

Lightweight and fast
Cross-platform support
Designed for 2D games
Small build size
Focused on mobile performance
Minimal clutter from unnecessary 3D tools

It allowed us to go through the engine's codebase and structure without feeling overwhelmed. And for a casual board game, we did not need any fully-fledged game engine.

From Typescript to Lua

Since most of our games are built in React Native using Typescript, we were used to that ecosystem. Defold, however, uses Lua, a lightweight scripting language popular in game development.

The transition was surprisingly smooth. Lua is a weakly typed language with syntax similar to Python, making it easy to pick up. While Defold technically supports language bindings like Typescript, C++, or Haxe, we stuck with Lua for simplicity (and haven’t explored the bindings yet).

Working with Defold: Learning Curve and Community

Defold is intentionally bare-bones. It gives you infrastructure to build upon, but leaves enough flexibility to approach problems in multiple ways, which is both a strength and a challenge. It can lead to confusion about which method is "right" or most optimal.

Some forum answers are outdated due to frequent updates in the engine, so we often turn to the Defold Discord community for up-to-date support. Thankfully, the official documentation and tutorial videos on their website are solid and provide a great starting point for everyone.

Prototyping and Production

Initially, we used assets from the game jam version of Carrom, with some placeholder designs created by the devs themselves. Once development stabilized, we brought in a designer to revamp the visuals.

Gameplay was always the heart of Carrom. We had a working prototype within days. Once the core mechanics were solid, we built out the backend to enable multiplayer gameplay, making it a complete mobile experience.

Into the World of Carrom: Iteration & Challenges

Humble Beginnings

Early versions were… let’s say chaotic.

Pucks moved too fast, sometimes even passing through each other.
Player states were not syncing properly across devices.
Debugging why one board didn’t match another was a headache.
Eventually, we found that Defold’s bullet option in its physics settings solved collision issues, and our trial-and-error tuning made the gameplay satisfying.

Physics: From Real to Fun

Initially, we converted real-world Carrom measurements into Defold’s physics scale. The result? Painfully sluggish gameplay.

Fun in games doesn’t always come from realism.

We ditched strict realism and adjusted physics by feel ("Trial and error" method). Defold uses Box2D, which gave us enough flexibility to fine-tune collisions and puck motion until the game felt like real Carrom, minus the boredom of waiting for slow pucks.

Building a Team Effort

Behind the scenes, the Bhoos team divided and conquered:

Diya: Design and UI/UX revamp
Nishedh: Networking, WebSockets, Game Logic
Saakshi: Project Manager and Marketing
Sanket: Initial prototype, GUI, animations
Sizan: Motion Designer

Roadblocks We Faced

Responsive Layouts
Unlike Godot, Defold does not have advanced responsive GUI tools. For a game with extra content beyond gameplay, it felt more like building an app inside a game engine. Hence, we used Druid, a popular Defold GUI library.
Memory and Rendering
GUI nodes can quickly pile up, hitting suggested limits. We had to clean up scenes diligently and use proxies to manage memory.

Yes, but with a catch.

Great for mechanic-intensive 2D games where engine efficiency matters.
Not ideal for GUI-heavy mobile apps disguised as games.

For Carrom, Defold was a smart choice. It gave us speed, flexibility, and a small build size, perfect for a physics-driven multiplayer board game.

The Takeaway

What started as a fun experiment at a game jam grew into a complete mobile multiplayer Carrom experience. We learned that:

Choosing the right engine is as important as gameplay mechanics.
Sometimes “less” is more, Defold’s simplicity was its biggest strength.
Iteration and community support are key in game development.

-written by Saakshi Baheti and Sanket Lamsal.

carrom