This guide makes the assumption that you have read the manual, or at least know a little bit about assembly and have played a few levels. I will upload images of the whole codes, however, mine might or might not be optimized or to your liking. Use at your own leisure.

If you want to contribute, I only need a screenshot. I will put your code in as soon as I can and will add you to the list. I might or might not test the codes, if any of them prove useless, just leave a comment below and I'll take a look.

Special Thanks to:
Groove
michael_kuerbis
Daverball

Thanks to VackaeP for pointing out the first one was not actually optimized.
I'll include his solution here.
Thanks to Kevio42, a better solution can be found here.
As the name suggests, this needs parallelization to work. Here's the code:

In this first achievement (not counting the manual achievement of course) you just have to keep the loop busy. We do this by taking the input hostage. In place of ANY, write whatever direction you want to.
Here's the code:
Sent by snp123, this code has over 117 million cycles.
This is for just ONE NODE.
He says it could go well over 500 million with all nodes active but no one had the courage to delve that deep :O

This solution is here thanks to Groove. Here's the solution:
Another solution can be found herethanks to Raddox.
One more solution is here thanks to Prism.
Another solution is here thanks to snp123.

My thanks to Daverball who sent this solution and he says:
"It's certainly not the cleanest solution, but it does work, it uses 6 of the nodes as the 6 memory cells necessary to store the entire sequence. The solution gets mainly complicated and messy because some of the nodes that make up the stack are also being used to forward values from the input to the output node.

I first tried to make the stack using just the 3 nodes on the right-most column, since each node has storage for two values potentially, but I couldn't fit the stack logic for two memory cells into just one node."
Here's the solution:
We now have a fewer nodes version thanks to Dopple, you can find it here.

Also a 4 node solution can be found here thanks to grudgekeyper:

Thanks to michael_kuerbis for this solution.
Minor spoilers ahead:
Make a machine execute the undocumented opcode HCF.
Pretty straightforward, just type in HCF in one of your codes and burn it all down!
Just kidding, this won't burn anything down, your saves are safe.

We reach this one by using JRO and a few number tricks. We change the [-2, 2] inputs into [1, 9] and use JRO with ACC, essentially making a switch case. Here's the code:
Another code can be found herethanks to Raddox.
Thanks to inspector, another way to go about the first solution can be found here.
Another solution can be found here, sent by snp123.

If you missed the manual, or just skipped it and tried to understand the game without it (which is pretty hard), you can get this achievement by simply pressing escape, and choosing TIS-100 manual from the menu. As this achievement is pretty easy, it will be at the bottom.

Secret level guide thanks to michael_kuerbis.
WARNING! Spoilers Follow:
How to get there:
Hint 1: Study the highlighted text in the manual.
Hint 2: Which terminal command (not assembly instruction) seems useless?
Hint 3: What does the eagle do?
Answer: On the level selection screen, hit F2 and click on the eagle.
How to solve:
Read a sequence from IN, it is terminated with -1. Clamp each value to [0, 1, 2]. Write the clamped value to OUT.R. Count the length of a clamped sequence where consecutive values are the same. When such a sequence end, write its length and the sequence value to OUT.E. 2222 mean 4, 2, 000 mean 3, 0.
Solution image.
Again, thanks to michael_kuerbis for searching for a solution and optimizing it.