Our snake glides around the arena, but it has nothing to do and no way to lose. In this final building part we add the three things that turn a moving line into a real game: food to chase, growth as a reward, and rules that end the run when you crash. After this, you will have a complete Snake that you can lose, swear at, and immediately play again. Scattering the Food Food should appear at a random empty spot inside the walls. GBDK-2020 provides a random number generator, which we use to pick a column and a row. If the spot we picked is already occupied, by the snake or by a wall, we simply try again until we find an empty cell, then place the food tile there. #include void place_food(void) { uint8_t fx, fy; do { fx = 1 + (rand() % (GRID_W - 2)); // somewhere inside the walls fy = 1 + (rand() % (GRID_H - 2)); } while (get_bkg_tile_xy(fx, fy) != T_EMPTY); set_bkg_tile_xy(fx, fy, T_FOOD); } This little function drops food somewhere valid. rand() asks GBDK for a random number, and the % (remainder) trims it down into range, so rand() % (GRID_W - 2) lands somewhere between the side walls; adding 1 keeps it off the wall itself. The do ... while wrapper means try this, and if the chosen spot is not empty (because the snake or a wall is already there) try again, repeating until it finds a free cell. Only then does it place the food tile. It is a tidy way of saying keep guessing until you find an empty square. Eating, Growing and Crashing Now we upgrade the move function from Part 4 into a full game step. Before moving, we look at the tile the head is about to enter. If it is a wall or part of the snake, the game is over and we report it. If it is food, the snake grows by keeping its old tail instead of erasing it, and we drop a fresh piece of food. Otherwise it is a normal move and we clear the tail as before. // returns 1 if the snake died this step uint8_t step_game(void) { int8_t i; uint8_t nx = snake_x[0] + dir_x; uint8_t ny = snake_y[0] + dir_y; uint8_t hit = get_bkg_tile_xy(nx, ny); if (hit == T_WALL || hit == T_BODY) return 1; // crashed: game over uint8_t tail_x = snake_x[length - 1]; uint8_t tail_y = snake_y[length - 1]; for (i = length - 1; i > 0; i--) { // body follows the head snake_x[i] = snake_x[i - 1]; snake_y[i] = snake_y[i - 1]; } snake_x[0] = nx; snake_y[0] = ny; set_bkg_tile_xy(nx, ny, T_BODY); if (hit == T_FOOD) { // ate food: grow if (length < MAX_LEN) { snake_x[length] = tail_x; snake_y[length] = tail_y; length++; } place_food(); } else { // normal move: clear tail set_bkg_tile_xy(tail_x, tail_y, T_EMPTY); } return 0; } step_game is the Part 4 move function with the rules added, so read it in three beats. First it works out the square the head is about to enter and looks at what is already there, storing that in hit. If hit is a wall or the snake's own body, it returns 1, our agreed signal for game over. If the snake survived, the middle section shuffles the body forward and draws the new head, exactly as before. Then the decision: if hit was food, the snake grows by keeping its old tail segment instead of erasing it, adds one to length, and drops a new piece of food; otherwise it was an ordinary move, so we rub out the tail as usual. Returning 0 at the end means the snake is still alive. That single returned number, 1 or 0, is how the game loop will know whether to carry on. Starting and Restarting We want each game to begin fresh, so we gather the setup into one function that clears the arena, places a new three-segment snake and drops the first food. This is the Part 4 setup with a clean-up sweep and a piece of food added. void init_game(void) { uint8_t x, y, i; for (y = 1; y < GRID_H - 1; y++) // clear the arena for (x = 1; x < GRID_W - 1; x++) set_bkg_tile_xy(x, y, T_EMPTY); length = 3; for (i = 0; i < length; i++) { snake_x[i] = 10 - i; snake_y[i] = 9; set_bkg_tile_xy(snake_x[i], snake_y[i], T_BODY); } dir_x = 1; dir_y = 0; place_food(); } init_game simply resets everything for a fresh run. The two stacked for loops together sweep across every cell inside the walls (one loop for the rows, one nested inside it for the columns) and set each to empty, wiping the old game away. Then, exactly as in Part 4, it lays down a new three-segment snake pointing right, and finally drops the first piece of food with place_food. One small but important detail: a random generator needs a seed, or it produces the same food pattern every time. A neat trick is to wait for the player to press START, count rapidly while the button is held, and use that count as the seed. Because no two people hold the button for exactly the same time, the food lands differently every game. void main(void) { uint8_t timer; uint16_t seed = 0; set_bkg_data(0, 4, tiles); SHOW_BKG; DISPLAY_ON; waitpad(J_START); // wait for the player while (joypad() & J_START) seed++; // count while held initrand(seed); // seed the randomness while (1) { // one game per outer loop draw_walls(); init_game(); timer = 0; while (1) { // the game loop wait_vbl_done(); read_input(); if (++timer >= 6) { timer = 0; if (step_game()) break; // died: leave the loop } } waitpad(J_START); // game over: press START waitpadup(); // wait for release, then restart } } The main function now runs whole games back to back. The first lines load the tiles and switch the screen on. Then comes the seeding trick: waitpad(J_START) freezes until START is pressed, while (joypad() & J_START) seed++ counts rapidly for as long as it is held, and initrand(seed) uses that count so the food falls differently each time. After that, the outer while (1) plays one game per lap: it draws the walls, sets up a fresh board, and runs the inner game loop. That inner loop moves the snake every sixth frame and watches step_game; the moment step_game reports a crash, break jumps out of it. We then wait for START and its release before looping back to start another game. Two loops, one nested inside the other: the inner one is a single game, the outer one lets you play again and again. Finishing the Snake Game Put all the pieces together, the tiles and defines from Part 3, the data and input from Part 4, and the food, growth and game-over logic from this part, and you have a complete Snake game in roughly 150 lines of C. Build it, hold START to begin, and play. The snake eats, grows longer with every bite, and the run ends the moment you clip a wall or your own tail. Press START again and you are straight into a fresh game. Take a moment to appreciate what you have done. You designed graphics, talked to real Game Boy hardware, handled input and wrote game logic, and the result is a genuine cartridge-ready game you made yourself. That is the same craft, in miniature, that built the library this whole collection celebrates. Let's play - the final snake game for your Game Boy Building Your snake.gb File Throughout this series you have built each step the same way you built your very first ROM back in Part 1: with the lcc tool that ships with GBDK-2020. To turn the finished game into a playable file, save the complete program as snake.c, open a terminal in that folder, and run a single command. Adjust the path so that it points at the lcc program inside your GBDK bin folder. lcc -o snake.gb snake.c That produces snake.gb, a real Game Boy ROM. Open it in an emulator such as Emulicious, BGB or SameBoy to play right away, or copy it onto a flash cartridge to run it on a genuine DMG-01. We look at that last step, playing on real hardware, in more detail in Part 6. Download the Game Files Want to skip ahead, or check your work against a finished version? Grab the complete project here: the full snake.c source code, ready to build, together with the compiled snake.gb ROM so you can play it straight away. Coming Up in Part 6 So far we have played in an emulator. In the final part we take the leap that makes it all real: running your game on an actual Game Boy, plus where to go next if you have caught the bug, from friendlier tools to deeper ones and the welcoming community behind them. The Full Series Part 1: Setting Up Your Workshop · Part 2: How the Game Boy Thinks · Part 3: Drawing Your World · Part 4: Taking Control · Part 5: Food, Growth and Game Over (you are here) · Part 6: From Emulator to Cartridge Part of the Write Your Own Game Boy Games series.

