This guide aims at facilitating

• the process of finding a solution to any level of Octopticom, and
  
• the collection of all achievements by showing optimized solutions.

In order not to spoil too much all solution screenshots are spoiler-hidden. Unspoil at your own risk!

All levels have screenshots of optimized solutions for those you at the end of their wits. I am currently working on creating unoptimized solutions and will add them over the coming days so that you can try optimization on your own. Please note that I'm creating the unoptimized solutions after having finished the game and that I may take the liberty to approach any level in a different, especially more complex way to not give the optimization away!

You can jump directly to the level you are interested in by use of the right-side Contents menu. In each level section you can find some hints on how to tackle the respective puzzle. At the end, there's the spoiler-hidden screenshot(s) of my solution.

Finally, feel free to share you solutions! I'd be especially interested in solutions that are more area-efficient. And I'd be happy to hear from you, so drop me a line in the comments if it's not too much trouble :)

Even though the available components are rather adequately described in-game here is a recap of all components:


The Block simply blocks any beam hitting it from either side. Can be helpful if you wanna prevent an unused beam from a Beam Splitter to hit any other component. Or simply apply it to clean up a solution. I very rarely used Blocks.


The Tunnel lets beams pass through two opposing sides while beams are blocked on the other two opposing sides. Can be helpful for optimizing solutions. Never once did I use a Tunnel though.


Mirrors are among the most important components given that the main task in the game is to redirect light beams.


Mainly useful for optimizing solutions because you can achieve the same effect by using two mirros in almost all cases.


Equally important as Mirrors are Beam Splitters. Without them it would be impossible to create multiple beams from the single source beam or to recombine separate beams to one.


Primary Color Filters only let beams of their respective primary color pass, i.e. red, green, or blue.


Secondary Color Filters let three types of beams pass: the respective secondary color as well as any of the two primary colors that the respective secondary color is made of, i.e.

• cyan, green, and blue;
  
• magenta, red, and blue;
  
• yellow, red, and green.

Another useful way to look at these components is by focussing exclusively at the three primary colors because any secondary color is just a combination of two primary colors:

• Cyan Filters prevent only red from passing.
  
• Magenta Filters prevent only green from passing.
  
• Yellow Filters prevent only blue from passing.

Primary Color Dichroic Mirrors let all colors pass except the one of their respective color which is redirected according to the orientation of the mirror. In effect, these mirrors only affect by redirection exactly one of the primary color channels, i.e. red, green, or blue.


Secondary Color Dichroic Mirrors redirect all primary colors except the one complementary to their respective color. In effect, these mirrors affect by redirection exactly two primary color channels, i.e. green & blue, (cyan mirror), red & blue (magenta mirror), or red and green (blue mirror).


The Switch Type 1 allows for the passage of a beam exclusively if there is an active control beam at the "bottom". Extremely important in all puzzles that they are available in.


The Switch Type 2 allows for the passage of a beam exclusively if there is no active control beam at the "bottom". In my opinion even more important than the Switch Type 1.


The Accumululator carries an input from one iteration to the next. Required in all puzzles that need some way of "counting".


The Complementary modifies a beam input into an opposite color beam output during the same iteration. It requires a white beam at the "bottom" to function. I only found it to be useful in one level of the entire game (yes, it is the one with fixed input and blocks to impede the use of this component).

Yes, this level covers the basics of using mirrors.But do you really have to?

Unoptimized solution:


Optimized solution:

Which filter would you use to get rid of only red beams? If you do not know this take a look here: Wikipedia - Complementary Colors[en.wikipedia.org] or read the above Components section.

Unoptimized solution:


Optimized solution:

Each Secondary Color Filter only prevents the complementary primary color beam from passing. So how many filters would you need if you want just the blue color channel of each input cell transported to the output?

Unoptimized solution:


Optimized solution:

Finally, we can split beams and we even got Primary Color Filters!
Experiment a bit with those Beam Splitters and the solution should be easy to find.

Unoptimized solution:


Optimized solution (Area 12):

Beam Splitters do not exclusively split beams. They can also be used to combine beams!

Unoptimized solution:


Optimization hint:Is it really necessary to combine beams for the solution?

Optimized solution (Area 12, Cost 90):

The Switch Type 1 lets beams pass only when the control beam at the bottom is active. And look! The developer made Dichroic Mirrors for all primary and secondary colors available. How convenient...

Unoptimized solution:


Optimized solution (Area 10):

