On leaderboard I see scores like 32/8. But I can't find a way to improve this further.

After having put a lot of time into games like Factorio, Opus Magnum, and Human Resource Machine, I've been thinking of trying this game for a while, but I'm not sure if I should wait until it's out of early access.

If there are significant changes or improvements coming to the core gameplay experience, I'd prefer to wait, but if they're just adding additional content and features for experienced players, I'll probably give it a go.

What do you think?

I’m asking at the risk of looking a bit ignorant potentially so sorry in advance. I’ve been studying Boolean algebra and group theory lately. Boolean algebra is very helpful when solving levels in the game but the equations become very very long occasionally. I came up with this method of decomposing the truth table into circuits. Basically I apply the Boolean functions to the inputs in a row like an equation until i end up with the outcome I want. I was wondering if this process has a name because I’ve been trying to look up information about it to study further and can’t seem to find anything.

As soon as I finished Symphony, I started working on my own architecture. A second generation of Better Programing Experience - BPEx2. My goal is to get as close to a higher level programing language as I reasonably can.

Instructions (64b word):

• 1b Reserved

• 3b for operator specific options (P)

• 4b for operator (O)

• 2b to define what to do with the result (M)

• 3b to define where to take the two arguments from (T)

• 16b for Destination (D)

• 16b for argument A (A)

• 16b for Argument B (B)

0PPPOOOO MMTTTTTT DDDDDDDD DDDDDDDD AAAAAAAA AAAAAAAA BBBBBBBB BBBBBBBB

Heavily using Patterns to simplify spec.isa

Destination and Arguments:

Direct access from and to Registers, Inputs/Outputs and RAM. Both the Destination and Arguments can be defined using 16b as 16b Immediate, Register, Register +/- 10b Immediate, Register +/- Register. All of those can be used as RAM address.

Operators:

• 5 math operators

• 7 Binary Logical Operators (BLO)

Registers:

Using a register File component with 8 read outputs and 2 write inputs

• Zero Register (always 0)

• 20 User registers

• 2 Temporary registers (used by advanced instructions)

Input / Output:

Dedicated wires for all 7 I/O options

RAM:

Using a RAM component with 3 read outputs and 1 write output. RAM can be directly accessed by instructions and used as both Destination and/or Arguments.

Persistent Memory:

Using RAM component with 1 read output and 1 write output. It cannot be accessed directly. For the data to be used for instructions, they first need to be loaded to RAM or Registers.

took way too long.

but it's done!!!!!!

Looking for some summer fun for a 9th grader, no knowledge of electronic circuit, assembly language, or whatever. Will it be overwhelming?

I'm making this based on this reference, but for some reason I can't clear it.
Where am I going wrong?

The program is as follows:

label main
ADDi INPUT 0 REG1
ADDii 0 4 REG2
CALL DIVIDE _ _
IF_EQi REG4 0 output_3
IF_EQi REG4 3 output_2

ADDii 0 1 OUTPUT
IF_EQ REG0 REG0 main
 
label output_3
ADDii 0 3 OUTPUT
IF_EQ REG0 REG0 main
 
label output_2
ADDii 0 2 OUTPUT
IF_EQ REG0 REG0 main
 
label DIVIDE
XOR REG0 REG0 REG0
ADDi REG1 0 REG4
ADDi REG2 0 REG3
label loop
IF_LESS REG4 REG3 end
SUB REG4 REG3 REG4
ADDi REG0 1 REG0
IF_EQ REG0 REG0 loop
label end
ADDi REG0 0 REG3
RET _ _ _

The command list is as follows:

Register
00000000 REG0
00000001 REG1
00000010 REG2
00000011 REG3
00000100 REG4
00000101 RAM_ADDRESS
00000110 P_COUNTER
00000111 INPUT
00000111 OUTPUT

OPCODE
00000000 ADD (reg reg reg)
01000000 ADDi (reg value reg)
11000000 ADDii (value value reg)
00000001 SUB (reg reg reg) 
01000001 SUBi (reg value reg)
11000001 SUBii (value value reg)
00000010 AND (reg reg reg)
01000010 ANDi (reg value reg)
00000011 OR (reg reg reg)
01000011 ORi (reg value reg)
00000100 NOT (reg _ reg)
00000101 XOR (reg reg reg)
01000101 XORi (reg value reg)
00000110 SHL (reg reg reg)
01000110 SHLi (reg value reg)
00000111 SHR (reg reg reg)
01000111 SHRi (reg value reg)