Our game now runs through three lives and then simply stops, leaving the last crash frozen on screen. That is a flat way to finish. In this part we give the game a real ending: a GAME OVER screen that announces the result, shows the final score, and invites the player to press START for another go. It reuses everything we have already built, so it is short and satisfying. The Game-Over Screen Just like the title screen in Part 2, the game-over screen is nothing more than text placed on a cleared display, using the font from Part 1 and the number-drawing helper from Part 3: void game_over_screen(void) { clear_screen(); draw_text(7, 4, "GAME"); draw_text(7, 6, "OVER"); draw_text(6, 9, "SCORE"); draw_num3(12, 9, score); // the final score draw_text(4, 13, "PRESS START"); } There is nothing new to learn here, which is rather the point. clear_screen() blanks the display. The two draw_text lines stack the words GAME and OVER in the middle, on rows 4 and 6. The next pair writes the label SCORE and then, with draw_num3, the player's final score right beside it, so they can see how they did. The last line writes PRESS START near the bottom. Every tool in this function is one we built in an earlier part, now paying us back. Game Over - Well, there is always a new try Wiring It Into the Game Now we just call it at the right moment. In Part 4 the lives loop kept running while lives remained; the instant it ends, all lives are gone, so that is exactly where the game-over screen belongs: // ... the while (lives > 0) loop has just ended ... game_over_screen(); waitpad(J_START); // wait for the player to press START waitpadup(); // then loop back to the title screen In plain words: as soon as the lives run out and that loop finishes, game_over_screen() paints the ending. waitpad(J_START) then holds everything there until the player presses START, so the result stays on screen for as long as they like. waitpadup() waits for them to release the button, and because this whole block sits inside the game's main outer loop, releasing START quietly carries us right back to the title screen from Part 2, ready for a fresh game. The player can now lose, see their score, and jump straight back in, which is the loop every arcade game is built on. Coming Up in Part 6 The game is now complete from start to finish. In the final part we add the two touches that make it a pleasure to play: sound, so eating and dying actually make a noise, and a pause function so you can stop mid-game. Then we hand you the whole finished project to download. The console this game runs on is documented, with photographs, in the collection. The Level Up Series Part 1: Drawing Graphics the Game Boy Way · Part 2: A Title Screen for Your Snake · Part 3: Keeping Score · Part 4: Three Lives · Part 5: A Proper Game Over (you are here) · Part 6: Sound and Pause Part of the Write Your Own Game Boy Games series.

In an earlier series we built a complete Snake game for the Game Boy in C and ran it on a real DMG-01. That game works, but it is bare: no title, no score, no lives, and a rather abrupt end. This new series levels it up, adding a title screen, a score, lives, a proper game-over screen, sound and a pause function, one feature per part. Before any of that, though, we need something the first game deliberately went without: graphics and text of our own. So we begin exactly where the Game Boy's own artists began, by drawing. The final homebrew snake game in action By the end of this part you will understand how graphics were made for the Game Boy, and you will have designed two things we use for the rest of the series: a small font, and a start-screen picture. No prior coding experience is needed; we will read every line together in plain English. How the Artists Drew for the Game Boy In 1989 there were no drag-and-drop art tools of the kind we know today. A Game Boy artist often began much like someone doing cross-stitch: on squared paper, one small 8 by 8 tile at a time, filling each of its 64 squares with one of just four shades. A logo, a character or a letter was then assembled from these little tiles like a mosaic, and finally turned into the numbers the console understood. Trivia, since people always ask: did programmers really work out every pixel as a number by hand? In the very early days, and for lone hobbyists, yes, that graph-paper-to-hex conversion was a genuine rite of passage. Professional studios did not stay in that world for long, though. They worked on development computers with graphical tile editors, painting each 8 by 8 tile with a cursor while the tool wrote out the numbers automatically. Today nobody types hex by hand at all: you draw your tiles in a pixel-art program such as Aseprite, or a dedicated tool like Game Boy Tile Designer, or design whole games visually in GB Studio, and a converter (for example GBDK's png2asset) turns your picture straight into the data the console needs. We are doing it the old, manual way in this series purely because it makes the machine impossible to misunderstand. Four Shades, Two Bits, Sixteen Bytes Because every pixel is one of four shades, it can be described by two bits (a bit is just a single yes-or-no value in the computer's memory). Each row of eight pixels therefore needs two bytes, one for each bit, and a full tile of eight rows takes sixteen bytes. That is why, back in the beginner series, our tiles were always sixteen numbers long. Here is the food tile again, a diamond: // the food tile: a diamond, 16 bytes (two per row) 0x00,0x00, 0x18,0x18, 0x3C,0x3C, 0x7E,0x7E, 0x7E,0x7E, 0x3C,0x3C, 0x18,0x18, 0x00,0x00 If those numbers look intimidating, here is the trick to reading them. The tile is eight rows tall, and each row is described by a pair of numbers, so there are eight pairs. A line beginning with two slashes is just a comment, a note for humans that the console ignores. A value like 0x00 means an empty row with nothing lit; the 0x in front simply marks it as a hexadecimal number. In the very next section we will work out, step by step, exactly where such a number comes from. Designing a Font To show a score, or the word SNAKE, we need letters and numbers, and on the Game Boy a letter is simply another tile. We design a compact five-by-seven pixel letterform inside each eight-by-eight tile, leaving a little breathing space around it so the words do not run together. Draw the twenty-six capitals and the ten digits once, store them as tiles, and you can write anything on screen. This is our little museum font, the alphabet and numbers we will use for every screen from here on. Designing a font for the Game Boy Designing One Letter, Pixel by Pixel To see exactly how a tile is born, let us build one letter from scratch: a capital A. First we sketch it on the eight-by-eight grid, colouring in the squares that should be dark and leaving the rest light. Straight away the familiar shape appears, a narrow peak, two uprights and a bar across the middle, with an empty row at the very bottom so the letters below have room to breathe. Designing Letter A Pixel By Pixel Reading the grid one row at a time, we turn each row into a single number. Here is that same A, row by row: // the letter A, one row at a time 0x38, // ### the peak 0x44, // # # the uprights begin 0x44, // # # 0x7C, // ##### the bar across the middle 0x44, // # # 0x44, // # # 0x44, // # # the two legs 0x00 // a blank row for spacing Read the little comment beside each number and you can find the letter hiding in the digits: 0x38 is the narrow peak, each 0x44 is a row with only its two edges lit, 0x7C is the bar across the centre, and 0x00 is the empty row at the foot. But where do those particular numbers come from? That is the part worth slowing down for. How Each Row's Number Is Worked Out Here is the simple rule behind every one of those numbers. Think of the eight squares in a row as eight switches. Each square has a fixed value that depends only on its position, starting from the left: 128, 64, 32, 16, 8, 4, 2, 1, each one exactly half of the one before it. To turn a row into its number, you add up the values of only the squares that are switched on (the dark ones), and then write that total in hexadecimal. Numbers and Pixels Take the upright row of our A, the one written 0x44, which has just its two edge squares lit. Looking at their positions, those two squares are worth 64 and 4. Add them together: 64 + 4 = 68. The last step is to write 68 in hexadecimal, the base-sixteen counting that programmers use. Hexadecimal counts in sixteens, so 68 is four sixteens (that is 64) plus four more, which is written as 44, giving us 0x44. That is the whole calculation: pick the lit squares, add their position values, convert the total to hex. The other rows work the very same way. The peak of the A lights the three middle squares, worth 32, 16 and 8; add them, 32 + 16 + 8 = 56, and 56 in hexadecimal is 0x38 (three sixteens is 48, plus eight, written 38). A completely empty row lights nothing, so it adds up to 0, written 0x00. And the bar across the middle lights five squares, 64 + 32 + 16 + 8 + 4 = 124, which is 0x7C. Work down all eight rows like this and you have built the letter by hand, one number at a time. A tile editor simply does this addition for you, but now you know exactly what it is doing under the hood. One last detail we skipped earlier: in the real font file each of these values is written twice in a row, because the Game Boy stores two copies for its four possible shades. Our font uses only the darkest shade, so the two copies are identical, which is why the finished tiles read 0x38,0x38, 0x44,0x44 and so on. Once the letters exist as tiles, writing a word is just placing the right tiles side by side. This little helper does exactly that: // each character is just a tile; write a word by placing tiles void draw_text(uint8_t col, uint8_t row, const char *s) { while (*s) set_bkg_tile_xy(col++, row, tile_for(*s++)); } Even if you have never written a line of code, you can follow what this does. The word void just means this is a reusable instruction, which we have named draw_text, that we can call whenever we want to write something. It is handed three things inside the brackets: a column and a row where the text should start, and the text itself (called s). The line while (*s) means keep repeating the next step as long as there are still characters left in the text. That step, set_bkg_tile_xy(col++, row, tile_for(*s++)), quietly does three small jobs at once: tile_for finds which tile matches the current character, set_bkg_tile_xy places that tile at the current column and row, and the two ++ marks then nudge us one column to the right and one character further along the text. Round and round it goes until the text runs out, and the word has appeared on screen, letter by letter. The full font, all twenty-six letters and ten digits already turned into tiles, lives in the downloadable project at the end of the series, so you never have to type it out by hand. Drawing the Start Screen With tiles and a font in hand, a title screen is simply careful arrangement. We place the word SNAKE near the top, coil a little snake underneath from the same body tile the game uses, drop a single piece of food beside it, and write PRESS START lower down. Notice that we are no longer thinking about individual pixels at all; we are arranging ready-made tiles on the twenty-by-eighteen grid, which is exactly how Nintendo's own title screens were built. The result already looks like a real game waiting to be played. Adding some flavour to our snake like game - a simple start screen Coming Up in Part 2 A picture on its own is not a title screen yet. In Part 2 we make it interactive: the game will show this start screen the moment it boots, sit patiently on it, and wait for the player to press START before the snake ever appears. That single change is what turns a program into something that feels like a cartridge. New to all this? Start with the beginner series, Build Your Own Game Boy Game, which builds the Snake we are about to improve. And to see the machine we are drawing for, browse the collection. The Level Up Series Part 1: Drawing Graphics the Game Boy Way (you are here) · Part 2: A Title Screen for Your Snake · Part 3: Keeping Score · Part 4: Three Lives · Part 5: A Proper Game Over · Part 6: Sound and Pause Part of the Write Your Own Game Boy Games series.

We have an arena with walls, but it is completely still. In this part we give it a star: a snake that the player can steer around the board. To get there we need three things. We need a way to remember where the snake is, a way to read the buttons, and a loop that ties it all together and runs the game. Let us take them one at a time. Say hello to the snake Remembering the Snake A snake is really just a chain of body segments, each sitting in one grid cell. The neat way to store that is two lists: one holding the column of every segment, and one holding the row. We also remember how long the snake currently is, and which direction it is travelling. Position zero in the lists is always the head. #define MAX_LEN 128 // the longest the snake can ever get uint8_t snake_x[MAX_LEN]; // column of each segment uint8_t snake_y[MAX_LEN]; // row of each segment uint8_t length; // how many segments right now int8_t dir_x, dir_y; // current direction (-1, 0 or 1) These few lines are just labelled boxes to remember things in. The define line fixes MAX_LEN, the longest the snake can ever grow, at 128. snake_x and snake_y are two lists (programmers call them arrays), each with room for 128 numbers; together they store the column and row of every body segment, with position 0 always being the head. length holds how many segments exist right now, and dir_x and dir_y hold the current direction as a pair of small numbers, each being minus one, zero or plus one. For example, dir_x of 1 with dir_y of 0 means moving right. Now we set the snake up at the start of a game. We place a short, three-segment snake in the middle of the board and point it to the right. void init_snake(void) { uint8_t i; length = 3; for (i = 0; i < length; i++) { snake_x[i] = 10 - i; // head at 10, body trailing left snake_y[i] = 9; set_bkg_tile_xy(snake_x[i], snake_y[i], T_BODY); } dir_x = 1; // moving right dir_y = 0; } init_snake lays down the starting snake. length = 3 says three segments to begin with. The for loop then runs i from 0 to 2 and, for each segment, sets its column to 10 - i (so the head sits at column 10 and the body trails off to the left), sets its row to 9, and draws a body tile there. Finally dir_x = 1 and dir_y = 0 point it to the right. A short snake, ready to go. Reading the Game Boy Controls GBDK-2020 gives us a joypad function that tells us which buttons are currently held. We check the four direction buttons and update the snake's direction. There is one classic rule in Snake: you cannot instantly turn back on yourself, so we only allow an up or down turn when the snake is moving horizontally, and a left or right turn when it is moving vertically. void read_input(void) { uint8_t keys = joypad(); if ((keys & J_UP) && dir_y == 0) { dir_x = 0; dir_y = -1; } else if ((keys & J_DOWN) && dir_y == 0) { dir_x = 0; dir_y = 1; } else if ((keys & J_LEFT) && dir_x == 0) { dir_x = -1; dir_y = 0; } else if ((keys & J_RIGHT) && dir_x == 0) { dir_x = 1; dir_y = 0; } } The one new symbol here is the & in keys & J_UP. joypad() hands back all the buttons squashed into a single number, and & is how we ask whether one particular button is pressed, so (keys & J_UP) means the up button is down. The extra check && dir_y == 0 enforces the classic Snake rule: you may only turn up or down while moving sideways, which stops the snake instantly doubling back on itself. The else if chain means only the first matching direction is taken each time. Making the Snake Move Moving the snake is the clever bit, and it is simpler than it looks. We work out where the new head will be, then shuffle every segment one place along the chain so the body follows the head. We draw a body tile at the new head, and clear the tile where the tail used to be. Because we only ever change two tiles per step, the head and the old tail, the game stays fast even when the snake grows long. void move_snake(void) { int8_t i; uint8_t nx = snake_x[0] + dir_x; // new head column uint8_t ny = snake_y[0] + dir_y; // new head row uint8_t tail_x = snake_x[length - 1]; uint8_t tail_y = snake_y[length - 1]; for (i = length - 1; i > 0; i--) { // body follows the head snake_x[i] = snake_x[i - 1]; snake_y[i] = snake_y[i - 1]; } snake_x[0] = nx; snake_y[0] = ny; set_bkg_tile_xy(nx, ny, T_BODY); // draw new head set_bkg_tile_xy(tail_x, tail_y, T_EMPTY); // erase old tail } This is the heart of the movement, so let us take it slowly. First we work out the new head position, nx and ny, by adding the direction to the old head (position 0). We also make a note of where the tail currently is. Then comes the clever part: the for loop runs backwards, from the last segment to the second, and copies each segment into the position of the one in front of it, so the whole body shuffles forward by one and follows the head. We then place the new head into position 0, draw a body tile there, and rub out the tile where the tail used to be. Because only two tiles ever change, the head and the old tail, the game stays fast no matter how long the snake grows. The Game Loop Every game has a heartbeat: a loop that repeats forever, reading input and updating the screen. On the Game Boy we pace that loop with wait_vbl_done, which pauses until the console has finished drawing the current frame. That happens about 60 times a second, which would make our snake far too fast, so we use a small counter and only move the snake every sixth frame. That gives a comfortable, classic Snake speed while still reading the buttons smoothly. void main(void) { uint8_t timer = 0; set_bkg_data(0, 4, tiles); SHOW_BKG; DISPLAY_ON; draw_walls(); init_snake(); while (1) { wait_vbl_done(); // wait one frame (~1/60 s) read_input(); // check the buttons every frame if (++timer >= 6) { // but only move every 6th frame timer = 0; move_snake(); } } } The main function is the whole game in miniature. It loads the tiles, shows the background, turns on the screen, draws the walls and places the snake, exactly the pieces from Part 3. Then while (1) starts a loop that runs forever. Each time round, wait_vbl_done pauses until the console has finished drawing one frame (about a sixtieth of a second), and read_input checks the buttons. The line if (++timer >= 6) counts those frames and only lets the snake move on every sixth one; without it the snake would lurch sixty times a second, far too fast to play. So the buttons stay responsive while the snake glides at a comfortable pace. Build the ROM and you will have a snake gliding around the arena, turning crisply as you press the direction pad. It does not eat, grow or die yet, but it is unmistakably a game now, and it responds to your hands. Coming Up in Part 5 In Part 5 we turn this into a real, winnable and losable game. We will scatter food for the snake to eat, make it grow with every bite, and add the rules that end the game when it hits a wall or its own tail. By the end you will have a complete, playable Snake. The Full Series Part 1: Setting Up Your Workshop · Part 2: How the Game Boy Thinks · Part 3: Drawing Your World · Part 4: Taking Control (you are here) · Part 5: Food, Growth and Game Over · Part 6: From Emulator to Cartridge Part of the Write Your Own Game Boy Games series.

Pick up games for your coffee break The Game Boy is often remembered for its epics, but its truest talent was always the opposite. More than any machine before it, it was built for the in-between moments: the bus ride, the queue, the five minutes before dinner is ready. Pick Up N'Play: Games for your coffee break Slide in the right cartridge and you can start playing in seconds, stop the instant you need to, and walk away without losing a thing. This series celebrates that quiet superpower. Pick Up and Play is about the games made for a spare minute, the ones with no save to protect and no ending to chase, where a single round is always enough and one more is always tempting. Every game here is drawn from the collection, and every one passes the same simple test: you can put it down at any moment and feel finished. Here is the whole set. Part 1: Tetris The game with no finish line, and the one that perfected the whole idea. Easy to learn, impossible to end, almost impossible to put down. Read Part 1: Tetris Part 2: Dr. Mario Nintendo's other puzzle pillar, where Mario swaps his overalls for a lab coat. Clear a bottle of viruses in a couple of minutes and stop with a clear conscience. Read Part 2: Dr. Mario Part 3: Mario & Yoshi A moreish little stack-and-match score-chaser with a secret pedigree: it was made by Game Freak, the studio that would soon create Pokemon. Read Part 3: Mario & Yoshi Part 4: Alleyway Bat, ball, bricks: the oldest arcade idea in the book, shipped at launch in 1989, with Mario's spaceship hiding in plain sight as the paddle. Read Part 4: Alleyway Part 5: Mario's Picross The gentle one: bite-size logic puzzles that reveal a hidden picture, one calm deduction at a time. A cult classic the West nearly missed. Read Part 5: Mario's Picross Part 6: Qix Pure abstract tension: claim a blank board, dodge a restless line, chase a bigger score. No story, no ending, just one more risky sweep. Read Part 6: Qix Part 7: Game & Watch Gallery Nintendo's own handheld ancestor, brought back to the Game Boy: tiny Game & Watch classics in faithful Classic and Mario-flavoured Modern forms, plus a gallery of the originals. Read Part 7: Game & Watch Gallery Part 8: Game & Watch Gallery 2 More of the same tiny classics, and a collector's twist: on the original Game Boy this sequel stayed a Japan exclusive, so the grey-cartridge release is an import. Read Part 8: Game & Watch Gallery 2 These eight are only the start. The collection is full of quick matches and score-chasers built for a spare minute, from the early sports games to the racing bundles. To browse them all, and see these cartridges up close, come and explore the Game Boy Museum. The Full Series Part 1: Tetris · Part 2: Dr. Mario · Part 3: Mario & Yoshi · Part 4: Alleyway · Part 5: Mario's Picross · Part 6: Qix · Part 7: Game & Watch Gallery · Part 8: Game & Watch Gallery 2

This series has been about the games you can play in a spare minute, so it would be strange not to visit the machine that started the whole idea. Long before the Game Boy, Nintendo made its name on tiny single-game handhelds you kept in a pocket and played at a bus stop. Part seven of Pick Up and Play is the cartridge that brings those little classics back to the Game Boy itself, a neat piece of history folding in on itself. The Game Boy's own ancestor, back on a cartridge. The original pick-up-and-play machine Game & Watch was Nintendo's line of pocket LCD handhelds, launched in 1980, each one built around a single simple game and, as the name promised, a clock. They were the work of Gunpei Yokoi, the same engineer who would later design the Game Boy, which makes this cartridge a quiet family reunion. Game & Watch also gave the world something every player now takes for granted: the cross-shaped directional pad, first used on the multi-screen Donkey Kong model before it became standard on every controller since. In other words, the Game Boy owes its designer, its philosophy of cheap portable fun, and even the shape of its d-pad to the games gathered on this cart. The Game & Watch line ran through the 1980s and into the early 1990s, spanning dozens of models and tens of millions of units, each a slim slab of plastic with a segmented LCD screen that could only light up pre-drawn shapes. From that limitation came real ingenuity: games like Ball, where you juggle to a rising rhythm, or the multi-screen folding units that packed two displays into a clamshell case. They were cheap, near indestructible and instantly understood, and for a whole generation they were the first video game you could carry in a coat pocket. That thrift was a philosophy, not an accident. Yokoi built his career on what he called lateral thinking with seasoned technology: taking cheap, well-understood parts and using them in clever new ways rather than chasing the cutting edge. It is the same instinct that later made the Game Boy a monochrome, battery-sipping machine in an age of colour rivals, and the same instinct that let it comfortably outsell them. Game & Watch is where that thinking was first proven, one pocket handheld at a time. Two ways to play, one museum on a cartridge The Game & Watch Gallery from 1997 does more than reprint the old games. Each included title can be played two ways: a Classic version that faithfully recreates the original monochrome handheld, and a Modern version that redraws the same game with Mario characters and a little more colour and personality. You get to feel the stark, elegant simplicity of the 1980s original and then see it reimagined, side by side. Better still, the cartridge hides an unlockable gallery of the original Game & Watch animations, so as you play you are also assembling a small museum of Nintendo's earliest handheld history. For a project like ours, a game that is itself a little museum is impossible not to love. There is even a gentle hook to keep you coming back. Scoring well in the Modern versions earns you stars, and those stars gradually unlock the Classic modes and the gallery of preserved originals, so idle high-score chasing quietly turns into curating a little exhibition. It is a clever way to make you appreciate the history rather than just skim it: you earn the museum by playing the games, one good run at a time. As pick-up-and-play goes, this is the platonic ideal. Every game inside is a bite-size test of timing and reflex with a running score and no ending to reach, exactly the format Game & Watch perfected forty years ago. You switch it on, catch a few falling parachutists or flip a few pancakes, chase a better score, and switch it off none the worse for stopping. It is the whole philosophy of this series in a single cartridge. For our purposes it is almost too perfect. Every game here was designed, four decades ago, around the exact idea this series celebrates, that a good game can last thirty seconds and still be worth switching on for. Playing them on the Game Boy, the machine their own creator went on to build, closes a loop that most compilations never even notice is there. This is the US edition; its Japan-exclusive follow-up, Game & Watch Gallery 2, is next in the series and also lives in the collection. To see this cartridge and the rest, come and explore the Game Boy Museum. The Full Series Part 1: Tetris · Part 2: Dr. Mario · Part 3: Mario & Yoshi · Part 4: Alleyway · Part 5: Mario's Picross · Part 6: Qix · Part 7: Game & Watch Gallery (you are here) · Part 8: Game & Watch Gallery 2

Switch on a Game Boy and before a single game appears you hear it: that two-note “ba-ding” as the Nintendo logo drops down the screen. That little chime is the console clearing its throat, and it is produced by the same tiny sound hardware that will later carry every melody, laser and footstep you hear. The Game Boy's audio is astonishingly simple, just four thin voices and a speaker the size of a coin, yet those four voices became one of the most recognisable sounds of the late twentieth century. This part of the series opens up the machine's sound: the four channels it can play, how they reach your ears, and the little wheel that still controls the volume today. A small round mono speaker hides within every Game Boy Four voices, and no more The Game Boy's sound is built from exactly four channels, each a separate little voice with a fixed job. They cannot be swapped or expanded; every piece of Game Boy music ever written is an arrangement for these same four performers. Understanding them is the key to understanding why Game Boy music sounds the way it does. Channel 1, a pulse wave with sweep. The first voice produces a square-edged “pulse” tone, the classic buzzy video-game sound. It has a built-in frequency sweep, meaning it can slide its pitch up or down automatically, perfect for the rising “power-up” and falling “fall down a hole” effects you remember. It usually carries the lead melody. Channel 2, a second pulse wave. The same kind of square-wave voice, but without the automatic pitch slide. With two pulse channels a composer could write a tune and a harmony at once, which is why so much Game Boy music sounds like two whistling lines weaving around each other. Channel 3, the programmable wave. The third voice is the clever one. Instead of a fixed shape it plays back a short custom waveform that the game loads into it, a tiny hand-drawn snippet of sound, 32 steps long. This let developers coax out rounder, more flute- or bass-like tones than a plain square wave, and it often handled the bassline. Channel 4, noise. The last voice makes no musical note at all. It produces pseudo-random noise, a controllable hiss, and that single channel is responsible for nearly every drum, explosion, crash and splash in the Game Boy's library. Tuned one way it is a snare; tuned another, a rumble or a wave breaking. Two pulses, one custom wave and one noise channel: that is the entire orchestra. The art of Game Boy music lies in how composers juggled them, stealing the lead channel for a sound effect for a split second, then handing it straight back to the melody. This same hardware is what musicians still perform on today, a story told in full in The Game Boy as an instrument. The speaker, and the voice you actually hear All four channels are mixed together and sent to the small round speaker behind the grille on the lower-right of the console's face. It is a tiny, cheap dynamic speaker, and on its own it reproduces only a thin, mid-heavy version of the sound; there is almost no bass to be had from a cone that small in a plastic box. Through this speaker everything comes out in mono: the four channels are simply summed into one signal. A small round mono speaker that carries all four sound channels when no headphones are plugged in is hiding behind the shell grille. What many owners never discovered is that the Game Boy actually produces stereo sound; you just cannot hear it from the built-in speaker. Each of the four channels can be placed in the left ear, the right ear or both, and games used this to pan effects across the stereo field. That stereo mix only comes alive through the headphone socket. The headphone jack and the volume wheel On the bottom edge of the console sits a standard 3.5 mm headphone socket. Plug anything in and two things happen: the internal speaker is switched off, and you finally hear the full stereo mix the hardware was producing all along. For a lot of people the Game Boy sounded like a completely different, far richer machine the first time they put on a pair of headphones. On the right-hand edge, opposite the contrast wheel, sits a second thumb-wheel marked volume. Unlike many of the console's controls this one is purely analogue: it is a small rotary potentiometer that physically turns the output level up and down, feeding both the speaker and the headphones. There is no digital volume here, just a dial bleeding more or less signal through, which is why, on a well-used Game Boy, that wheel can grow crackly with age and why a careful clean often brings the sound back. A small sound with a long reach It is worth pausing on how little hardware all of this is. There is no dedicated sound chip bolted on beside the processor; the four channels live inside the main Sharp processor itself, as described in Part 2. The whole audio system is a handful of circuits on the same sliver of silicon that runs the games. And yet from those few circuits came theme tunes that millions of people can still hum, proof that character in sound has far more to do with clever writing than with raw power. The four-channel voice was so distinctive that it escaped the console entirely, inspiring records, chart hits and a worldwide live-music scene. If the sound of the Game Boy is what draws you in, the wider story of where that sound travelled is told across The Sound of the Game Boy. Specifications at a glance Property Specification Sound channels 4 Channel 1 Pulse / square wave with frequency sweep Channel 2 Pulse / square wave Channel 3 Programmable wave (32 x 4-bit samples) Channel 4 Noise generator Speaker output Mono Headphone output Stereo Headphone jack 3.5 mm, bottom edge Volume control Analogue wheel (right edge) Sound hardware Integrated in the Sharp LR35902 The Series Overview · Part 1: The Shell, Buttons and Controls · Part 2: The Main Board and the Sharp Processor · Part 3: The Screen · Part 4: Sound (you are here) · Part 5: Power · Part 6: Connectivity and the Link Port

Virtual Worlds Museum Teleportal, mapping the metaverse Switch off a Game Boy and nothing is lost. The game sits in the cartridge, patient and complete, waiting for the next set of batteries, whether that is tomorrow or in fifty years. Switch off a virtual world and it can be gone for good: the servers wiped, the login dead, the place where thousands of people met simply erased, with nothing left in a drawer to rediscover. That single, unsettling difference is the whole reason the Virtual Worlds Museum exists, and it is why a museum devoted to a 1989 handheld feels such kinship with it. A Museum for Places That Might Vanish The Virtual Worlds Museum is a digital museum archiving the history of virtual worlds and the wider metaverse. Founded and directed by Julian Reyes, it has already been recognised with the 2025 AUREA Impact Award and a place among the M100 Spectrum Metaverse Innovators, and it was built with the help of a successfully funded Kickstarter. Its motto is refreshingly plain for a field drowning in jargon: explore, preserve, inspire. The scope is enormous. The museum tracks the platforms that defined online life for whole generations, from Active Worlds and Habbo and Second Life to VRChat, Roblox, Minecraft, Fortnite and Meta's Horizon Worlds. It sorts them into exhibits, from WebXR and open-source worlds to blockchain experiments. And, most poignantly, it keeps an exhibit for "Sunset Worlds": the places that have already been switched off for the last time. That is preservation at its most urgent, because once one of these worlds closes, there is often nothing left to collect. Mapping the Metaverse The centrepiece is the Teleportal, an interactive map and gateway to the worlds the museum tracks. Think of it as an atlas of the metaverse, turning preservation into something you can wander through rather than just read about. It exists in five versions, which tells you how seriously the team takes access: a 3D force graph that renders the platforms as a drifting constellation, a clickable index organised in category rings, a simplified 2D viewer built for classrooms, a VR build in testing on Meta Quest, and a spatial edition being adapted with WebSpatial for Apple Vision Pro and Pico. You do not need a headset for the browser versions, which is how most of us will explore it. Where our own collection is a map of one machine, the Teleportal is a map of an entire, shifting continent of them. Two Ends of the Same Mission It would be hard to imagine two museums more different on the surface. One preserves a small grey object you can hold, photographing every cartridge and box; the other preserves vast, intangible spaces that exist only while a company keeps the power on. And yet the mission is identical: make sure the history is still there when someone goes looking for it. If anything, our jobs are mirror images. We fight decay, the yellowing plastic and the leaking battery, and we have written before about how to keep an original Game Boy alive. The Virtual Worlds Museum fights disappearance, the far more sudden death of a world that is perfectly healthy right up until the moment it is deleted. Between us, the tangible and the intangible sides of play both get a record. A Museum That Maps Other Museums There is a lovely detail that brought our two worlds together in the first place. Alongside everything else, the Virtual Worlds Museum keeps a directory of game museums, physical and virtual alike, a museum that maps other museums, so that anyone curious about where gaming history is being kept can actually find it. That is how the Game Boy Museum came to be listed among them, and it is exactly the kind of connective work the scene needs. If you spend your days, as we do, thinking about how to keep gaming history from slipping away, the Virtual Worlds Museum is well worth your time. You can explore the Teleportal and the whole archive at virtualworlds.museum, and the museum's interviews with the people who build these worlds live on its Teleportal TV channel. That series is a team effort, and Julian Reyes is quick to say so. Teleportal TV and the museum's Spotlight video series exist thanks to Evo Heyning, Carlos Austin, Steve Van Loon and Rachael Newport. Different technology, same stubborn belief: that the places and machines we played on are worth keeping, long after the world has moved on to the next thing. This is one of the places gathered in our guide to the video game museums worth visiting.

Not every pick-up-and-play game needed a new idea. Some just took the oldest one in the arcade and made it fit in a pocket. Part four of Pick Up and Play is Nintendo's take on the game that has been quietly hypnotising players since the 1970s: bounce a ball off a bat and knock down a wall of bricks. Bat, ball, bricks. The simplest fun on the whole system. One bat, one ball, no thinking required The appeal of Alleyway is that there is nothing to understand. You slide a paddle along the bottom of the screen, keep the ball in play, and chip away at the bricks above until they are gone. It is reflex, not strategy, which makes it the ideal thing to reach for when you have a single minute and no desire to think. There is no plot, no map and no save to worry about; you are simply trying to keep one ball alive a little longer than last time. That is a session you can start and end anywhere. The one flicker of skill is in the angle. Hit the ball with the centre of the paddle and it comes straight back; catch it with the edge and you can send it slicing sideways to pick off an awkward corner, or punch a single gap and let it rattle around behind the wall clearing bricks on its own. Learning to steer like that is the difference between clearing a screen in one confident sweep and chasing a stray ball around for a nervous minute. It is a tiny bit of craft hiding inside a game that looks like it has none. The game belongs to a lineage that stretches back to Breakout, the 1976 Atari classic whose prototype, as the legend goes, was hammered together by a young Steve Wozniak with Steve Jobs looking on. Taito's Arkanoid revived the formula in 1986 with power-ups and a proper spaceship paddle, and dozens of imitators followed. Alleyway is Nintendo's entry in that long tradition, and the reason the format has outlived a dozen console generations is exactly the reason it suits this series: the core loop is so clean it never needs updating. On the small green screen it feels right at home, quick and twitchy and endlessly repeatable. A launch title with a hidden Mario Alleyway is one of the original Game Boy launch titles from 1989, part of the small handful of games that first shipped with the console, and one of Nintendo's earliest attempts to give a plain brick-breaker an identity of its own. The way it did that is delightful once you notice it. The paddle is not a generic bar but a tiny spaceship belonging to Mario, and the bonus stages arrange their bricks into shapes drawn from the Mario universe, so a stripped-down arcade game quietly becomes a Nintendo one. Those touches go further than the paddle. Clear certain screens and you drop into a bonus round where the bricks are laid out as characters and objects from the Mario world, giving you a few seconds to rack up extra points before the real game resumes. It is a small thing, but it is the whole difference between playing a generic brick-breaker and playing a Nintendo one, and it is the sort of detail that tells you the company was already thinking hard about how to stamp its personality onto even the simplest idea. It arrived in very select company. When the Game Boy went on sale in Japan in 1989 its first cartridges numbered only a handful, and Alleyway was among them, sitting alongside the likes of Super Mario Land and Baseball as the games that introduced the world to the machine. To be one of the titles chosen to launch a console, even a modest brick-breaker, is a kind of honour, and it means Alleyway was in a great many of the very first Game Boy boxes ever opened. As a launch game it also captures something about the Game Boy's first moments: the stripped-down, experimental spirit of a machine still working out what it was for. Sometimes the answer was an epic. Sometimes it was just a bat, a ball and five spare minutes, and that turned out to be more than enough. That is why it earns its place here. Alleyway is not the deepest game on the shelf and never tried to be. It is the pure, portable distillation of an idea that was already old when the Game Boy was new, and it still does exactly what a spare minute asks of it: one ball, one wall, and nothing to leave unfinished. To see this cartridge and the rest of the collection, come and explore the Game Boy Museum. The Full Series Part 1: Tetris · Part 2: Dr. Mario · Part 3: Mario & Yoshi · Part 4: Alleyway (you are here) · Part 5: Mario's Picross · Part 6: Qix · Part 7: Game & Watch Gallery · Part 8: Game & Watch Gallery 2

The Game Boy is remembered for falling blocks, a plucky plumber and, a little later, a world full of pocket monsters. But from its very first summer it was quietly a sports machine too. Some of the earliest cartridges Nintendo made for the handheld were not adventures at all but games of tennis, baseball and golf, plain monochrome sports you could pull out of a pocket and play in a few minutes. And in every one of them, if you looked closely, a very familiar face was hiding. This is a tour of the sports games in the collection, and the cameos tucked inside them. Nintendo's first handheld sports team Three cartridges sit at the heart of this story, and all three are from the machine's opening years. Tennis and Baseball both date to 1989, right at the North American launch, and Golf followed in 1990. They are not showpieces of graphics or story; their charm is historical. This was Nintendo proving that its new handheld could be more than a home for puzzles and platformers, that it could carry the same everyday sports that had done so well on the living-room consoles, now shrunk down to fit in a coat pocket. There was another idea baked into them from the start: playing against a friend. Tennis in particular was an early showcase for the Game Boy's link cable, letting two players wire their consoles together for a proper match. That social, head-to-head streak runs through the whole sports line and, as we will see, eventually grew into something you could play four at a time. Spot the plumber Here is the fun part, the reason these plain-looking cartridges are more interesting than they first appear. Nintendo had a habit in these years of slipping Mario into its sports games as a friendly, familiar face, and all three games here are in on the joke, each in a different way. In Tennis, look at the official presiding over your match: the chair umpire, calling the score from his raised seat at the side of the court, is Mario himself. It is a tiny detail, easy to miss, and completely charming once you notice that the most famous character in video games has been reduced to keeping score of your rallies. In Golf the cameo goes further: the lone golfer you control, the little figure lining up each shot, is Mario, a direct descendant of the golf game Nintendo first built around him on the Famicom back in 1984. The Western box even puts him front and centre, so here the plumber is not hiding at all; he is the star athlete. Baseball completes the set, and it hides the best cameo of all. The Western box art shows Mario in mid-pitch, ball in hand, and the nod carries into the game itself: in the US mode one team, the Bears, fields Mario on the mound, while the rival Eagles answer with Luigi as one of their pitchers. So across these three early sports games Mario plays every position Nintendo could give him, referee in one, star athlete in another, and pitcher in the third, with his brother called up for the away side. It is worth noting that these appearances are a feature of the Western releases; they were Nintendo's way of putting a recognisable, welcoming face on otherwise plain sports games for players outside Japan. All of it happened years before Mario would ever headline sports games under his own name; on the Game Boy he simply turns up as a guest, a wink to anyone who recognised the man in red. Four players, one adapter The competitive streak in these games reached its peak when Nintendo built accessories to let more than two people play at once, and the collection holds the sporting side of that story in three boxes. The rare Top Ranking Tennis bundle packed the tennis game together with the Four Player Adapter, promising a fierce competition for one, two, three or four players right on the box. Racing counts as a sport too, and the same adapter turns up again with the motorsport titles: the sealed F1 Race bundle paired the adapter with F1 Race, the very game the adapter was first sold alongside. Grandest of all is the American Racing Set, a whole clamshell that gathered F1 Race and Super R.C. Pro-Am together with the Four Player Adapter and a Hip Pouch carrying case. Between them these three boxes turn the Game Boy's quiet sports catalogue into something loud and communal: not a solitary round of golf, but four friends hunched over four grey bricks, racing and rallying against each other through a single cable. It is the same competitive idea that Tennis introduced in 1989, simply multiplied. The sports games are among the humblest cartridges the Game Boy ever produced, and among the most quietly historic: launch-era software, early proof of link-cable play, and a hiding place for one of gaming's most famous characters before he ever went pro. To see them, and the bundles that made them a four-player affair, come and explore the Game Boy Museum.

A whole Zelda adventure on the little green screen. Of all the games that proved the Game Boy was more than a toy, few make the case as completely as The Legend of Zelda: Link's Awakening. A full, sprawling adventure, with dungeons and secrets and a world to lose yourself in, somehow poured onto the little green screen. What makes it remarkable is not just that it exists, but how it came to be: not as a grand plan, but as an experiment a few Nintendo staff tinkered with after work, which grew quietly into one of the strangest and most beloved games the company ever made. An after-hours experiment Link's Awakening started life as an unofficial side project. Some of the team began, in their own time, trying to squeeze the Super Nintendo classic A Link to the Past onto the far weaker Game Boy, almost to see whether it could be done at all. That experiment took on a life of its own, and instead of a straight port it became an original game under the direction of Takashi Tezuka, with the story and script shaped by Yoshiaki Koizumi and Kensuke Tanabe. After about a year and a half of work it was released in Japan in June 1993 and around the world later that year. That informal origin matters, because it shows in every corner of the finished game. This was the first Legend of Zelda made for a handheld, and the first built from the ground up rather than for a television, and its loose, playful development gave it a freedom the mainline console games never quite had. Nobody, it seems, was watching too closely, and the result is gloriously off-model. A Zelda without Zelda The setup is a sharp break from tradition. Link is shipwrecked and washes up not in Hyrule but on Koholint Island, a small, dreamlike place watched over by a slumbering, whale-like deity called the Wind Fish. To leave, he must find eight musical instruments scattered across the island and use them to wake the sleeping giant. There is no Triforce quest in the usual sense, and, unusually for the series, neither Princess Zelda nor Ganon actually appears. It is one of the very few Zelda games where the two names on the marquee are both absent, though the final foe does briefly borrow Ganon's shape among a parade of nightmares. No Zelda, no Ganon, a few Goombas, and an ending that stays with you. The crossover nobody approved Here is where that after-hours freedom really shows. Koholint Island is quietly full of characters who have wandered in from entirely different Nintendo games, cameos that were essentially unofficial. Explore for a while and you will trample Goombas straight out of Super Mario Bros., dodge Piranha Plants, meet a chained-up creature called Bow-Wow that is unmistakably a Chain Chomp, and run into Boos, Piranha Plants and even Wart, a boss borrowed from Super Mario Bros. 2. A treasured Yoshi Doll sits at the heart of one of the island's trading quests, a picture of Princess Peach turns up along the way, and the friendly farmer Tarin looks suspiciously like Mario with a moustache. Nintendo's other great mascot gets a nod too, in enemies modelled on Kirby. The dreamy island of Koholint In any other Zelda this crowd of gatecrashers would feel like a mistake. On Koholint it feels exactly right, because the whole island has the logic of a dream, where half-remembered faces from other stories drift in without explanation. The unrestrained development did not just tolerate that strangeness, it made it the point. The dream you have to end It is worth pausing here, because this next part gives away the ending of a thirty-year-old game. What lifts Link's Awakening above a charming curiosity is its story, which is quietly devastating. As you play, it dawns on you that Koholint Island is not real at all. It is the dream of the sleeping Wind Fish, and every villager you have helped, every friend you have made, exists only for as long as the great beast sleeps. To escape, Link must wake it, and waking it means the island and everyone on it will simply cease to be. The game asks you to finish something knowing that completing it will erase the very world you fell in love with. For a handheld often dismissed as a machine for quick fun, that is an astonishingly bittersweet note to end on, and it is the reason players still talk about the game decades later. In this collection Link's Awakening was a system-seller, and this collection holds it in a fitting form: the rare, German-only Super Star Set, a console bundle that paired the Game Boy with two of its biggest titles at once: The Legend of Zelda: Link's Awakening and Super Mario Land 2. Nintendo built plenty of bundles around its heavy-hitting first-party games, but because this one was limited to a single market, complete examples are genuinely scarce today, which makes it one of the more special ways to own a piece of Koholint. The Game Boy Super Start Set - Mario and Zelda joining forces The little adventure that started after hours went on to become a classic, later recoloured for the Game Boy Color and rebuilt entirely for a modern console, but the original monochrome version is where the dream began. To see this bundle and the rest of the collection, come and explore the Game Boy Museum.

Every so often a game comes along that its maker adores, promotes relentlessly, and simply cannot convince people to buy. Mario Picross is one of those games. Nintendo believed in it, put Mario's face on the box, and pushed it across the West in 1995. Players politely declined. Three decades on, it is quietly regarded as one of the finest puzzle games on the Game Boy, which makes its commercial flop one of the handheld's great injustices. Mario the archaeologist, chiselling pictures out of numbers. Numbers that hide a picture Picross is short for picture crossword, and the puzzle is also known as a nonogram. You are given a blank grid with numbers running along the top and down the side. Those numbers tell you how many cells in each row and column are filled, and in what runs. Chip away the right squares and a picture slowly emerges: a fish, a boot, a little umbrella. Guess wrong and you are penalised with lost time. It is logic, not luck, and once it clicks it is fiercely moreish. GBuddy's GB Treasure Hunt Nintendo dressed this austere logic puzzle in the friendliest costume it had. Mario appears as a kind of archaeologist, chiselling and hammering the picture out of the grid, cheering when you solve one and wincing when you make a mistake. The Game Boy's tiny screen was actually well suited to the format, since a monochrome grid needs no colour to be read. All you need is the discipline to trust the numbers. A hard sell in the West The Japanese edition of Mario Picross landed in 1995, and the PAL release followed for Europe. Nintendo genuinely got behind it, giving it prominent coverage in its own magazines and marketing. The problem was not quality, it was familiarity. In Japan, nonogram puzzles were already a known pastime in newspapers and magazines. In Britain, Germany or the United States, most shoppers had no idea what a picross even was, and a puzzle you cannot explain in one line of box copy is a puzzle that stays on the shelf. The best Game Boy game a lot of people never heard of. So it undersold. Not disastrously, but enough to make Nintendo cautious about the West's appetite for the genre. That single commercial decision would shape everything that followed for the series outside Japan. The sequels that stayed home Because the first game had struggled abroad, its successors never left Japan. Mario Picross 2 arrived on the Game Boy for Japanese players only, expanding the formula with larger, tougher puzzles and even handing some duties to Wario. Western fans who had fallen for the first game had no official way to buy the follow-up, and importing a Japanese cartridge was the only route. For a puzzle that needs no translation to play, that was a particular shame. The sequels stayed in Japan. Now you know why importers exist. Vindicated in the end The story has a happy ending. The picross idea refused to die, and Nintendo kept returning to it, eventually building a long-running series on later handhelds that found the audience the Game Boy original never quite reached. Today the genre has fans worldwide, and Sudoku has made grid logic mainstream in exactly the way that might have saved Mario Picross had it arrived a decade later. That is why the cartridge is such a rewarding thing to revisit. It was a great game that showed up a little too early for its own market, and the passage of time has done nothing but prove it right. You can find both the Western and Japanese versions in the Game Boy Museum collection. This article is part of the Great Games, Tiny Screen series.