This solution heavily relies on the findings of the previous level with the exception that now we have a Switch Type 2 available.

Unoptimized solution:


Optimized Solution (Area 10):

This level requires a somewhat different approach given that there is an abundance of fixed components already on the board. However, the main focus is on preventing the infinite loop which is created by the fact that the beam that passes Switch Type 2 does in the same iteration become the active control beam of Switch Type 2 ... a paradox of sorts!

Unoptimized solution:


Optimization hint:The optimized solution can be created by adding only three components.

Optimized Solution (Cost 224):

You are now moving into the binary operations section of the game but fear not! Apart from level 1, this level has the most basic solution layout yet.

Unoptimized solution:


Optimized Solution (Area 4):

This is the OR color table that is expected:


So basically if there is any white input it has to be passed along to the output.

Unoptimized solution:


Optimized solution (Area 8):

Optimization Challenge: Area - 10

Changing a white input into a black output, and a black input into a white output can only be accomplished with some sort of switch.

Unoptimized solution:


Optimized solution (Area 10):

XOR Color Table:


This is like level 9 (AND) except for the fact that two white inputs have to cancel themselves out. This sounds like a perfect task for some switches.

Unoptimized solution:


Optimized solution (Area 15):

NAND Color Table


This level can be approached on basis of the solution for level 9 (AND). But the output has to be reversed from that level.

Unoptimized solution:


Optimized solution (Area 12):

NOR Color Table:


The solution accepts a white output only in case both inputs are black. Sounds like a task for one of both available switch types.

Unoptimized solution:


Optimized solution (Area 15):

XNOR Color Table:


If I'm not mistaken you need at least three switches for a valid solution, and both types of switches must be used.

Unoptimzed solution:


Optimized solution (Area 18):

Finally, Accumulators!

Unoptimized solution:


Optimized solution (Area 10):

For this solution, the Input 2 sequence serves as a mask: copy a cell from Input 1 to Output 1 only in case the corresponding cell in Input 2 is blue.

The difficulty of this level is to make sure that a cell in Input 2 has only the primary color blue, i.e. not magenta (blue & red) or cyan (blue & green). You cannot use Filters here because they cancel out some colors. So it is pretty obvious that you have to work with Dichroic Mirrors. However, the blue Dichroic Mirror also reflects blue in case of magenta or cyan. Could a switch be the solution?

Unoptimized solution:


Optimized solution (Area 15):

The way I approached this is by looking only at the three primary colors because each of the eight possible inputs and outputs consists exclusively of these three primary colors. Once you figure out which primary colors are contained in the input you can simply reverse each one of them and you will get the valid output.

Unoptimized solution:


Optimized solution (Area 28):

To solve this you need to separate the primary color channels of the input cell and write them into the corresponding output only if there is exclusively ONE primary color channel in the input cell. Didn't I use a technique to do that a couple of levels before?

Unoptimized solution:


Optimized solution (Area 28):

This one is the hardest level so far and, compared to level 19 which has sort of the same basic goal, requires a surprisingly complex solution!

Still the basic approach of what you need to check is pretty simple as illustrated in the following table:


Unoptimized solution:


Optimization hint: It is possible to test for one secondary color and assign it to the appropriate output in an area of 3x4 squares. You may have to send two beams into this area though.

Optimized solution (Area 50):

This level can only be solved with the help of an accumulator.

Unoptimized solution:


Optimization hint:Note that the input sequence has no black cells?

Optimized solution (Area 15):

My basic thinking for this one was that once I get a white beam from the light source in steps of threes only, it would be pretty simple to pass that beam through Input 1, Input 2, and Input 3, sequentially.

Unoptimized solution:


Optimization hint:The unoptimized solution only uses so much space because I did not rearrange the input and output modules. If you arrange them appropriately you do not need more than an area of 3x9 squares.

Optimized solution (Area 27):

Obviously, you need accumulators to skip output for eight iterations after eight iterations.

Unoptimized solution:


Optimized solution (Area 21):

This one should be pretty simple after Level 23 (Skip Row).

Unoptimized solution:


Optimized solution (Area 21):

This puzzle is challenging in itself, optimization is likely to only succeed if you throw your general approach overboard and think outside of the box!

First off, you obviously need to store the eight cells of each odd row in accumulators and then somehow compare the color channels of current even row cells with the stored cells.

On top of that you need to switch the output every eight iterations between (i) Input 2 and (ii) combination of Input 2 and stored cells.

