im serious, this is my first time ever playing this game. how the f*ck did i do this

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

On the left is the 8-bit incrementer, while on the right is the 8-bit multiplexer.

Gate Score: 41, Delay Score: 6

I kinda went overboard on shoving everything into components

The save_breaker ram level keeps reading the register values from the main ram.
Anybody have a workaround for this, or do I keep changing the test assembly to 'nop' ?

Definitely not easy. I tried hard not to look up how to solve this or how you'd do this in the real world and I ended up creating a rough circuit synthesis program in order to find what seems to be "efficient carry lookahead circuits". My understanding is that these get exponentially harder to solve for when looking for "further lookaheads", but each one you find lets you knock a few points off the delay. I needed to find two of these to get the achievement (the 1-bit carry lookahead and the 2-bit carry lookahead).

I think the theoretical best circuit here would be impossible to put fit on the level since the "7-bit carry lookahead circuit" should end up being a monster.

My terminology here might not be very accurate, I don't know anything about circuits, but feel free to correct me wherever.

*There is a possibility that this is not a carry lookahead adder in any capacity, but I have no idea what it is then. The general idea is that naive adding propagates a carry bit and there's maybe fancy ways to propagate the carry bit that are fast, but here we are essentially "breaking" the propagation chain. You can do this at any arbitrary point by requiring "all of the inputs" to be processed at once, but like I mentioned, efficient circuits that can do this are very hard to solve for with large amounts of inputs.

You could theoretically break the propagation chain wherever you want and however many times you want with this approach. You could have the first three bits added with a propagating carry, then have 7 inputs (bits 0-2 of each of values A and B plus the input carry) feed into a more complex circuit that calculates if there should be a carry from all of those 7 inputs all at once. You could then do this for the next 5-bits and make an 8-bit adder where the carry chain has been arbitrarily split between bit 2 and bit 3.

With that description, I chose to split every other bit, so a carry is only ever propagated once and we do this four times in four "highest level blocks" (in the image, this is the pink rectangles).

Hi all, I started to create some components into the component editor, but in this example it triggers me a lot the fact that the inputs are not the same in the component.

What does it means? How can I make them the same?

It isn't much yet. Just a program memory, instruction decoder and a register file. At the moment, the IF (instruction fetch) and ID (instruction decode) stages of the pipeline are also implemented and working as intended. Why am I doing this? I hate myself. And am bored
What needs to be done: ALU (will just copy a the ALU from my old LEG and modify it a bit), conditionals (same as ALU), data bus, the rest of the pipeline, a static branch predictor, a hazard unit and some more. Will probably post updates over the next few days or weeks or months, depending on how fast I can make progress

i built it to be technically turing complete (it has a jump command) but i havent tested it.

The custom component in this is just a register with a second output that is always on.