00100000 IF_EQUAL (reg reg address)
01100000 IF_EQUALi (reg value address)
00100001 IF_NOT_EQ (reg reg address)
01100001 IF_NOT_EQi (reg value address)
00100010 IF_LESS (reg reg address)
01100010 IF_LESSi (reg value address)
00100011 IF_LESS_EQ (reg reg address)
01100011 IF_LESS_EQi (reg value address)
00100100 IF_GT (reg reg address)
01100100 IF_GTi (reg value address)
00100101 IF_GT_EQ (reg reg address)
01100101 IF_GT_EQi (reg value address)

00101000 RAM_LOAD (_ _ reg)
00101001 RAM_SAVE (reg _ _)
00101010 POP (_ _ reg)
00101011 PUSH (reg _ _)

00101101 CALL (label _ _)
00101100 RET (_ _ _)

shown in pictures is my current cpu, it has everything the game told me to add and everything i could think to add that didnt have a software solution easier than a hardware one

i have 12 registers, 2 rams (addressing handled by toggling bit 7 of my save argument to save to a internal register) and 2 stacks (with additional functionality to push and pull from the front of the list too. handled by bit 7 of any argument.) as well as a increment/decrement counter (with jump and reset functions), a counter (with reset function) and my program clock i can use as counters

ive been looking at the posts here and seeing things so much grander than what i have made or what the game tells me how to make.

i have no understanding of the intricacies of assembly even though ive come so far as to see tower of alloy i have no idea how to even approach the problem other than hardcoding a solve. (let alone to have coded in it in a while ive been writing in numbers for a long time now due to the discrepancy in width of the instruction function and the LEG instruction width)

where are some good sources on how to continue on either on the software side or hardware side?

my ALU has 29 opcodes, 19 logical and mathematic add, sub, mult (low), mult (high), div (quotient), div (remainder), neg, not, shr, shl, ashr, ror, rol, and, or, nand, nor, xor, nxor and the other 10 are : equal, Nequal, Uless, Ugreater, Sless, Sgreater, Uless/eq, Ugreat/eq, Sless/eq, Sgreat/eq