Things are not made easier by the fact that the odd rows you store contain black cells which means that you cannot use them to switch the output.

Having said that there is a way to work around all these obstacles.

Unoptimized solution:


Optimization hint:If you approach this level with the above considerations the area will likely cover double that which the Optimization Challenge allows for. This is basically the first hint for the optimization challenge. I'll say it again: Think outside the box in order to get the common color channels in odd and even rows and you'll get a very clean solution to this one!!!

Further optimization hint:One possible way to get get common color channels of two signals is an AND operation.

Optimized solution (Area 42):

Pretty simple basic approach: If one of the inputs contains a red channel, block green and blue channels, and if one of the inputs contains a green channel block the blue channel.

Unoptimized solution:


Optimization hint:The rules say nothing about running the above checks separately for each input beam!

Optimized solution (Area 20):

Here you need to use accumulators and check whether the current input cell together with the last two input cells contain the required red-green-red sequence. If so direct a white cell into the output in the next iteration.

Unoptimized solution:


Optimization hint:Have you used Double Sided Mirrors before?

Optimized solution (Area 24):

For this one I'll only provide the following table of RGB colors:


Unoptimized solution:


Optimized solution (Area 28):

This level basically requires the opposite transformation to level 28. If you are lost check the RGB table I provided for level 28 first!

My basic approach was to only direct the first, fourth, seventh, and so on source cell into the color check where I checked step-by-step if this cell contains a red channel (-> white cell to output), a green channel (-> white cell to output), and a blue cell (-> white cell to output).

Unoptimized solution:


Optimized solution (Area 40):

As to the rules of this level, it should first of all be clarified that only the first cell in row 2 and the last cell in row 8 only require two input cells of the sequence to be merged. Basically, the first output cell in each even row also has to merge the last input cell of the previous even row if available, and the last output cell in each even row also has to merge the first input cell of the next even row if availabe.

I approached solving this one by use of two separate accumulator sections:

• One that controls the output switch between odd row cells and even row cells.
  
• One that accumulates the cells of Input 1 for combined output in even rows.

This solution approach can also be arranged in a way that is space efficient enough to beat the Optimizatioin Challenge.

(Barely) Unoptimized solution:


Optimized solution (Area 56):

In case the rules are not clear enough:

• For every odd cell number in the entire sequence the input cell has to be copied directly to the output.
  
• For every even cell number in the entire sequence the color of the previous odd input cell has to be changed to the next primary color and the resulting color has to be written to the output.

Unoptimized solution:


Optimized solution (Area 30):

This level is somewhat weird: It is the only level where changing a color cell to its complementary color is explicitely requested. However, using the Complementary module is specifically impeded by the fixed positions of the two blocks and Input 1!

Nonetheless, I think the most efficient way to solve this is by way of using the Complementary. Note that, while the input sequence is different every time you enter this level, the first input cell is always white. It should also be noted that the last input cell is always black which is a problem because the Complementary does not change no input to white!

If you want to use the Complementary you have to preserve the white input cell during the entire sequence so that you can send it into the control slot of the Complementary in each iteration.

Unoptimized solution:


Optimized solution (Area 36):

This level was a real head scratcher for me and I only solved it once I had already gotten to level 41. Only when I looked at this from a different angle I was able to come up with a solutionn tactic which, in the end, did not only work but also solved this in an area of just 120 squares.

However, for an unoptimized solution I took the "easy" approach of dealing with each color change separately, i.e. checking the input cell in seven individual tests for its color and on the basis of the result sending the approriate next color to the output. The area covered is still below 200 so I'm sorry for not being able to give a "real" unoptimized solution:



But there is sufficient space for you to try and optimize the area for this level. My original approach was to look at this level as a challenge to program a binary increment as indicated by the following table which works with three bits counting from left to right:


As you can see, you basically just need to decode the binary value of the input cell and increase it by one before you send it to the output. A simple rule to achieve a binary increment is by flipping all bits up until and including the first 0 (in the above example that would be from left to right).

When trying to build this algorithm I suggest you experiment first with only two bits, i.e. black, red, green, and yellow. Once you achieve this you can simply copy the algorithm for flipping the second
bit to the third bit, at least that's what I did.

The following conditions for that I provide spoiler-hidden so you can first try and figure them out yourself:

1. For each input cell the red channel has to be flipped from 0 to 1 or from 1 to 0.
   
2. If the red channel of the input cell is 1 the green channel has to be flipped from 0 to 1 or from 1 to zero.
   
