Panda Pop Game by Jam City: How to Play and Build One

By Arron R.10 min read
The Panda Pop game Jam City publishes is a free-to-play bubble shooter: match three or more same-color bubbles to rescue baby pandas. Bank shots off walls, drop

The Panda Pop game Jam City publishes today is a free-to-play bubble shooter where you fire colored bubbles into a cluster, match three or more of the same color to pop them, and free trapped baby pandas along the way. It has been on phones since 2013, and it still gets regular version updates. This guide covers who made it, how the rules and special bubbles work, how to get past the levels that stop most players, and, for anyone who builds games, how a bubble shooter works under the hood and how to make your own.

The Panda Pop Game Jam City Built: Who Made It and When

Panda Pop came out in 2013 from a company that was then called SGN (Social Gaming Network). According to Jam City’s Wikipedia entry, the studio was founded in 2010 by Chris DeWolfe, Colin Digiaro, Aber Whitcomb and Josh Yguado, went through the names Platform G and MindJolt, became SGN in 2012, and rebranded as Jam City in September 2016. Panda Pop went on to become one of the company’s highest-grossing mobile games, and a year later the studio followed it with the match-3 hit Cookie Jam.

Jam City is based in Culver City, California, and its catalogue mixes original games with licensed ones such as Harry Potter: Hogwarts Mystery. Most of its games, Panda Pop included, follow the free-to-play model: you download and play without paying, and optional purchases sell boosts and items that speed up progress.

One quick clarification, because the name trips people up: Jam City is a company, not a game jam. A game jam is a short event where people build a whole game around a theme in a fixed time. If that is what you were after, our guide to the Brackeys Game Jam explains how those events run.

How to Play Panda Pop: The Core Rules

If you have never played a bubble shooter, the rules fit in one paragraph. A cluster of colored bubbles hangs from the top of the screen. You control a launcher at the bottom. You aim, fire one bubble, and it sticks wherever it touches the cluster. If it joins a group of three or more bubbles of the same color, that whole group pops. Any bubbles left hanging with no connection to the top fall off and count as cleared too.

Panda Pop wraps that formula in a story: Mama Panda is trying to rescue her babies, who are trapped inside bubbles on the board. Popping the bubbles around a baby panda frees it, and freeing the pandas is usually the goal of a level. The store listing describes more than 4,000 levels, organised as a saga map you work through in order.

The basic controls:

  • Aim: drag on the screen and a guide line shows where the bubble will travel.
  • Bounce: bubbles reflect off the side walls, so you can bank a shot around obstacles.
  • Fire: release to shoot. The bubble snaps into the nearest open slot in the grid.
  • Plan ahead: the launcher shows the color coming next, so you can set up combos two shots ahead.
Diagram of the bubble shooter loop: aim, match three, drop floating clusters
Every Panda Pop shot follows the same loop: aim, match three or more, then drop whatever is no longer attached.

Special Bubbles and Obstacles in Panda Pop

Plain colored bubbles only carry the early levels. Later boards add obstacles that change how shots behave, and learning them is most of the skill curve. Panda Pop’s help center lists several, including Bumper Bubbles, Fill Bubbles and Cloud Bubbles.

Bumper Bubbles

Bumper Bubbles do not stick. When your shot hits one, it bounces off in a new direction, like a pinball hitting a bumper. The help center’s advice is to aim at them on purpose to redirect a shot. That turns them from a nuisance into a tool: a bumper next to a hidden pocket of bubbles is often the only way to reach it.

Why obstacles matter for design

Obstacles exist so the same three rules (aim, match, drop) keep producing fresh puzzles across thousands of levels. Each new bubble type changes one assumption the player has learned: a bumper breaks “my shot sticks where it lands,” a blocker breaks “I can always reach that cluster.” If you build your own bubble shooter later, that is the pattern to copy. Add one new rule at a time and build several levels that teach it before mixing it with others. Our level design guide for beginners covers this idea of teaching through layout in more depth.

Panda Pop Strategy: How to Beat Hard Levels

Most players stall at the same points, and it is rarely about raw aim. These habits make the biggest difference:

  1. Shoot the anchors, not the nearest match. The best shot is often a small match near the top that cuts off a big cluster below it. Everything disconnected falls at once, and falling bubbles are free progress.
  2. Use the walls. A bank shot can reach a gap you cannot hit directly. Line up the guide so the bubble arrives at a shallow angle, which makes it slide into tight spots instead of clipping a neighbor.
  3. Read two shots ahead. Check the next bubble before you fire. If the current color has no good target, park it somewhere harmless that sets up the next shot.
  4. Clear a path to the pandas first. On rescue levels, the pandas are the win condition. A beautiful combo on the far side of the board does nothing if the babies are still trapped.
  5. Save boosts for open boards. A power-up spent on a crowded spot clears a few bubbles. The same power-up aimed at the anchor of a large cluster can drop half the board.
  6. Do not litter the bottom. Every bubble that sticks without matching pushes the cluster closer to you and blocks future angles. A wasted shot near the top costs much less than one near the bottom.