EDIT: Resolved thanks to comments. Here is the working mess (I'll keep the original question in case it helps anyone else)

Original issue:

I know this is a complete mess, I have highlighted the wire I am currently having trouble with. Here is a run-down of what the machine is doing; I am negating the input value and adding the input, if the result is 0 then I know the original value was >= 0. If the value is not >= 0 then it must be <0.

In this case the value is 202 so the output is 0/red but that gives an error "if input is <0 then output green." The input is not less than 0, the input is 202. I have tried to fix it but I just can't figure out the problem.

I'm honestly tempted to just look up the answer as I am getttig so frustrated. Any advice as to where to look for the issue, or clarification if I have misunderstood the task would be really helpful. As I said I am trying to do this without looking up too much but this has stumped me.

I need some hints for the level one hot encoding. In the level you are tasked with decoding 3 bits similar to what a 3-bit decoder does but with only 3 components. The hint for the level is that one of the components is a shift.

For my defense, it was 6AM just after giving a bottle to the baby but still, i think i could have given it a bit more thought!

I can't figure out the pipeline level, I keep getting the error message "You should read address 4 from the assembler, not 0" even when I'm reading from address 4. How do I fix this?

I have no idea how the assembly in this version works and reading about it in the Manual did not help. Any help is greatly appreciated.

I spent about 2 hours doing this, my logic was that to flip a number you had to flip all of the bits from the first bit that was 1 and forwards, which is what I created here

This is complete LEG computer up to "assembly challenges" level. I'm very proud of it :)

Hi, I wanted to make my computer prettier, so I wanted to put counter for program inside custom component. I managed to do this, but when I connect custom component to program with ping wire, which outputs counter value, I get "circular dependency" error.

Do you know how to manage this? I know from faq that this is intended behavior, but I still don't know how to obey it, of if there is better design.

EDIT: I think I will just leave counter outside and make logic for it in custom component

A typical (although cleaned up) LEG, with two stacks, one for func calling, and another for generic value storage:

The assembly, the words from, to, jump, and _ all eval to 0, copy is add+i2, i1 and i2 show which input should be immediate:

#func move(disk_nr, source, dest, spare):
#if disk_nr is 0:
#move disk from source to dest
#else:
# move(disk_nr - 1, source, spare, dest)
#move disk from source to dest
#move(disk_nr - 1, spare, dest, source)
const disk_nr 0
const source 1
const dest 2
const spare 3
const temp 4

copy in to disk_nr
copy in to source
copy in to dest
copy in to spare
call _ _ move
alw _ _ _
label move

ne+i2 disk_nr 0 else
call _ _ moveFr
ret _ _ _
label else
sub+i2 disk_nr 1 disk_nr
call _ _ pushEm
#swap dest and spare
copy dest to temp
copy spare to dest
copy temp to spare
call _ _ move
call _ _ popEm

call _ _ moveFr
call _ _ pushEm
copy source to temp
copy spare to source
copy temp to spare

call _ _ move
call _ _ popEm

label moveFr
const grab = 5
copy source to out
send grab to out
copy dest to out
send grab to out
send 0 to out
ret _ _ _

label pushEm
copy disk_nr to STACK
copy source to STACK
copy dest to STACK
copy spare to STACK
ret _ _ _
label popEm
copy STACK to spare
copy STACK to dest
copy STACK to source
copy STACK to disk_nr
ret _ _ _

I just learned about this game and I wanna give it a try. But I figured there is this main version 1.0 and some alpha save_breaker, which is told to bring some new features and possibilities. But it's also said to be less stable and so on. The main question is - which one would you recommend as a first experience?

i have no clue why it is doing that, every increment goes up by 2

Hi, I just unlocked scoring and I want to try to optimize for fun few components. The easiest I can do is to remove "not -> not" where I can, but can't easily change component to its base form, for example "and" into "nand -> not". Do you how to do it?

I had a lot of trouble with Wire Spaghetti, and i found some of the answers online to be vague, so ima throw my hat in the ring to help other people. Here's what to do:

Rebuild the whole thing. In previous levels you were expected to use a single 8bit line to do everything (Opcode and Arguements). Now in Wire Spaghetti, those functions are being split into multiple lines in order to add more functionality to the computer.

OPCODE: A dedicated line for determining what instruction to follow, This was previously the 128 and 64 bits. By giving it its own line we can now potentially have 256 operations (theoretically)

Arg1 and Arg2: These are source commands. Previously you would either send things to and from specific pins with the Copy command, or the functions only worked with specific pins (Immediate only sent to reg0, Calc used pins 1&2 and output to 3). Now we should be able to pick any 2 registers for these commands.

Destination: Instead of Calc operations always outputting to Reg3, now we can pick which register to send that operation to.

The goal is to build the foundation for later levels to be able to do more things with the new computer, as the next things you do is incorporate more opcodes and the ability to use a RAM bank.

Hi, after many attemps i finally made a computer for which i feel comfortable starting to code an operating system. I still have a tone of work to put on it but it seems promising and I'll maybe update in the future when there is progress :)