3. If the red channel and the green channel of the input cell are both 1 the blue channel needs to be flipped from 0 to 1 or from 1 to 0.
   
4. All channels of the input cell that are unaffected by the abovementioned conditions have to be passed along unchanged to the output.

Upon maximum optimization this solution has an area of only 72. However, it may be a bit difficult to decode ;)

Optimized solution (Area 72):

The easiest way to solve this level is by creating two separate accumulator sections. One of them counts nine steps, the other one counts seven steps. This way you can block the inputs from Input 1 and Input 2 each for the appropriate amounts of time. There really isn't much more to it except the little detail that the last cell will get an input from both Input 1 and Input 2 if you only apply these two counters.

Unfortunately, I do not know how to expand the original solution I found with this approach without adding unnecessary space. And that solution has an area of exactly 110 squares. However, you can try to minimize that area to 48 or below if you're up for a challenge.

Optimized solution (Area 110):


Further optimization hints:
1. If you want to go below a 90 area you have to find a totally different approach for this level.
2. Try and find a way to separate (i) blocking the path from the light source to the inputs, and (ii) the iterations of 7 and 9 steps.
3. Work exclusively with the first white cell of the light source for the entire rest of the level.

Further Optimized solution (Area 48):

At this stage of the game, you should not have too many diffculties with this level. You basically need a four-step counter that simply switches the input cells from Input 1 and Input 2 between Output 1 and Output 2.

Unoptimized solution:
Sorry, but I simply do not know how to fill up the board meaningfully with 120 squares given the basic approach I used for this.

Optimized solution (Area: 48):

This level was the last level I solved because I just could not figure out how to do this.

Finally, it became clear to me that I simply need to create a counter of eight steps that is equipped with only one cell at the start of the sequence and that adds one cell in every loop. Once this is achieved, the rest is simple blocking the path from input to output.

Unoptimized solution:


Optimized solution (Area 35):

I originally solved this with the help of 118 accumulators ... and then I found a much cheaper solution that only needs 64 accumulators and originally fit the optimization challenge. However, the challenge has been adjusted to require the above values, particularly the cost part has been added! So the optimized solution became the unoptimized solution :)

Unoptimized solution:


Optimized solution (Area 153 & Cost 2656):

There are two basic approaches to solving this level:

• Separate the input cell into its components right at the beginning and delay the transition of green and blue if approriate.
  
• Pass the input cell through a series of tests for red, green, and blue step by step.

The method first mentioned is easier to create but requires a significantly bigger area. I only came up with that approach in looking for an unoptimized solution and and it just barely fails at the challenge.

Unoptimized solution:


My original approach to solving this level was using the following algorithm:

1. Red Test
   
   • If the input cell has no red channel, send all other channels to the Green Test in the same step.
     
   • If the input cell has a red channel three steps are required:
     
     • Write the red channel into the current output cell.
       
     • Carry remaining green and blue channels to the Green Test in the next step.
       
     • If at least one of the remaining green and blue channels is active block the next cell in the sequence from being sent into the Red Test.
2. Green Test
   
   • If the input cell has no green channel, send all other channels to the Blue Test in the same step.
     
   • If the input cell has a green channel three steps are required:
     
     • Write the green channel into the current output cell.
       
     • Carry remaining blue channels to the Blue Test in the next step.
       
     • If the remaining blue channel is active block the next cell in the sequence from being sent into the Red Test.
3. Blue Test
   
   • If the input cell has a blue channel write it into the current output cell.

As you can see, once you finalize work on the red test you can simply copy it for the green test!

Optimzed solution (Area 72):

The solution I found is difficult to explain. Obviously you need to store the first four cells in accumulators and in the next four steps, through an elaborate maze of mirrors, splitters and switches, direct them step by step from the accumulators to the output in the opposite order while making sure that the input is blocked from sending to the output and into the accumulators. All in all, I needed seven accumulators to achieve this. However, if you are willing to use more accumulators you can reduce the solution to smaller area.

Unoptimized solution:
Sorry, I really tried to find a sensible solution that requires an area bigger than 180 but I could only come up with 128 max ... and I tried three different approaches by now. Therefore, I'll give a couple of further pointers on how you can achieve the intended output:

• First off, you need at least seven accumulators to store the input cells.
  
• In step 5 of 8 sequence steps you need to direct the signal from the 1st accumulator to the output.
  
• In step 6 of 8 sequence steps you need to direct the signal from the 3rd accumulator to the output.
  