When a level still will not break, replay it once just to study the layout. Bubble shooter boards are fixed puzzles at the start, so knowing where the anchors and bumpers sit pays off on the next attempt.

How a Bubble Shooter Works Under the Hood

Here is the part for builders. Strip away the pandas and the obstacles and a bubble shooter is one of the friendliest genres to code: no physics engine, no pathfinding, just a grid and two searches. It touches most of the core disciplines of video game development (programming, design, art and audio) in a small enough package to finish in a weekend.

The four systems

  • A hex grid with offset rows. Bubbles pack in a honeycomb. Every other row shifts half a bubble to the right, so each cell has six neighbors instead of four.
  • Aiming and wall bounce. The shot moves in a straight line. When it reaches a side wall, flip its horizontal velocity.
  • Snapping. When the shot touches a bubble or the ceiling, it stops and locks into the nearest empty cell.
  • Two flood fills. A flood fill is a search that spreads from one cell to every connected cell that passes a test. The first fill finds same-color neighbors of the bubble you just placed; if there are three or more, pop them. The second starts from every bubble in the top row and marks everything still connected. Anything unmarked is floating and drops.

A complete minimal version in JavaScript

This runs in any browser. Make an HTML page with a single canvas element whose id is game, load this script after it, and you have a playable bubble shooter: move the mouse to aim, click to fire. If you want to understand the rendering loop in more detail, our guide to building an HTML5 canvas game engine covers it step by step.

const canvas = document.getElementById("game");
const ctx = canvas.getContext("2d");
const R = 16, COLS = 12, ROWS = 16;
const ROW_H = Math.sqrt(3) * R;
const COLORS = ["#e74c3c", "#3498db", "#2ecc71", "#f1c40f"];
canvas.width = COLS * R * 2 + R;
canvas.height = 600;
const SHOOTER = { x: canvas.width / 2, y: canvas.height - 30 };

const randColor = () => COLORS[Math.floor(Math.random() * COLORS.length)];
const grid = [];
for (let r = 0; r < ROWS; r++) {
  grid.push([]);
  for (let c = 0; c < COLS; c++) grid[r].push(r < 6 ? randColor() : null);
}

function pos(r, c) {
  return { x: c * R * 2 + R + (r % 2 ? R : 0), y: r * ROW_H + R };
}

function neighbors(r, c) {
  const d = r % 2
    ? [[-1, 0], [-1, 1], [0, -1], [0, 1], [1, 0], [1, 1]]
    : [[-1, -1], [-1, 0], [0, -1], [0, 1], [1, -1], [1, 0]];
  return d.map(([dr, dc]) => [r + dr, c + dc])
    .filter(([nr, nc]) => nr >= 0 && nr < ROWS && nc >= 0 && nc < COLS);
}

function flood(startR, startC, test) {
  const seen = new Set([startR + "," + startC]);
  const stack = [[startR, startC]];
  const out = [];
  while (stack.length) {
    const [r, c] = stack.pop();
    out.push([r, c]);
    for (const [nr, nc] of neighbors(r, c)) {
      const key = nr + "," + nc;
      if (!seen.has(key) && test(nr, nc)) { seen.add(key); stack.push([nr, nc]); }
    }
  }
  return out;
}

function dropFloating() {
  const anchored = new Set();
  for (let c = 0; c < COLS; c++) {
    if (grid[0][c] && !anchored.has("0," + c)) {
      flood(0, c, (r, cc) => grid[r][cc] !== null)
        .forEach(([r, cc]) => anchored.add(r + "," + cc));
    }
  }
  for (let r = 0; r < ROWS; r++)
    for (let c = 0; c < COLS; c++)
      if (grid[r][c] && !anchored.has(r + "," + c)) grid[r][c] = null;
}

function snap(shot) {
  let best = null, bestD = Infinity;
  for (let r = 0; r < ROWS; r++)
    for (let c = 0; c < COLS; c++) {
      if (grid[r][c]) continue;
      const p = pos(r, c);
      const d = (p.x - shot.x) ** 2 + (p.y - shot.y) ** 2;
      if (d < bestD) { bestD = d; best = [r, c]; }
    }
  if (!best) return;
  const [r, c] = best;
  grid[r][c] = shot.color;
  const group = flood(r, c, (nr, nc) => grid[nr][nc] === shot.color);
  if (group.length >= 3) {
    group.forEach(([gr, gc]) => (grid[gr][gc] = null));
    dropFloating();
  }
}

