Wii U console hardware engineering

Nintendo recently published this interview about the hardware decisions for their upcoming console, the Wii U. The interview is part of Nintendo’s Iwata Asks series, where Satoru Iwata, Nintendo’s president, interviews engineers, designers and artists who worked on various software and hardware projects to get an inside look into their development. Even though I work at Nintendo, and I’ve even helped a bit during the Wii U’s development, I can learn a lot from reading these interviews, as well.

The interviews tend to be surprisingly honest, detailing both the good and the bad of development, and providing an honest insight into hardware and software engineering that you tend not to see very often. (Although the Xbox Engineering Blog is pretty cool, too.) This particular interview talks to several engineers in IRD (Integrated Research and Development), the primary engineering group who decides on and builds the hardware for home consoles. I’ve dealt with several members of IRD on a personal basis, and everyone I know there is always extremely nice, smart, and works very hard (probably too hard).

One of the major points they address in the interview is the engineering goal of reducing power consumption in home consoles, which is a goal that Nintendo had for GameCube, Wii, and now for Wii U as well. You can see from this chart how well Nintendo has been doing at that goal. of all of the major game consoles released in the past 13 years, only the PSOne uses less power than Wii and GameCube. Considering that PSOne’s processor ran at ~34Mhz while GameCube and Wii run over an order of magnitude faster, this is quite impressive.

Mr. Iwata’s interview touches on cooling solutions that they’ve used for including more powerful hardware in a smaller case design since Wii, which is an interesting topic for me. Case design is tough stuff, and cooling is one of the hardest parts about it. I’m sure that many readers are familiar with the Xbox 360′s “red ring of death,” a failure mode that manifested itself in a large percentage of consoles due to overheating. Even though the Xbox 360 is known for its especially loud fan (due to the high RPMs at which it runs), it still has cooling issues.

The engineers discuss how they did thousands of different heat tests to optimize the fan size and RPMs, heatsink size, and vent angle/placement. These are all interesting thermodynamic engineering problems. I won’t steal the photos for this post, but you should really check them out here.

Finally, as an aside, I’m not sure that most technology company presidents would be capable of legitimately doing an interview like this. Throughout the interview, Mr. Iwata makes several clever and interesting comments which demonstrate his technical knowledge and understanding, and that he’s been closely involved in the Wii U’s development. As a computer scientist and former game developer himself, Mr. Iwata is unfortunately rare in the video game industry. Most of the leaders of successful game companies are businessmen first and foremost. Here are a few examples:

Company Role President/CEO Background
Sony Corp Consumer Electronics/Games Kaz Hirai Business and marketing
Activision/Blizzard Game Publisher/Developer Bobby Kotick Software entrepreneurship
Electronic Arts Game Publisher/Developer John Riccitiello Business and marketing
Sega Game Developer Hajime Satomi Business

It’s refreshing to work for a company that’s headed up by an engineer.

Wrench Reduction

In physics and mechanical engineering, it’s often useful to reduce a system of forces and couples to a single force and a single couple, in order to simplify the problem. The net forces and couples are easier to think about than several forces and couples would be.

We can take this simplification to the extreme by reducing a system into a single force, applied at a single point P, and a single couple which is parallel to that force. This is called a “wrench,” and any system of forces and couples may be reduced into a wrench. There aren’t a lot of references about “wrenches” online, but you can read about them here on Wikipedia, or in Chapter 4 or Bedford and Fowler’s Statics.

As a fun exercise in 3D programming, I made a tool which allows you to input any system of couples and forces, and which shows you, step-by-step, how to reduce it into a wrench. Hopefully this is actually interesting and not as hopelessly nerdy as it seems to me right now.

The tool is here: Wrench generator

(This tool requires WebGL, an in-browser 3D framework which can be a bit tough to get running on certain browsers and certain computers. If after some Googling you still can’t figure out how to get it running, leave a comment here and I’ll try to help you get going.)

Systems of Equations

Physics and mechanical engineering students spend a lot of time solving systems of equations (a.k.a. simultaneous equations), often in the context of free body diagrams. I’m taking a Statics course, and we’ve been doing these sorts of problems a lot. I wanted to write a post exploring what techniques are available for solving systems of equations, and what software tools you can use to solve them automatically.

Basically, there are three ways to solve systems of equations:

  • Graphically, by plotting and seeing where the equations intersect. For equations in two variables, this is quite practical, as you can assign one to x and the other to y on the 2D Cartesian plane. For 4 variables and greater though, I’m not sure if it’s possible.
  • Algebraically, through substitution (finding the value of a variable in terms of other variables, and substituting that value in for the variable), elimination (combining equations such that certain variables cancel out entirely), or a combination of both.
  • Using matrix operations, usually involving a technique called Gaussian elimination to get an initial matrix into a reduced form called reduced row echelon form. This is a very efficient method for complex systems of equations.

Let’s pick this simple system of equations to solve:

2x + y – z = 24
x + 2y + 3z = 11
y + z = 6

How could we solve this with software tools?


Using the Solve function makes this a cinch in Mathematica. Specify a list of equations as your first argument, and a list of variables as your second argument:

In[1]:= Solve[{2x + y - 2z == 24, x + 2y + 3z == 11,
          y + z == 6}, {x, y, z}]
out[1]= {{x -> 3, y -> 10, z -> -4}}

TI Calculators

On TI calculators, you can express the system of equations as a matrix, like so:

\left( \begin{array}{cccc}  2 & 1 & -2 & 24 \\  1 & 2 & 3 & 11 \\  0 & 1 & 1 & 6\end{array} \right)\

You can see above that each row is one of our equations, and each column is the x, y, z and right-hand value, respectively.

We can then reduce that matrix to reduced row echelon form, where each row directly expresses the value of a single variable. The resulting matrix will be in this format:

\left( \begin{array}{cccc}  1 & 0 & 0 & x \\  0 & 1 & 0 & y \\  0 & 0 & 1 & z\end{array} \right)\

Solving for several variables is as simple as inputting the matrix of equations on our calculator, then using the RREF (reduced row echelon form) function to transform the matrix. Here’s a video showing the steps (full-screen to see the details better):

As you can see, the last column of the resulting matrix gives us 3, 10, and -4, which are the values for x, y, and z, respectively.

Newer TI calculators (TI-85 and later) have simultaneous equation solvers that make this process easier. Check your instruction manual or Google.


There’s an excellent module for symbolic manipulation called SymPy, which can solve various types of complicated equations. Solving a system of equations with SymPy is pretty easy.

After downloading and installing SymPy, fire up the Python interpreter.

First, we need the Symbol class to define a symbol, and the solve function from the solvers sub-module to solve a system of equations. Let’s import these:

>>> from sympy import Symbol
>>> from sympy.solvers import solve

Now, to represent our system of equations, we’ll first declare the symbols we’re going to use:

>>> x = Symbol('x')
>>> y = Symbol('y')

Finally, we give the solve function two arguments: a list of expressions that equal zero, and a list of variables for which to solve:

>>> solve([2*x + y - 2*z - 24, x + 2*y + 3*z - 11,
      y + z + -6], [x, y, z])
{x: 3, y: 10, z: -4}

Do you have any tips for solving systems of equations with these tools or any others? I’m still looking for a clean way to do it in Matlab/Octave. Share your thoughts and tricks in the comments.