• In step 7 of 8 sequence steps you need to direct the signal from the 5th accumulator to the output.
  
• In step 8 of 8 sequence steps you need to direct the signal from the 7th accumulator to the output.
  
• Make sure to block the transmission path from the input component to the output when there is an accumulator input.

Optimized solution (Area 81):


Further optimized solution with a different approach to the level (Area 77):

For all of you struggling with the rules (as did I), here's what you need to do in a table:


So in essence the output sequence is the binary addition of the two input sequences. However, note that you have to merge three input signals into one output signal. The easiest and cheapest way to accomplish this should be with two successive XOR operations. Think of it as if you are adding three numbers: you would add two of them first and then add the third one in a second step. The first XOR operation merges any two signals into one, and that result is then merged with the remaining signal to the output signal by the second XOR operation. Whether there is something to carry forward to the next sequence step is a different matter but also not really difficult to implement with a Switch Type 1.

The way I solved this is with the following algorithm:

1. Check if both input cells contain white and, if so, send white to an accumulator.
   
2. Then apply an XOR operation on both inputs, and send the result to the next algorithm step.
   
3. Check if both the accumulator and the result from the XOR operation contain white and, if so, send white to the accumulator.
   
4. Then apply an XOR operation on both the accumulator signal and the result from the XOR operation, and send the result to the output.

Unoptimized solution:


Optimized solution (Area 44):

For all of you struggling with the rules (as did I), here's what you need to do in a table:


So in essence the output sequence is the binary subtraction of the Input 2 sequence from the Input 1 sequence. Contrary to the solution in level 40, you have to pay close attention to the order of the operations because the accumulator must be added to Input 2 first. Only then can you subtract the result from the Input 1 signal. One iteration step therefore looks like this:
Nonetheless, like in level 40 each of the two operations is basically an XOR operation. So the solution of level 40 is a good starting point for level 41. However, the paths of the inputs and the accumulator have to be rearranged to comply with the order of operations, and the test when to send a signal to the accumulator in the subtraction step has to be changed so that it only receives a signal when white is subtracted from black.

It follows that there are three things you need to take care of in one sequence step:

• XOR the Input 2 signal and the accumulator signal first, then XOR the resulting signal with the Input 1 signal and send the result to the output.
  
• Send white to the accumulator if both the Input 2 signal and the accumulator signal are white.
  
• Send white to the accumulator if the Input 1 signal is black and just one of the signals from Input 2 and the accumulator is white.

Unoptimized solution:


Optimized solution (Area 55):

Ok, this one I approached the following way:

The usual switching solutions do not work here because you need to switch inputs on unforeseeable sequence steps for an unknown amount of sequence steps. In other words, the occurence of three cells of the same color is a singular event which can not switch the beam from the light source for an unknown amount of steps. So you have to approach the switching of inputs in a different way.

If you cannot switch the beam emitted by the light source between inputs, the easiest way to solve this should be to create an independent light source for each input. You only need an accumulator and some mirrors/splitters for each of those independent light sources.I'm talking about using only the first white cell from the light source and directing it into an endless loop. The entire solution is powered only by this one white cell that is reproduced in each step of the sequence. On the circular way from the accumulator into the accumulator, a Beam Splitter can be used to "power" the currently active input and the switch test.

This approach means that you not only have to create the same independent light source for each input but also the same structure of directing the color of the currently active input to the output and, potentially, of checking for three consecutive same-colored cells. Once this structure is working for one input it can easily be copied for the other two inputs. So start experimenting only with the red cells on Input 1.

The switching between inputs is accomplished by directing the beam from one independent light source to the next independent light source, thereby powering the next input and color check.All you need to accomplish this is a Switch Type 1 and a Switch Type 2 and a Beam Splitter. Given that each input has the same structure it should be quite simple to direct the white cell of the accumulator out of one loop into the next loop.

Now, for the test of three consecutive cells with the same color you only needa Filter, some accumulators, and two Type 1 Switches arranged with some Mirrors and Beam Splitters.

And that's basically what you can see down below.

Unoptimized solution:


This blueprint has plenty of room for optimization so it should not be difficult to minimize the area by 11 squares. Searching for a reasonable solution with an area bigger than 169 I actually got a bit sidetracked and found several ways to minimize the required area by a third.

Optimized solution with shared test for three same-colored cells (Area 121):


Optimized solution with separate tests for three same colored cells (Area 120):