let shot = null, nextColor = randColor(), aim = -Math.PI / 2;

canvas.addEventListener("mousemove", (e) => {
  const b = canvas.getBoundingClientRect();
  const a = Math.atan2(e.clientY - b.top - SHOOTER.y, e.clientX - b.left - SHOOTER.x);
  aim = Math.max(-Math.PI + 0.15, Math.min(-0.15, a));
});

canvas.addEventListener("click", () => {
  if (shot) return;
  shot = { x: SHOOTER.x, y: SHOOTER.y,
           vx: Math.cos(aim) * 9, vy: Math.sin(aim) * 9, color: nextColor };
  nextColor = randColor();
});

function update() {
  if (!shot) return;
  shot.x += shot.vx;
  shot.y += shot.vy;
  if (shot.x < R || shot.x > canvas.width - R) {
    shot.vx *= -1;
    shot.x = Math.max(R, Math.min(canvas.width - R, shot.x));
  }
  let hit = shot.y <= R;
  for (let r = 0; r < ROWS && !hit; r++)
    for (let c = 0; c < COLS; c++) {
      if (!grid[r][c]) continue;
      const p = pos(r, c);
      if ((p.x - shot.x) ** 2 + (p.y - shot.y) ** 2 < (R * 1.8) ** 2) { hit = true; break; }
    }
  if (hit) { snap(shot); shot = null; }
}

function circle(x, y, color) {
  ctx.beginPath();
  ctx.arc(x, y, R - 1, 0, Math.PI * 2);
  ctx.fillStyle = color;
  ctx.fill();
}

function draw() {
  ctx.fillStyle = "#1b1f3a";
  ctx.fillRect(0, 0, canvas.width, canvas.height);
  for (let r = 0; r < ROWS; r++)
    for (let c = 0; c < COLS; c++)
      if (grid[r][c]) { const p = pos(r, c); circle(p.x, p.y, grid[r][c]); }
  ctx.strokeStyle = "#ffffff";
  ctx.beginPath();
  ctx.moveTo(SHOOTER.x, SHOOTER.y);
  ctx.lineTo(SHOOTER.x + Math.cos(aim) * 60, SHOOTER.y + Math.sin(aim) * 60);
  ctx.stroke();
  circle(SHOOTER.x, SHOOTER.y, nextColor);
  if (shot) circle(shot.x, shot.y, shot.color);
}

function loop() { update(); draw(); requestAnimationFrame(loop); }
loop();

The shot moves 9 pixels per frame, less than one bubble radius, so it can never skip through a bubble between frames. The snap step simply picks the empty cell closest to where the shot stopped. That is crude but reliable, because the shot always stops right next to the bubble it touched.

Hexagonal bubble grid showing six neighbors, a flood fill match and floating bubbles
Under the hood: an offset hex grid, six neighbors per cell, one flood fill for matches and one for floating bubbles.

Building a Panda Pop–Style Game With WizardGenie

The code above is a skeleton. Turning it into something that feels like a real bubble shooter means rescue goals, a shot limit, a level map, obstacle bubbles, popping animations, character art and sound. That is a lot of iteration, and it is where WizardGenie fits. WizardGenie is the AI game engine at the heart of Sorceress: you describe the game you want, and it writes the code, runs it and iterates on it with you. This style of building by describing behavior instead of typing every line is often called vibe coding.

WizardGenie runs on the web with nothing to install, and also as a Windows desktop app with an auto-updater that adds native file access and longer agent sessions. It works with the leading AI coding models, and you can switch models with your own API key.

A practical prompt sequence

Do not ask for “a game like Panda Pop” in one message. Build it in layers, testing each one before moving on:

  1. Core loop: “Make a bubble shooter on a hexagonal grid with offset rows. Mouse to aim, click to fire, bubbles bounce off the side walls, three or more of the same color pop, and disconnected bubbles fall.”
  2. Win and lose: “Trap three panda characters inside bubbles. The level is won when all three are freed. Give the player 25 shots; show the count on screen and end the level when it hits zero.”
  3. Feel: “Add a dotted aim guide that shows one wall bounce. Animate popping bubbles shrinking out and floating bubbles falling with gravity.”
  4. Obstacles: “Add a bumper bubble that never sticks and reflects the shot. Build three levels that introduce it gradually.”
  5. Progression: “Add a level select screen with ten levels and save which ones are complete.”

The art and audio

