MANUFACTORIA Hint guide.
Game by PleasingFungus.
Guide by Dr_Donut
Not cool enough for a website.
Manufactoria is a great game. As a person with no programming or computer
science backgrounds at all it was a great introduction into the land of
programming, and also just an overall great puzzle game.
However, that does not mean it was by any means an easy experience. The
steep learning curve and high degree of difficulty on the later levels,
combined with the author's very minimalistic explanations of gameplay and
functions, can make this game very off-putting for new players.
If you are or were one of the players who has given up on this game, then
this guide is for you! As level solutions are readily available throughout
theinternet, especially on Kongregate.com, this guide will instead focus on
helping to explain and give hints for each of the levels in plain and simple
The goal of this guide is to help give you inspirations and guide you to
creating your own solutions, as that is the most rewarding aspect of this
game. If you are an experienced player just stuck on some of the later
levels, you can probably skip the next section, where I will be explaining
the basic gameplay elements.
**QUICK HINT: Understanding level 9 is very important for later levels**
TABLE OF CONTENTS (Control + F to get there faster!)
Part 1: Controls
Part 2: Level Hints
Part 3: Credits / Final Thoughts
Part 1: Controls
The Robot: This is that little guy that you are 'testing', the part that
moves around the level. The goal is to get robots with the correct
input/output from the top of the level to the bottom exit, while discarding
The Tape: The tape is the part of the game that displays all those red and
blue dots. Note that the game will always READ the tape from the left side
(the beginning) and WRITE new dots on the end. More on writing later.
The Code, or String: String is, I think, a programming term for a section of
code. In this case the code is represented by Red and Blue dots
(later Yellow and Green). In later levels, these dots represent binary
code, with blue being 1 and red being 0. The manipulation of these dots is
what this game is all about!
Conveyer belts: These simply move the robot throughout the levels. A robot
can approach a conveyer belt from any direction. For example a robot could
be placed on two conveyer belts both pointing at each other, and the robot
would keep going back and forth infinitely.
Conveyer belts are also the only tool that can be 'stacked', or 'bridged.'
Later levels will use this bridging quite a bit. After building one
conveyer belt, add a bridge by holding down the shift key and placing
another bridge on top of your original in a different angle. You should
end up with a plus sign looking configuration.
When a robot enters a tile that has a bridge, it will take the path in line
with it's original direction. If a robot enters a bridged tile from the
left it will always follow the horizontal path. Note this is not the case
with unbridged tiles, as the robot will follow the conveyer belt in any
direction in that case.
Branches: These are tools that 'read' the tape, and send the robot in one
of three different directions. There are two types of tapes, and they both
behave exactly the same. There is a Red/Blue branch (R/B), and a
Yellow/Green branch (Y/G). In both cases they will look at the FIRST symbol
on the tape. If the symbol matches one of the colors on the branch, that
color will be REMOVED from the tape, and the robot will go in the direction
of that color on the branch. If the symbol is NOT on the branch, it will
NOT BE removed from the tape, and continue down the in between arrow on the
For example the current 'string' is Red-Yellow. If the string goes to a
Yellow / Green branch, it will pass through and the string will remain Red -
Yellow. (Strings are not altered by a branch if the correct color is not
detected). However if the same string passed through a Red – Blue branch,
the machine would take off the 'Red', and send the robot down the red path.
A VERY IMPORTANT point to remember about branches is that once a branch has
read a color, that color is REMOVED. To replace colors that have been
removed from your code, you will need to use writers.
Writers: Writers simply ADD the corresponding color to the END of your
string, and send the robot on along the arrow. Think of writers as a
conveyer belt that adds a color.
The Select Tool: The select tool allows you to manipulate large portions of
your level at the same time. It is also a little under-explained in the
game. Selecting sections of your level is easy, simply select the select
tool. Now click and hold while dragging the mouse over an area. Release
the mouse once you have selected the required area.
When you have a selected area, there are several things you can do:
Press the delete key to delete all selections.
Press Shift + C to copy your selection.
Note you can copy selections between levels. This is very useful in later
levels, when a section of your new machine may have already been built in an
Press Shift + V after copying to paste your solution. You will be able to
move the pasted selection around before placing it like a normal tool.
To further manipulate a selection, you must first CLICK AND DRAG your
selection. You should see your entire selection 'lift off' and start
following your mouse. While your selection is 'hovering' like this, you can:
Press the A or D keys to rotate your selection.
Press the spacebar to flip (reverse) your selection.
Note this does not reverse the 'polarity' (colors) on switches. [at least at
the time of this writing]
Simply move your selection
When you are finished doing any of the above, simply release the mouse button
when your tiles are where you want them to be. NOTE: These moved tiles will
overwrite any existing tiles on the board, so be careful!
Part 2: Level Hints
In this part of the FAQ I will be going through each level and giving advice
on how to beat each level. I will try to start with very broad hints and
move gradually towards practically giving away the solutions. Note that due
to the nature of Manufactoria, there will be many different ways to solve
each level. If some of these hints can inspire you to create different
solutions to my own, that's great! I will include links to my own solutions
at the end of each section. Note that in most, if not all cases, my
solutions that I will be linking to are NOT the best solutions. I will be
basing my descriptions and hints off of these, so if you are really stumped
you can click and load them to help you figure out what I'm babbling about.
Level 1: Robo Toast!
Objective: Move robots from the entrance (top) to the exit (bottom)!
Hint 1: Umm... don't give up!
Hint 2: Use conveyer belts.
Hint 3: Use three conveyer belts pointed in the same direction to move the
robot to the exit.
Level 2: Robocoffee!
Objective: If a robot's string starts with blue, accept. Otherwise: REJECT.
This is the first level where you will have to use branches. Don't fret!
Think about it logically, the solution is easy!
Hint 1: You will need only ONE branch.
Hint 2: The only symbol you care about is the first one.
Hint 3: Place the first branch so that the blue is facing the exit. Your
conveyer belts will carry anything that goes out of the blue side to the
exit. All other directions should simply be dumped on the floor.
Level 3: Robolamp!
Objective: Accept if there are three or more blues.
This is the first level many people get stuck on. If you're one of them,
don't fret! This level introduces the concept of a repeating string.
Hint 1: A useful idea in design (I've found) is to first design a machine
that will accept a proper solution. You can use the INPUT tool (located in
between the START and SAVE buttons) to test your own strings. In this case,
once you have built something you think will be a good solution, simply use
the input tool to test THREE BLUES. If it passes, you know you are on the
Hint 2: Try to create different levels, or tiers, or loops, to your machine.
The idea is to keep track of how many blues your machine has seen by sending
it to a different loop each time a blue is seen and keeping it in the same
loop each time a red is seen.
Hint 3: Once your machine has seen three blues, you can immediately move it
to the finish.
Hint 4: Make sure that paths to the floor (discards) are always open if your
string runs out before your machine has seen three blues.
Hint 5: Bridges could be very useful for conserving space.
Level 4: Robofish!
Objective: Accept if a robot contains NO red.
Hint 1: Remember that conveyer belts can send a robot DIRECTLY back into a
Hint 2: If your machine reads a red, to the floor with it!
Hint 3: You should only need one Blue / Red branch.
Hint 4: You should only need 3 conveyers.
Hint 5: Make your machine so that any blues will go right back towards the
branch, while any reds fall to the floor. Once the loop has exhausted
itself (no more dots), the robot will exit through the neutral path to the
Level 5: Robobugs!
Objective: Accept if the tape only has alternating colors!
Another tricky level. In this level you will need to expand your mind a
little bit about your loops. Try to think of your different loops not only
in terms of the branches, but also the conveyer belts. What loops are the
conveyer belts part of? If I send something to a conveyer belt, what loop
is that going to? What function will that loop have?
Hint 1: If at ANY POINT in your loops there are two consecutive same colors,
discard that robot.
Hint 2: This level will require you (probably) to introduce another use of
the branches, that of checking to see if a string has finished.
Hint 3: To check if the string has finished, use a Blue / Red branch at the
end of your string(s) to see if the robot goes down the neutral path.
Hint 4: When a robot goes through your 'end checking' branch and it is not
the end, make sure both red and blue go back to the correct loops. This
may require some bridging and redesigning.
Hint 5: Starting your level with a B/R branch, and the building two separate
(they never interact) shouldn't be too hard.
Hint 6: Okay: Build a machine that first checks for blue or red. Note the
game accepts 'nothing' strings as being correct, so build a conveyer right
to the exit from the neutral path. Now build conveyers from both blue and
red. Think of these conveyers as your BLUE and RED conveyers. A robot
should only touch the blue conveyer if the last read dot was blue. At the
end of these conveyers will be another branch that should check for the
opposite color. Note that each neutral branch must lead to the exit, as the
only possible failures on this level can occur when two of the same color
appears. After your opposite color branch, you should check for another
opposite color. Use these two branches (on either side) to keep looping and
checking for opposites.
Level 6: Robocats!
Objective: Accept if the tape ends with two blues.
This one shouldn't be too bad using the skills you've already learned.
Remember, design for the solution and figure out how to deal with the errors.
Hint 1: Remember ending in two blues is the same as ending in 3 or more
Hint 2: You should set up a three branch long loop to check for two blues
and then the end.
Hint 3: If you see any reds, send the robot ALLLL the way back to the
beginning (not just to the last branch).
Hint 4: If your machine sees two blues in a row, any more blues should be
sent back to the 'check if last' branch.
Hint 5: Make sure any neutral paths lead to the floor before the machine has
seen two blues.
Level 7: RC Cars!
Objective: The input but with the first symbol at the end.
This level introduces the use of writers. Remember that once a symbol has
been read, it is gone forever unless you write it back into the string
somehow. Also: Writers always add on to the END of the string.
Hint 1: The END of the string. END.
Hint 2: Where do writers put symbols??
Hint 3: All you're concerned about is the first symbol, so don't make a loop
or read more than one symbol.
Hint 4: Make a R/B branch at the start. If a red is read, write a red
pointing away from the branch. If a blue is read, write a blue away from
the branch. Both writers will connect to a conveyer to the end.
Level 8: Robocars!
Objective: Replace blue with green and red with yellow.
A very easy level that introduces the idea of copying the basic colors with
other colors. I like to get into the habit (for later levels) of keeping
with the green is blue and yellow is red theme if I decide to use a loop
that converts colors for whatever reason.
Hint 1: Just create a loop that keeps sending the robot through a R/B branch
until it goes through the neutral part.
Hint 2: Remember: Yellow and Green are considered neutral by a R/B branch
(and vice versa) and are not destroyed by passage.
Hint 3: Add a Yellow writer pointing towards the branch after Red, and a
Green writer pointing towards the branch after Blue.
Level 9: Robostilts!
Objective: Put a green at the beginning, and a yellow at the end.
This is perhaps the MOST IMPORTANT level in game to understand. Completing
this level itself is very easy, yet I will try to explain why the
PleasingFungus (the game's author) has included this seemingly simple level.
But first, hints on the level itself.
Hint 1: Whenever writing to the string, consider the order of your writing.
If you want something to be at the beginning of a (completed) string, you
must write it, then copy the rest of the string. If you want something to
be at the END, you must first copy the string and then write it.
Hint 2: So.... for this level you must write the green, copy the reds and
blues, and then write a yellow.
See this link for exactly what I'm talking about. I will be referring to
this configuration for why this level is so important.
So, why such an emphasis on this level. This configuration will be very
useful in later levels.
First, the easiest part to see is the B/R branch with the connected Blue and
Red writers. In my mind I consider this 3-piece configuration to be a
Re-constructor. Whenever your robot hits this setup, he will continue to
copy whatever blues and reds he has in order. Most later levels are
accomplished by only modifying one dot at a time, so levels will be full of
Note with a re-constructor that without a green or yellow somewhere in the
string, the loop would just continue on forever. It would read a read, then
write a red. Same with blues. It would never finish. Therefore we can see
why the need for other colors is crucial.
The second important lesson with this level comes from the Green dot at the
beginning. Placing a green (or a yellow) before a string is a way of
telling your loop when it has reached the end. This may be confusing. Why
should writing something at the beginning mark the end? Because the machine
always writes to the end! Having a green in your loop like this lets you
design machines around the fact the you know a green dot will appear
eventually, and when it does you have reached the end of your loop.
Finally, putting a yellow at the end of your string lets you know when
you've reached a critical part of a string (inside of a loop). In this
level you know the dot that is directly before the yellow is at the end of
the string. If you could someone move the yellow through the string while
keeping everything else in order, you could 'mark' a specific dot. Keep
this in mind through later solutions.
Level 10: Robobears!
Objective: Strings that begin and end with the same color.
This level can quickly get very bloated it you let it. Try to keep things
very simple and use the least amount of branches that you can. Think things
through logically. You can do this.
Hint 1: You only care about the very first and the very last symbols.
Hint 2: Start your level with a branch. This will tell you what color will
be the correct final color.
Hint 3: If your level started out with red, then any time the machine sees a
red, send it to a 'accept' loop. And if it sees a blue, send it to a
Hint 4: The neutral exit for the 'reject' loop should lead to the floor.
The neutral exit for the 'accept' loop should lead to the exit.
Hint 5: Five branches should be all that you need. If you have more than
that you probably have more loops than you need.
Level 11: Milidogs!
Objective: With blue as 1, and red as 0: Accept odd binary strings.
This is where the game got scary for me the first time I played through it.
I don't know anything about binary! you're probably thinking. Don't worry!
I'll try to explain only what you need to know with regards to binary as the
binary levels progress.
This level is actually very easy once you understand one crucial fact.....
Hint 1: Go ahead! Google binary if you want and do a bit of research.
Hint 2: Just like numerical numbers, there is a very easy way to know if a
binary number is odd or even.
Hint 3: If a binary number ends in a 1 (blue dot), it will always be odd.
If it ends in a zero (red dot) it will always be even.
Hint 4: Keep in mind that nothing, or only red dots both count as zero.
(000000 = 0, just as 0000001 = one)
Hint 5: Another useful configuration or tool that is useful in binary levels
is to always first “strip off” any leading reds. [ie: turn 00000001 into 1,
or 0000010101 into 10101].
Level 12: Androids!
Objective: Accept some number of blue, then the same number of red.
Another tricky level that cause many people to rage quit the game. There
are two basic ways to beat this level, one 'true' solution and one 'false'
solution. In the true solution your machine should be able to handle any
length of string thrown at it, while the false solution would fail after a
I'll cover the true solution in detail, yet I'll also quickly discuss the
other version. In the false solution, the machine will set up a long string
of B/R branches side by side. There may be some conveyers involved, but the
logic is that an equal number of reds and blues would eventually get the
robot back to the starting branch, and then through the neutral to the exit.
The problem with this solution is that it fails on very long strings, and
also is very large and bulky to build.
The true solution introduces the player to another important concept, that
of reductionism. While I havn't taken a math course since high school, I
remember this much: If a = b, then a-1 = b-1. What I'm trying to say is
that if we accept that both red and blue will have an equal amount then we
can begin to REDUCE the complexity of the string to something far more
manageable. The idea is to subtract one red, then one blue, and then check
to see if the string is finished. If ever your machine can't subtract one
color after it subtracted the other, then you know there was an unequal
amount and the robot should be rejected.
This is probably going to be the toughest problem so far. Be sure to
utilize the concept of 'prepping' your string, and remember that you get rid
of symbols by having them be read and not replacing them. Design for the
solution, think it through, and you'll do fine.
Hint 1: Okay. You'll probably want to first add a green at the beginning to
mark the end of your string. Design to that if a green gets read, you can
add another and send it back through the loops.
Hint 2: Remember that blue should always be the first color you see. If you
see a red initially, junk the robot right away.
Hint 3: If there are more reds than blues, at some point your 'check if blue
is first' branch should fail.
Hint 4: Remember to re-construct extra blues and extra reds after you have
taken off one.
Hint 5: If there are any blues after your reds, and your string hasn't
finished yet (encountered the green dot) junk it.
Level 13: Roborockets!
Objective: Swap blue for red and red for blue.
If you're familiar with the idea of marking the end of your string, this
level will be a breeze.
Hint 1: The natural solution is to make a B/R branch and connect the writers.
However this will lead to an infinite loop. How to avoid this?
Hint 2: You must add in a green or yellow before you start doing your
conversion. This way the yellow or green dot will be ignored after the
conversion is finished.
Hint 3: Remember to clean up the extra colors.
Level 14: Roboplanes!
Objective: All of the blue, but none of the red.
Almost exactly the same as roborockets, except you are eliminating instead
Hint 1: See the above hints.
Hint 2: Still can't get?
Hint 3: Add a blue writer that leads back to the B/R branch, while just a
conveyer will lead back to the branch.
Level 15: Robomecha!
Objective: The input, but with the last symbol moved to the front.
If you read the section on androids, then this is the level where putting a
yellow at the end comes in handy.
Hint 1: You'll need some way of knowing what color is last.
Hint 2: While searching for the last color, you'll have to to have some way
of of keeping track of all the other colors.
Hint 3: Converting the colors into green and red will be one such way of
Hint 4: Make sure you have a green at the beginning, and a yellow at the end.
Hint 5: If you always check for a yellow dot BEFORE doing your color
conversion, you can know when the last dot has been reached.
Hint 6: When you reach the yellow dot, immediately write the appropriate
color and then re-construct / re-convert your yellows and greens back to
reds and blues.
Level 16: Rocket Planes!
Objective: The input, but with all blues moved to the front.
Shouldn't be too tricky if you've gotten used to using green to mark the end
of your solutions.
Hint 1: Try to design for a solution first, and figure out how to deal with
Hint 2: Remember the problem, you have to move blues ahead of reds.
Hint 3: If your machine sees a blue after a red, find a way to get that blue
on the tape before the red.
Hint 4: The idea here is so carry, or borrow if you will, the first red dot
Hint 5: Once your machine sees the first red, do not write it right away.
Instead, continue to check for blues and reds. If, after the red, there are
only reds, you can send the robot towards the exit and add the missing, or
borrowed red. (think of keeping a math equation balanced. If you change
it in one place, you will have to put it back somewhere else)
Hint 6: If, after seeing the first red, your machine sees a blue, you can
immediately write a blue. Then continue to re-construct the rest of the
solution. When it finishes (comes to the green) then add the borrowed red
before starting the loop over again. You have now succeeded in placing one
blue before a red. If this loop repeats enough, all blues will be before
Level 17: Teachers
Objective: Accept X blue, then X red, then X more blue for any X.
Another level that seems more complicated than it actually is.
Hint 1: Think of the easiest possible string that would be accepted for
this problem and design a machine that would accept it. (B-R-B)
Hint 2: Is there a way you could get other solutions down to that magic
B – R -B formula?
Hint 3: Reduce reduce reduce!!!! (Don't forget to prep your string with a
Hint 4: Similar to level robomechas, you want to reduce the complexity of
the string while checking correctness along the way.
Hint 5: Use the concept of 'borrowing' from the rocket planes level to
slowly remove b-r-b each time the robot goes through your loop.
Hint 6: If a color appears where it shouldn't be, be sure to junk the robot.
Level 18: Robo Children!
Objective: Accept an equal number of blue and red, in any order!
Hmm... doesn't think objective sound a little familiar? This level will put
that whole copy + paste feature to great use!
Hint 1: This level is identical to Androids, expect the colors are out of
Hint 2: If you could only get all of the blues to the front, then you could
use your androids solution!
Hint 3: Wait a second... didn't you just finish a level where you put all of
the blues in front?
Hint 4: To copy, select an area then press shift + c. Press shift + v
(even on another level) to paste!
Hint 5: If you havn't gotten the hint yet, use your solution from Rocket
Planes to “prep” your string. Then attach that “prepped string” to your
solution from Androids. Isn't copy + paste wonderful?
Hint 6: You might need to make to optimizations to your solutions (making
them smaller) in order to fit everything on one screen. You can do it!
Level 19: Police!
Objective: Put a yellow in the middle of the (even-length) string.
[ed. The level will always be even numbered]
This can be a very mind bending level. You're probably used to moving
symbols to either the front or the back by now, but the middle? How? Why?!
Earghh! Don't worry. My inspiration for creating this guide actually came
about of me reading some human advice regarding this puzzle. It's actually
not too hard once you wrap your mind around it. Full credit goes to
Anonymous guest (who are you!) at the jayisgames.com board.
Hint 1: Obviously the you can only ever write a symbol at the end of the
tape. Thus we need to find a sneaky way to move symbols in order to locate
the middle, and then mark the middle.
Hint 2: Hold your hands apart from each other. How might you find where the
middle point in between your hands? If you slowly moved your hands together
until they touched, does that give you any ideas?
Hint 3: What if you could move two symbols from opposite ends of a string
together until they touched? Would you have found the middle?
Hint 4: Okay, one way to solve this problem is to first “prep” your string
by adding a yellow to the beginning and the end. (Don't forget to add a
green before anything, so you know when your loop has finished).
Hint 5: The idea is keep re-constructing all the symbols until you hit a
yellow. The first yellow will be moved forward in the string. The second
yellow will be moved backwards in the string. If you can get those two to
meet, you have found the middle.
Hint 6: In your loop, when you hit the first yellow, check to see if there
is another one immediately. If not, continue as normal, if so, you've found
the middle and simply need to add one yellow, re-construct the rest of the
string, and send it to the exit.
Level 20: Robotanks!
Objective: With blue as 1, and red as 0, accept binary string that are >15.
[ed. greater than 15]
This is another simple level (should be by now) that just relies on a simple
fact of binary.
Hint 1: If you really want to figure it out yourself, you can use the input
tool and try to discover the difference between 15 and 14 and under.
Hint 2: Simply put 15 or over requires at least five symbols to produce.
Hint 3: So anything that has gone through five branches can head right to
Hint 4: Remember that reds at the beginning do not count, so be sure to get
rid of them!
Hint 5: Don't forget about bridges.
Level 21: Soldiers!
Objectives: With blue as 1, and red as 0, multiply by 8!
I think this level is in here just to make people scared.
Hint 1: There is a very easy way to multiply any binary string by 8.
Hint 2: It involves adding three colors.
Hint 3: All of the colors are the same.
Hint 4: All three reds to the string and you're done.
Level 22: Officers!
Objective: With blue as 1, and red as 0, add 1 to the binary string.
This level actually requires you to make a rudimentary calculator. Cool!
I highly recommend checking out this website, as it gives a real simple a
good description of how binary addition works.
Hint 1: Be sure to get rid of any reds before the first blue. They are
meaningless. Destroy them!
Hint 2: Spend some time on the input screen, seeing if you can get
comfortable how adding +1 works in binary. Try to find some patterns.
Hint 3: Have you noticed that if a string ends in a red, you simply change
it to a blue?
Hint 4: If a string ends in a blue, it changes to a red and the blue is
Hint 5: If a string ends in a blue, you have to change the last red to blue,
and then check to see if the next color behind is red or blue. If it is red
you can just change it to blue and be done. If it is blue again, then that
gets changed to red and the process repeats again.
Hint 6: Remember about using a yellow to 'mark' a specific point in the
string, in this case the digit that needs to be carried or changed.
My solution for this level is quite clunky, but it works! Just think
through the steps logically and you'll be able to make something better, I
have no doubt!
Level 23: Robospies!
Objective: With blue as 1, and red as 0, accept natural powers of four.
Another easy level that relies on some binary trickery. I'll get right to
Hint 1: A power of four in binary is some number of blues followed by an
even number of reds.
Hint 2: First strip off any leading reds. Destroy them, DESTROY!
Hint 3: Once you hit the first blue head to another branch.
Hint 4: Any more blues head to the same place.
Hint 5: A red will have to be followed by another red.
Hint 6: After two reds check if it is the end and send it to the exit, if
not check for two more reds.
Hint 7: Note any blues after a red will cause the robot be rejected right
Level 24: Judiciary
Objective: Accept even length strings that repeat midway through.
In this problem the strings will always be even length. What you are being
asked to do is to check if, after the midpoint, the entire first half is
repeated in order. [ie: B-B-R-B-B-R] = pass
Hint 1: Wasn't there another problem involving middle parts?
Hint 2: Use your police solution in order to find the middle of the string,
then create a new second half.
Hint 3: Now find a way to compare the first half to the second. Don't get
overwhelmed, do it one step at a time.
Hint 4: Use a variation of the theme of reducing the problem down. If the
two sides are the same, then doesn't that mean they would both have the same
beginning or endpoints?
Hint 5: To complete the machine, first check the color of the first symbol
on the first half and construct the rest. Don't add the first symbol back
into the string. Once you hit the yellow (midway) add a yellow and check if
the borrowed color from the first is the first to be removed from the second
half. If it isn't, junk the robot. If it is, keep looping back to the
start. If the machine eliminates all the colors, and your string has only a
green and a yellow, send it to the exit.
Level 25: Politicians
Objective: Accept if there are twice any many blues as reds.
Here is another problem that won't be too hard if you break it down.
Hint 1: First move all the blues to the front.
Hint 2: You want to accept 2 blues and 1 red in the end, so start reducing
down to that size.
Hint 3: Make a loop that only accepts 2 blue and 1 red. Make sure to check
for more reds before it goes in the exit.
Level 26: Academics!
Objective: Reverse the input string.
Hint 1: You will want to find a way to read from the end of the string.
Hint 2: Prep the string and mark a yellow at the end, with a green at the
Hint 3: The idea is to keep checking for the yellow, then write the
appropriate color behind the yellow. The yellow will travel along the
string until it hits the green. When your machine reads Green – Yellow, you
know you are finished.
Hint 4: After the the marked symbol is found, be sure to re-construct the
string right before adding the new symbol. This is what will slowly build
up the reverse input.
Level 27: Generals
Objective: Subtract 1 from the binary string. Input will always be equal to
or greater than 1.
This level I found a lot easier than officers. This is because a borrowed
red can actually go all the way to the beginning, before the first blue, and
still be a valid number.
Basically reverse your Generals solutions and you shouldn't have too much
Level 28: Engineers!
Objective: Accept perfectly symmetrical strings.
One solution to this level is to build a machine similar in nature to that
of your judiciary second half. A symmetrical string will have the same
beginning and end, so if you keep eliminating those until none are left, you
then have a symmetrical string!
Hint 1: Use a yellow at the end of your string to check for the final symbol.
Hint 2: Remember that a string of one symbol should pass not matter what, so
build that in.
CREDITS / FINAL THOUGHTS
As for the rest of the levels, I'll leave that to you to figure out by
yourself. Use what you've learned and always remember to break the solution
down to the easiest components and solve for the solution.
As you've probably seen by now, my solutions leave a lot of room for
improvement. If some Manufactoria deity has been reading this, perhaps you
could write a separate FAQ designed to help humans like me optimize my
A big thanks to PleasingFungus for creating this game. Let's hope he keeps
releasing updates and, if we're lucky, a sequel!
Another big thanks to all the people on the message boards and everyone who
posted their solutions. I would have never made it this far without your
Want to give me shout? Offers useful corrections for the FAQ? Shower me
with honor and glory? Drop me a line at:
Please don't send in your own solutions, or offer updates to my own.
That's not the point of this guide. Only mention solutions if the links or
solutions themselves seem to be broken.
Thanks for reading my guide! Now get out there and solve some more levels!