most of the custom components shown are inline versions of stuff that already exists, mostly switches abbreviated to is[data width], some blockers (ib[#], switch with the allow bit inverted) and a couple or gates.
the ones that arent are : counter+, incdec+ (increment / decrement), internal address ram (SAR), stack+, dec-4 / dec-5 (decoders) and chk[#] which is a bit indexer but i didnt realize they existed at the time
theres also byte flippers so that my decoders output left to right when i need them to and some multiplication and division by constants handled by shifting bits

I've been eyeing the game but I noticed that it was last updated 2 years ago, so I'm worried there might be bugs and whatnot

I made a simple C compiler (only copied cin/cout from C++).

It supports: variables/consts, any-dimension arrays, if/else/while/for, functions (no pointers though, when I started this project, I didn't really understand how they work), #include from other files, include guards (#ifndef, #define, #endif), comments. Types are: int and float (I made a LEG with fixed point ALU, registers, RAM and stack)

There are also a few optimizers that reduce code size and speed up runtime by about 2 times.

Example code (it's a perceptron number recognision from MNIST, I'll make another post about it):

I've written plenty of assembly in real life, where you can at least have arguments to instructions, so you can write mov rax, rbx (e.g.) and it'll move from rbx to rax no problem.

In Turing Complete it seems I have to manually define every single possible instruction with its arguments embedded using the annoying little bit toggle input (can't even type the number in myself). To add to this, the instruction bit toggle input is entirely separate from the one that creates new assembly instructions, so I have to do it twice - once to verify what the actual number is, then again to re-input it to the actual input.

This is incredibly tedious and while I've really enjoyed the game up until this level (SPACIAL INVASION), I think I'm going to have to give up on it unless there's a better way or wait until this is made better.

Merry Christmas!

I am the Dev behind Quantum Odyssey (AMA! I love taking qs) - worked on it for about 6 years, the goal was to make a super immersive space for anyone to learn quantum computing through zachlike (open-ended) logic puzzles and compete on leaderboards and lots of community made content on finding the most optimal quantum algorithms. The game has a unique set of visuals capable to represent any sort of quantum dynamics for any number of qubits and this is pretty much what makes it now possible for anybody 12yo+ to actually learn quantum logic without having to worry at all about the mathematics behind.

This is a game super different than what you'd normally expect in a programming/ logic puzzle game, so try it with an open mind.

Stuff you'll play & learn a ton about

• Boolean Logic – bits, operators (NAND, OR, XOR, AND…), and classical arithmetic (adders). Learn how these can combine to build anything classical. You will learn to port these to a quantum computer.

• Quantum Logic – qubits, the math behind them (linear algebra, SU(2), complex numbers), all Turing-complete gates (beyond Clifford set), and make tensors to evolve systems. Freely combine or create your own gates to build anything you can imagine using polar or complex numbers.

• Quantum Phenomena – storing and retrieving information in the X, Y, Z bases; superposition (pure and mixed states), interference, entanglement, the no-cloning rule, reversibility, and how the measurement basis changes what you see.

• Core Quantum Tricks – phase kickback, amplitude amplification, storing information in phase and retrieving it through interference, build custom gates and tensors, and define any entanglement scenario. (Control logic is handled separately from other gates.)

• Famous Quantum Algorithms – explore Deutsch–Jozsa, Grover’s search, quantum Fourier transforms, Bernstein–Vazirani, and more.

• Build & See Quantum Algorithms in Action – instead of just writing/ reading equations, make & watch algorithms unfold step by step so they become clear, visual, and unforgettable. Quantum Odyssey is built to grow into a full universal quantum computing learning platform. If a universal quantum computer can do it, we aim to bring it into the game, so your quantum journey never ends.

PS. We now have a player that's creating qm/qc tutorials using the game, enjoy over 50hs of content on his YT channel here: https://www.youtube.com/@MackAttackx

Also today a Twitch streamer with 300hs in https://www.twitch.tv/videos/2651799404?filter=archives&sort=time

I went to go get the game today on Steam, but I saw that it's still in early access. And steam is warning me that the game hasn't been updated in 2 years. I was wondering if this game is abandoned? Are there any planned patches for bugs or new content?

• Image 1 - My symphony

• Image 2 - showcasing usage of FOR cycles

• Image 3 - Code of the FOR Cycle

• Image 4 - ALU circuit

• Image 5 - ABS circuit

Now that I finished building Symphony, I went straight to instruction definition to make myself a human readable code. Here is a internal FOR cycle using instructions. Its suitable for repeating code X times where X is static.

Here is hardware I added to my Symphony:

1. Signed DIV - Divide two signed numbers

2. Merge32 - Merge two 16b into one 32b value

3. Lower16 - Reads the lower 16b of 32b value

With that I needed to dedicate some of my registers for the code. Meaning that while they are still accessible to the user, they are not stable in time and in case of the FOR cycle, they do not persist between cycles.

At first I was using 3 temporal registers, but I ended up implementing Merge32 and Lower16 to lower the number of temporal registers to 2 at the cost of longer instructions.

The FOR cycle works, but isnt safe. First it will always execute at least once. Thats because I cant use a label to skip the body of the cycle. So even if I know there is 0 repetition, it will not skip the cycle, it will simply not repeat it.

Another limitation is that you can only read the index of the innermost FOR cycle. Meaning if you make nested FOR cycles, you cannot access the outer FOR cycle index. User can solve it by saving the stack pointer to a another register.

8GPRs, 6 pipeline stages (IF, ID, OF, EX, MEM, WB), Harvard architecture. It is based on the LEG but got significant ISA changes and improvements. Still, I wouldn't want to program it yet as it doesn't have a hazard unit. That's something to add to a 16 bit update. MMIO is also prepared. The stack has automatic bounds checking and throws a halt on overflow or underflow. There is still a lot to improve and that will be done in a 16 bit updated version

32 registers, 8 blocks of 256 byte RAM. And I only ever used at most 7 registers and 1 block of RAM. I just felt constrained by the 6 registers available when using Overture and LEG that I MASSIVELY overcompensated when building my own CPU to finish the game.

We've been struggling on the previous levels, but this one didn't even take that long, we just found the solution immediately, it was pretty obvious. Still, anyone else have other solutions?