Bubble shooters live or die on charm. For the rescued characters, Auto-Sprite v2 (Pro) creates game-ready 2D sprites of any character in any art style, including the animations a panda needs for an idle bob and a celebration when freed. For backgrounds, AI Image Gen gives you the leading image models in one panel. For the pop, bounce and level-clear sounds, plus a cheerful loop for the level map, Sound Studio covers AI music, sound effects and voice, with a built-in editor for trimming. If you prefer to work in another coding agent, the Sorceress API gives it one key to generate the same kinds of assets.

The Sorceress tools guide maps every tool to the job it does, which is handy once your bubble shooter needs more than a panda and a pop sound.

Common Mistakes When Cloning a Bubble Shooter

Most first bubble shooters fail in the same handful of places:

  • Using a square grid. Bubbles on a square grid leave diagonal gaps and the matching feels wrong. Always use offset rows with six neighbors.
  • Forgetting the floating check. Popping a match without dropping disconnected bubbles leaves clusters hanging in mid-air, and it removes the best part of the genre: the big cascade.
  • Fast shots that tunnel. If a bubble moves farther than its radius per frame, it can pass straight through a target. Keep the speed below the radius or move it in smaller sub-steps.
  • Random colors with no logic. Truly random next bubbles often hand the player a color that no longer exists on the board. Pick the next color from the colors still present.
  • Copying the brand. Pandas trapped in bubbles is Jam City’s identity. Borrow the mechanics, which are a long-standing genre, but give your game its own characters, name and art. That matters even more if you plan to release it as an indie game.
  • Too many obstacle types too early. Introduce one new bubble type per small group of levels, as described above.

If you enjoyed this breakdown, the same approach works for other puzzle hits: our guides to the Block Jam game and the Car Jam game walk through their rules and how to build them.

The Verdict

Panda Pop is Jam City’s long-running bubble shooter: launched in 2013 under the SGN name, free to play, and built on three simple rules (aim, match three, drop what is disconnected) stretched across thousands of levels by obstacles like Bumper Bubbles. To beat it, shoot anchors instead of nearby matches, use the walls, read the next bubble and clear a path to the pandas before chasing combos.

To build one, the full pipeline looks like this:

  1. Start with an offset hex grid, aiming, wall bounce and snapping.
  2. Add the two flood fills: one for matches, one for floating bubbles.
  3. Layer on goals, a shot limit and one obstacle at a time, using WizardGenie to iterate in plain English.
  4. Give it your own characters, art and sound with Sorceress tools.
  5. Export the build and host it wherever you like.

The skeleton above is about a page of code. Everything that makes the game memorable, the characters, the levels, the cascade of falling bubbles, is iteration, and that is exactly where an AI game engine saves you the most time.

Frequently Asked Questions

Who makes Panda Pop?

Panda Pop is made by Jam City, a mobile game developer and publisher based in Culver City, California. The game launched in 2013, when the company was still called SGN (Social Gaming Network). SGN rebranded as Jam City in September 2016, so the studio that launched Panda Pop and the studio that runs it today are the same company under a newer name.

Is Panda Pop free to play?

Yes. Panda Pop is listed as a free bubble shooter on the app stores. Like most Jam City games, it follows a free-to-play model with optional in-app purchases for items and boosts that help you get through hard levels faster. You can play through levels without paying, though tougher stages may take several attempts.

How do you beat hard Panda Pop levels?

Aim for the bubbles that hold big clusters up, not just the nearest match, because anything disconnected from the top falls off the board at once. Use wall bounces to reach gaps you cannot hit directly, look at the next bubble before you fire, and save your power-ups for boards where one shot opens up a large area.

What do Bumper Bubbles do in Panda Pop?

Bumper Bubbles are an obstacle that changes the direction of your shot. Instead of sticking where they land, your bubble bounces off them and travels a new way. Panda Pop’s help center tells players to aim toward them on purpose to redirect shots, which makes them useful for reaching bubbles hidden behind other obstacles.

Is Jam City a game jam?

No. Jam City is a company name, not an event. A game jam is a short event where people build a game in a fixed time, often 48 hours to a couple of weeks, around a theme. Jam City is a commercial developer that publishes titles such as Panda Pop, Cookie Jam and Harry Potter: Hogwarts Mystery.

Can I make my own bubble shooter like Panda Pop?

Yes, and it is a good beginner project. The core is a hexagonal grid, an aiming line, wall bounces, a flood fill that finds three or more matching bubbles, and a second pass that drops floating clusters. You can code it yourself in JavaScript or describe it to WizardGenie and iterate on the result in plain English.

Sources

  1. Jam City (company) — Wikipedia
  2. Video game development — Wikipedia
  3. Vibe coding — Wikipedia
  4. Indie game — Wikipedia
Written by Arron R.·2,459 words·10 min read

Related posts