If you spend a lot of time staring at log files, you might want to consider installing CCZE. CCZE is a tool that color highlights your log files making them much easier to read.
The Raspberry Pi micro-computer grows in power with each new model release, with more resources that make it a more capable, low-cost content server for your media and resources.
Laptops, smartphones, tablets, even lightbulbs—an endless number of devices now have the ability to connect to your local network and the wider internet.
This is the simplest way to see the health of your iPhone’s battery. For a reminder, after 500 cycles, your battery is operating with roughly 80% of its full capacity*.
This is the simplest way to see the health of your iPhone’s battery. For a reminder, after 500 cycles, your battery is operating with roughly 80% of its full capacity*.
This is the simplest way to see the health of your iPhone’s battery. For a reminder, after 500 cycles, your battery is operating with roughly 80% of its full capacity*.
This is the simplest way to see the health of your iPhone’s battery. For a reminder, after 500 cycles, your battery is operating with roughly 80% of its full capacity*.
Ever notice that little HDR feature that appears for certain photographs on your iPhone? It’s called High Dynamic Range. Check out our guide on HDR and when to use it.
Ever notice that little HDR feature that appears for certain photographs on your iPhone? It’s called High Dynamic Range. Check out our guide on HDR and when to use it.
If you’ve got an iPhone with TouchID, and you’re mourning the loss of the ability to unlock your phone without pressing the home button, there is hope.
Whether you bought the 16GB iPhone on a budget or you like to store thousands of pictures and songs on your phone, you will eventually need to learn how to free up some space.
Whether you’ve shattered your screen, broken your home button, or decided to upgrade to a fancy new iOS device, chances are you’ll want your new iPhone to work like your old one.
If you’ve got an iPhone with TouchID, and you’re mourning the loss of the ability to unlock your phone without pressing the home button, there is hope.
Whether you bought the 16GB iPhone on a budget or you like to store thousands of pictures and songs on your phone, you will eventually need to learn how to free up some space.
Whether you’ve shattered your screen, broken your home button, or decided to upgrade to a fancy new iOS device, chances are you’ll want your new iPhone to work like your old one.
As a JavaScript developer, one of the most common things you’ll need to do is react to the user’s events. For example, the user clicks submit on a form and you need to validate it, or the user clicks a button that dynamically adds content to the page. There are many times when the user will interact with your application and you’ll need to respond to their actions. And since DOM elements are always nested within each other, managing the events and targets can be tricky. Enter event bubbling.
We often nest related DOM elements when we write our markup. For instance, we may have an div containing an img, an h2, and a p tags
My item
Item description
Suppose we wanted to allow the user to click anywhere inside of this div. If we were simply navigating the user to a new page, an a tag with a properly set href would be sufficient. But if we want to perform some other action on the current page, we’ll want to use JavaScript to listen for click events to the entire div and all of it’s children.
Fortunately, we don’t have to listen and respond to a click on each DOM element – div, img, h2, and p. We only have to listen to events on the parent! This is due to event bubbling.
When an event occurs on any DOM element on a page, the event is bubbled up through it’s parent elements triggering the event on each. So in our example above, if a user clicks on the p element, the click event will be triggered on the p followed by the parent div following by the parent of the div all the way to the document object.
As described in the previous step, the event is first triggered on the target element and then on it’s parents moving up the chain. We can prove this with a quick example.
Suppose we have the following markup:
We can set a click event listener on each div like this:
Even though it appears that they are logged at the same time, the order is important. The event was triggered first on the inner div, followed by the middle div, followed by the outer div.
In JavaScript, events have a target attribute to identify which DOM element was the target of the event. When we listen for events on a specific DOM element we can provide a callback function that is called when the event is triggered. This callback function takes the event as its first argument. This event object contains the target of the event. Here’s a quick example showing how to access the target.
Note: Even though we are using jQuery, as it stands the event.target attribute will be a vanilla JavaScript DOM object, not a jQuery object.
In the above example, the target would be the actual button that was clicked.
When we get into nested DOM elements this becomes a little bit more interesting. Take our example from the previous step. Suppose we log the target for each div.
The above code simply logs the id of the target and the id of this – this being the element we’re listening to. A click on the #inner element will log this:
inner inner inner middle inner outer
Each line shows target this.
As expected, the target doesn’t change. Even though the event is bubbled up and triggered on parent elements, the target remains the actual element that was clicked on. However, this provides access to the element we’re listening to. As we see, inner inner is first showing that the event on the #inner element was triggered first, and obviously #inner is the target as well.
Sometimes you’ll want to stop an event from bubbling all the way to the top. Maybe you know for sure you’re finished processing the event, or perhaps in some case you don’t want the event to be triggered on the parent.
We can stop bubbling with event.stopPropagation().
Taking the example we’re using throughout this guide, we can test this out:
This is similar to what we saw before except that we’ve added e.stopPropagation() to the callback for the #inner div. Before, a click on the #inner element bubbled up to the parent elements and logged 3 lines, but this time it stops with the target and logs:
As a JavaScript developer, one of the most common things you’ll need to do is react to the user’s events. For example, the user clicks submit on a form and you need to validate it, or the user clicks a button that dynamically adds content to the page. There are many times when the user will interact with your application and you’ll need to respond to their actions. And since DOM elements are always nested within each other, managing the events and targets can be tricky. Enter event bubbling.
We often nest related DOM elements when we write our markup. For instance, we may have an div containing an img, an h2, and a p tags
My item
Item description
Suppose we wanted to allow the user to click anywhere inside of this div. If we were simply navigating the user to a new page, an a tag with a properly set href would be sufficient. But if we want to perform some other action on the current page, we’ll want to use JavaScript to listen for click events to the entire div and all of it’s children.
Fortunately, we don’t have to listen and respond to a click on each DOM element – div, img, h2, and p. We only have to listen to events on the parent! This is due to event bubbling.
When an event occurs on any DOM element on a page, the event is bubbled up through it’s parent elements triggering the event on each. So in our example above, if a user clicks on the p element, the click event will be triggered on the p followed by the parent div following by the parent of the div all the way to the document object.
As described in the previous step, the event is first triggered on the target element and then on it’s parents moving up the chain. We can prove this with a quick example.
Suppose we have the following markup:
We can set a click event listener on each div like this:
Even though it appears that they are logged at the same time, the order is important. The event was triggered first on the inner div, followed by the middle div, followed by the outer div.
In JavaScript, events have a target attribute to identify which DOM element was the target of the event. When we listen for events on a specific DOM element we can provide a callback function that is called when the event is triggered. This callback function takes the event as its first argument. This event object contains the target of the event. Here’s a quick example showing how to access the target.
Note: Even though we are using jQuery, as it stands the event.target attribute will be a vanilla JavaScript DOM object, not a jQuery object.
In the above example, the target would be the actual button that was clicked.
When we get into nested DOM elements this becomes a little bit more interesting. Take our example from the previous step. Suppose we log the target for each div.
The above code simply logs the id of the target and the id of this – this being the element we’re listening to. A click on the #inner element will log this:
inner inner inner middle inner outer
Each line shows target this.
As expected, the target doesn’t change. Even though the event is bubbled up and triggered on parent elements, the target remains the actual element that was clicked on. However, this provides access to the element we’re listening to. As we see, inner inner is first showing that the event on the #inner element was triggered first, and obviously #inner is the target as well.
Sometimes you’ll want to stop an event from bubbling all the way to the top. Maybe you know for sure you’re finished processing the event, or perhaps in some case you don’t want the event to be triggered on the parent.
We can stop bubbling with event.stopPropagation().
Taking the example we’re using throughout this guide, we can test this out:
This is similar to what we saw before except that we’ve added e.stopPropagation() to the callback for the #inner div. Before, a click on the #inner element bubbled up to the parent elements and logged 3 lines, but this time it stops with the target and logs:
As a JavaScript developer, one of the most common things you’ll need to do is react to the user’s events. For example, the user clicks submit on a form and you need to validate it, or the user clicks a button that dynamically adds content to the page. There are many times when the user will interact with your application and you’ll need to respond to their actions. And since DOM elements are always nested within each other, managing the events and targets can be tricky. Enter event bubbling.
We often nest related DOM elements when we write our markup. For instance, we may have an div containing an img, an h2, and a p tags
My item
Item description
Suppose we wanted to allow the user to click anywhere inside of this div. If we were simply navigating the user to a new page, an a tag with a properly set href would be sufficient. But if we want to perform some other action on the current page, we’ll want to use JavaScript to listen for click events to the entire div and all of it’s children.
Fortunately, we don’t have to listen and respond to a click on each DOM element – div, img, h2, and p. We only have to listen to events on the parent! This is due to event bubbling.
When an event occurs on any DOM element on a page, the event is bubbled up through it’s parent elements triggering the event on each. So in our example above, if a user clicks on the p element, the click event will be triggered on the p followed by the parent div following by the parent of the div all the way to the document object.
As described in the previous step, the event is first triggered on the target element and then on it’s parents moving up the chain. We can prove this with a quick example.
Suppose we have the following markup:
We can set a click event listener on each div like this:
Even though it appears that they are logged at the same time, the order is important. The event was triggered first on the inner div, followed by the middle div, followed by the outer div.
In JavaScript, events have a target attribute to identify which DOM element was the target of the event. When we listen for events on a specific DOM element we can provide a callback function that is called when the event is triggered. This callback function takes the event as its first argument. This event object contains the target of the event. Here’s a quick example showing how to access the target.
Note: Even though we are using jQuery, as it stands the event.target attribute will be a vanilla JavaScript DOM object, not a jQuery object.
In the above example, the target would be the actual button that was clicked.
When we get into nested DOM elements this becomes a little bit more interesting. Take our example from the previous step. Suppose we log the target for each div.
The above code simply logs the id of the target and the id of this – this being the element we’re listening to. A click on the #inner element will log this:
inner inner inner middle inner outer
Each line shows target this.
As expected, the target doesn’t change. Even though the event is bubbled up and triggered on parent elements, the target remains the actual element that was clicked on. However, this provides access to the element we’re listening to. As we see, inner inner is first showing that the event on the #inner element was triggered first, and obviously #inner is the target as well.
Sometimes you’ll want to stop an event from bubbling all the way to the top. Maybe you know for sure you’re finished processing the event, or perhaps in some case you don’t want the event to be triggered on the parent.
We can stop bubbling with event.stopPropagation().
Taking the example we’re using throughout this guide, we can test this out:
This is similar to what we saw before except that we’ve added e.stopPropagation() to the callback for the #inner div. Before, a click on the #inner element bubbled up to the parent elements and logged 3 lines, but this time it stops with the target and logs:
As a JavaScript developer, one of the most common things you’ll need to do is react to the user’s events. For example, the user clicks submit on a form and you need to validate it, or the user clicks a button that dynamically adds content to the page. There are many times when the user will interact with your application and you’ll need to respond to their actions. And since DOM elements are always nested within each other, managing the events and targets can be tricky. Enter event bubbling.
We often nest related DOM elements when we write our markup. For instance, we may have an div containing an img, an h2, and a p tags
My item
Item description
Suppose we wanted to allow the user to click anywhere inside of this div. If we were simply navigating the user to a new page, an a tag with a properly set href would be sufficient. But if we want to perform some other action on the current page, we’ll want to use JavaScript to listen for click events to the entire div and all of it’s children.
Fortunately, we don’t have to listen and respond to a click on each DOM element – div, img, h2, and p. We only have to listen to events on the parent! This is due to event bubbling.
When an event occurs on any DOM element on a page, the event is bubbled up through it’s parent elements triggering the event on each. So in our example above, if a user clicks on the p element, the click event will be triggered on the p followed by the parent div following by the parent of the div all the way to the document object.
As described in the previous step, the event is first triggered on the target element and then on it’s parents moving up the chain. We can prove this with a quick example.
Suppose we have the following markup:
We can set a click event listener on each div like this:
Even though it appears that they are logged at the same time, the order is important. The event was triggered first on the inner div, followed by the middle div, followed by the outer div.
In JavaScript, events have a target attribute to identify which DOM element was the target of the event. When we listen for events on a specific DOM element we can provide a callback function that is called when the event is triggered. This callback function takes the event as its first argument. This event object contains the target of the event. Here’s a quick example showing how to access the target.
Note: Even though we are using jQuery, as it stands the event.target attribute will be a vanilla JavaScript DOM object, not a jQuery object.
In the above example, the target would be the actual button that was clicked.
When we get into nested DOM elements this becomes a little bit more interesting. Take our example from the previous step. Suppose we log the target for each div.
The above code simply logs the id of the target and the id of this – this being the element we’re listening to. A click on the #inner element will log this:
inner inner inner middle inner outer
Each line shows target this.
As expected, the target doesn’t change. Even though the event is bubbled up and triggered on parent elements, the target remains the actual element that was clicked on. However, this provides access to the element we’re listening to. As we see, inner inner is first showing that the event on the #inner element was triggered first, and obviously #inner is the target as well.
Sometimes you’ll want to stop an event from bubbling all the way to the top. Maybe you know for sure you’re finished processing the event, or perhaps in some case you don’t want the event to be triggered on the parent.
We can stop bubbling with event.stopPropagation().
Taking the example we’re using throughout this guide, we can test this out:
This is similar to what we saw before except that we’ve added e.stopPropagation() to the callback for the #inner div. Before, a click on the #inner element bubbled up to the parent elements and logged 3 lines, but this time it stops with the target and logs:
We often nest related DOM elements when we write our markup. For instance, we may have an div containing an img, an h2, and a p tags
My item
Item description
Suppose we wanted to allow the user to click anywhere inside of this div. If we were simply navigating the user to a new page, an a tag with a properly set href would be sufficient. But if we want to perform some other action on the current page, we’ll want to use JavaScript to listen for click events to the entire div and all of it’s children.
Fortunately, we don’t have to listen and respond to a click on each DOM element – div, img, h2, and p. We only have to listen to events on the parent! This is due to event bubbling.
When an event occurs on any DOM element on a page, the event is bubbled up through it’s parent elements triggering the event on each. So in our example above, if a user clicks on the p element, the click event will be triggered on the p followed by the parent div following by the parent of the div all the way to the document object.
We often nest related DOM elements when we write our markup. For instance, we may have an div containing an img, an h2, and a p tags
My item
Item description
Suppose we wanted to allow the user to click anywhere inside of this div. If we were simply navigating the user to a new page, an a tag with a properly set href would be sufficient. But if we want to perform some other action on the current page, we’ll want to use JavaScript to listen for click events to the entire div and all of it’s children.
Fortunately, we don’t have to listen and respond to a click on each DOM element – div, img, h2, and p. We only have to listen to events on the parent! This is due to event bubbling.
When an event occurs on any DOM element on a page, the event is bubbled up through it’s parent elements triggering the event on each. So in our example above, if a user clicks on the p element, the click event will be triggered on the p followed by the parent div following by the parent of the div all the way to the document object.
As described in the previous step, the event is first triggered on the target element and then on it’s parents moving up the chain. We can prove this with a quick example.
Suppose we have the following markup:
We can set a click event listener on each div like this:
Even though it appears that they are logged at the same time, the order is important. The event was triggered first on the inner div, followed by the middle div, followed by the outer div.
As described in the previous step, the event is first triggered on the target element and then on it’s parents moving up the chain. We can prove this with a quick example.
Suppose we have the following markup:
We can set a click event listener on each div like this:
Even though it appears that they are logged at the same time, the order is important. The event was triggered first on the inner div, followed by the middle div, followed by the outer div.
In JavaScript, events have a target attribute to identify which DOM element was the target of the event. When we listen for events on a specific DOM element we can provide a callback function that is called when the event is triggered. This callback function takes the event as its first argument. This event object contains the target of the event. Here’s a quick example showing how to access the target.
Note: Even though we are using jQuery, as it stands the event.target attribute will be a vanilla JavaScript DOM object, not a jQuery object.
In the above example, the target would be the actual button that was clicked.
When we get into nested DOM elements this becomes a little bit more interesting. Take our example from the previous step. Suppose we log the target for each div.
The above code simply logs the id of the target and the id of this – this being the element we’re listening to. A click on the #inner element will log this:
inner inner inner middle inner outer
Each line shows target this.
As expected, the target doesn’t change. Even though the event is bubbled up and triggered on parent elements, the target remains the actual element that was clicked on. However, this provides access to the element we’re listening to. As we see, inner inner is first showing that the event on the #inner element was triggered first, and obviously #inner is the target as well.
In JavaScript, events have a target attribute to identify which DOM element was the target of the event. When we listen for events on a specific DOM element we can provide a callback function that is called when the event is triggered. This callback function takes the event as its first argument. This event object contains the target of the event. Here’s a quick example showing how to access the target.
Note: Even though we are using jQuery, as it stands the event.target attribute will be a vanilla JavaScript DOM object, not a jQuery object.
In the above example, the target would be the actual button that was clicked.
When we get into nested DOM elements this becomes a little bit more interesting. Take our example from the previous step. Suppose we log the target for each div.
The above code simply logs the id of the target and the id of this – this being the element we’re listening to. A click on the #inner element will log this:
inner inner inner middle inner outer
Each line shows target this.
As expected, the target doesn’t change. Even though the event is bubbled up and triggered on parent elements, the target remains the actual element that was clicked on. However, this provides access to the element we’re listening to. As we see, inner inner is first showing that the event on the #inner element was triggered first, and obviously #inner is the target as well.
Sometimes you’ll want to stop an event from bubbling all the way to the top. Maybe you know for sure you’re finished processing the event, or perhaps in some case you don’t want the event to be triggered on the parent.
We can stop bubbling with event.stopPropagation().
Taking the example we’re using throughout this guide, we can test this out:
This is similar to what we saw before except that we’ve added e.stopPropagation() to the callback for the #inner div. Before, a click on the #inner element bubbled up to the parent elements and logged 3 lines, but this time it stops with the target and logs:
Sometimes you’ll want to stop an event from bubbling all the way to the top. Maybe you know for sure you’re finished processing the event, or perhaps in some case you don’t want the event to be triggered on the parent.
We can stop bubbling with event.stopPropagation().
Taking the example we’re using throughout this guide, we can test this out:
This is similar to what we saw before except that we’ve added e.stopPropagation() to the callback for the #inner div. Before, a click on the #inner element bubbled up to the parent elements and logged 3 lines, but this time it stops with the target and logs:
As a JavaScript developer, you’ll often need to construct URLs and query string parameters. One sensible way to construct query string parameters is to use a one layer object with key value pairs.
Writing tests is an important part of software development process. Unit tests form a core part of testing process where each functional block is tested as an independent unit.
As a JavaScript developer, you’ll often need to construct URLs and query string parameters. One sensible way to construct query string parameters is to use a one layer object with key value pairs.
Writing tests is an important part of software development process. Unit tests form a core part of testing process where each functional block is tested as an independent unit.
If you’re familiar with Python’s keyword-only arguments, then you’ve probably wondered why the same constraint doesn’t exist for positional arguments. This changes with Python 3.
While this requirement may seem rare, learning how to nest defaultdicts properly in Python can be extremely powerful and save you from bloated and confusing initialization code.
Python is howchoo’s favorite programming language. We believe python promotes the most organized and performant codebase possible. We also love Django so, naturally, we love Python.
Game Boys are awesome! But they’ve been around for so long, it’s no surprise to find they have a thriving mod community.
Have you always wanted a purple Gameboy? Maybe you’re tired of sitting under a lamp just to play Tetris. Whatever the case, there’s nothing holding you back from creating the ultimate Game Boy experience you’ve dreamt of since 1989.
This guide lists the most common Game Boy mods available today. I’m ready if you’re ready—now let’s get started.
What You’ll Need
InterestsSeries
Here’s everything you’ll need to complete this guide:
Game Boys can be upgraded with an amazing variety of custom shells. In 2018, you don’t have to look hard to find third party vendors selling Game Boy shells. Most of them are aftermarket shells, created with the modern modding community in mind.
However, it is possible to locate original hardware. Auction websites and used gaming stores sell old devices and individual Game Boy components. This is great for restoration projects or those who just prefer original hardware. If you want to learn more about customizing your shell, visit our Game Boy shell replacement guide.
Another common mod you’ll find in the community is custom buttons. Upgrade your Game Boy with brand new controls! They work just like the old ones, but you can choose a different color if you like.
Third party vendors sell many custom color buttons to match the wide array of replacement shells. Replacing the buttons is just as easy as replacing the shell with half the work! Just open up the Game Boy, remove the front motherboard, and swap out the buttons. While you have that Game Boy open, it’s a great time to fix any button sticking issues—visit our guide to learn how to fix sticky Game Boy buttons.
Finding an old Game Boy is awesome. Wasting time to find a lamp to sit under is not. That’s why we have the Game Boy backlight mod! After almost 30 years, you can finally install a working light to play your original Game Boy in the dark.
This mod is a little bit involved and could potentially ruin the original screen. You may want to avoid using any sentimental hardware. But if you think you’re ready, so do we. Head over to our Game Boy backlight mod guide to get started!
A small side effect of installing the backlight is speaker whine — I’ve written a guide to help you fix that.
Backlighting an original Game Boy screen has a direct impact on pixel contrast. Rotating the polarizing film can cause the pixels to invert—some modders do this intentionally. For an ideal display, the pixels need to be inverted twice.
The modding community tackles this issue by means of bivert chip mods. The installation of these chips inverts the signal information for dark and light pixels. This small difference improves the contrast and visibility on the screen. As a side effect from this mod, the contrast wheel now works backwards.
Customizing the bezel on a Game Boy can add an incredible touch to your modding project. The original screen bezels were made of plastic. But you can find a wide variety online, including high quality bezels made of glass.
The original Game Boy was released with a gray bezel. But you’ll find a rainbow of options online—including custom printed graphics. Your only limit is your imagination when it comes to custom bezel replacement.
Game Boy screens are more than necessary, they’re iconic. But there comes a time in every modders like when you realize that maybe it would be pretty cool to install that 3″ aftermarket screen. Just for funsies, right?
Or maybe you’ve bricked your original Game Boy screen in a failed attempt to install a backlight. Repurpose old components and create your very own “frankenboy”. Add a custom after market screen and throw it in a custom shell while you’re at it. There’s nothing wrong with taking advantage of modern day upgrades.
Original Game Boy audio is so classic, fans have created genres of music based on it. Chiptunes are built on the fundamental sounds created by the Nintendo Game Boy. But what if you wanted to bring out the best of these sounds?
If you’re into high quality audio, this mod is for you. This mod upgrades your Game Boy to let more power through the sound system. Amplify those bass tones and bring out the best audio in your Game Boy. Ready to get started? Check out our Game Boy bass boost guide here.
If you’re familiar with Python’s keyword-only arguments, then you’ve probably wondered why the same constraint doesn’t exist for positional arguments. This changes with Python 3.
While this requirement may seem rare, learning how to nest defaultdicts properly in Python can be extremely powerful and save you from bloated and confusing initialization code.
Python is howchoo’s favorite programming language. We believe python promotes the most organized and performant codebase possible. We also love Django so, naturally, we love Python.
Ash is an experienced tech writer with an endless passion for technology. She enjoys retro gaming, 3D printing, and making awesome projects on the Raspberry Pi.
Ever since AT&T discontinued its unlimited data plan, it’s been important to keep an eye on your data usage. Thankfully, you can check your data usage at any time via text. In this guide, you’ll learn how to check your AT&T data usage.
Ever since AT&T discontinued its unlimited data plan, it’s been important to keep an eye on your data usage. Thankfully, you can check your data usage at any time via text. In this guide, you’ll learn how to check your AT&T data usage.
Ever since AT&T discontinued its unlimited data plan, it’s been important to keep an eye on your data usage. Thankfully, you can check your data usage at any time via text. In this guide, you’ll learn how to check your AT&T data usage.
Ever since AT&T discontinued its unlimited data plan, it’s been important to keep an eye on your data usage. Thankfully, you can check your data usage at any time via text. In this guide, you’ll learn how to check your AT&T data usage.
Ever notice that little HDR feature that appears for certain photographs on your iPhone? It’s called High Dynamic Range. Check out our guide on HDR and when to use it.
Ever notice that little HDR feature that appears for certain photographs on your iPhone? It’s called High Dynamic Range. Check out our guide on HDR and when to use it.
This is the simplest way to see the health of your iPhone’s battery. For a reminder, after 500 cycles, your battery is operating with roughly 80% of its full capacity*.
If you’ve got an iPhone with TouchID, and you’re mourning the loss of the ability to unlock your phone without pressing the home button, there is hope.
Whether you bought the 16GB iPhone on a budget or you like to store thousands of pictures and songs on your phone, you will eventually need to learn how to free up some space.
This is the simplest way to see the health of your iPhone’s battery. For a reminder, after 500 cycles, your battery is operating with roughly 80% of its full capacity*.
If you’ve got an iPhone with TouchID, and you’re mourning the loss of the ability to unlock your phone without pressing the home button, there is hope.
Whether you bought the 16GB iPhone on a budget or you like to store thousands of pictures and songs on your phone, you will eventually need to learn how to free up some space.
At our house, handheld games are king. This is the pinnacle of our console collection. Game Boys are still popular in 2019. Today’s modding tools make it nearly impossible to stop at just one Game Boy. This collection has slowly grown over the years, and that probably won’t change any time soon.
The collection features almost every Game Boy to pass through my front door. We’ve got original unmodded Game Boys, fully modded DMGs with backlit screens, and aftermarket shells for a totally custom experience.
This is everything! Okay—not everything. There’s always one or two Game Boys hiding around the house somewhere. But this is definitely a huge chunk of the collection! If you had a Game Boy as a child, you probably see one just like it here. The full picture doesn’t do it justice. Let’s dig in and check out the highlights of the collection.
The original Game Boy design is iconic in the gaming world. This was the first model created for the Game Boy line. They all have the classic offwhite/cream shell. A couple have yellowed more than others, this is likely due to poor storage conditions.
Before the Game Boy Color—there were colored Game Boys! The Play It Loud series brought a much-needed splash of color to the original Game Boy design. We’ve almost got every Play It Loud color: blue, red, yellow, green, black, and transparent. The only one missing is white.
The original Play It Loud shells typically have a gray bezel, gray buttons, and black text. On the black Play It Loud shell, the Game Boy text is a pink/red color. We managed to snag a couple in the original retail boxes. One of these boxes had the original Game Boy pamphlets!
One of the green Play It Loud Game Boys has been backlit, this makes the screen look darker in comparison. One of the unmodded Game Boys came with the original booklets, a Nintendo Power ad, and a really awesome Play It Loud poster. I love finding original documentation. It’s like unfolding pure nostalgia.
The clear Game Boys are so cool. They are just as exciting today as they were 20+ years ago. I’m really happy to have a few good clear shells in the collection. One of the boxes still had the Play It Loud box art tucked inside. There’s just something wicked about seeing the Game Boy guts while you play. These shells are some of my absolute favorites.
You can’t lose a Game Boy this bright. The Play It Loud yellow is just too hard to miss on a chunky device like this. These two easily bring the most sunshine to the collection. I was also excited to discover the original Game Boy booklets in the retail box!
These Game Boys are super rad. Wait…no they’re super red. Red Play It Loud’s aren’t very difficult to get ahold of. They’re not as common as the original Game Boy edition, but definitely not the rarest, either. I always appreciated the contrast of the gray bezel and buttons against the vibrancy of the red shell.
Blue Game Boys are a bit harder to get your hands. They were only released officially in Europe and Japan. As a US resident, this makes it much harder to complete the collection. But there’s nothing that can’t be resolved with a little research online. You can find blue Game Boys on eBay.
I love to mod Game Boys! One of my favorite mods is the backlight mod (I do not have enough AA batteries to light up this picture). The backlight installation process isn’t super easy, but it’s definitely something you can pull off in an afternoon.
These are the Game Boys that have aftermarket aesthetic upgrades. They’ve got brand new bezels, shells, buttons, and screens that weren’t manufactured by Nintendo. This is how people get crazy colored Game Boys that were never on the market.
These shells are aftermarket creations. You can find them on Amazon in a variety of colors. While original shells definitely have their appeal, sometimes a nice aftermarket upgrade can help salvage an old device.
In a world without Cartoon Cartoon Fridays and Slime Time Live, honor must be paid.
It’s one thing to backlight the screen on a Game Boy—but the buttons, too?! Not only do these buttons illuminate, they’re made with RGB LEDs. You can expect a full rainbow rotation of color while you play. It’s super cool and only a little bit distracting.
Sometimes it’s hard to say goodbye. These are the remnants of projects past. From broken shells to fried motherboards, these are the pieces we keep on hand. While preservation is key in a collection, sometimes you have to know when to cut your losses and make sacrifices for the greater good. You never know when you might need to salvage a part for another Game Boy.
Enough flash and flare, it’s time for the real deal. The biggest majority of the collection is dedicated to unmodded, original hardware. These Game Boys are carefully stored and maintained. While modding is fun and has its perks, nothing beats the appeal of an original Game Boy.
Game Boy resources
Thinking of starting a Game Boy collection of your own? I don’t blame you! Here are a few resources to get you started.
And lastly, don’t forget to bookmark our Game Boy troubleshooting guide. You never know what can go wrong, but you’re probably not the first person to encounter the issue before. We’ve got you covered.
We’re hiring!
Are you a passionate writer? We want to hear from you!