Logic World Wiki - User contributions [en]

Multiplexer

2025-10-18T09:18:24Z

Lawrziepan:

[[File:Multiplexer Diagram.png|300x300px|A diagram of a multiplexer|alt=A diagram of a multiplexer|thumb]]
[[File:Simpler Multiplexer Circuit.png|alt=A diagram of a simple multiplexer|thumb|376x376px|Example of a simple multiplexer.]]
A multiplexer, sometimes referred to as a MUX, is used to select from input data. A multiplexer is an essential piece of any circuit in Logic World. There are many different ways to build a multiplexer.

== Behavior ==
A multiplexer has at least 2 inputs of any bit size, and a select input that is either:

* A bit array with a length of the number of inputs, and whichever bits are '''ON''', their corresponding inputs get bitwise-ORed to the output.
* A value which corresponds to an input to send directly to the output.

== Uses ==
Multiplexers are very versatile, and can be used for many circuits. Multiplexers are commonly used for:

* Selecting between registers to use in operations in a CPU.
* Indexing memory.

Your First Computer

2025-10-18T09:05:57Z

Lawrziepan: Added a paragraph in the example program section describing the assembly notation used in the example

{{stub}}

== Introduction ==
This guide is for anyone who is interested in learning how computers work, and wants to learn by building a computer for themselves, but doesn't know where to start.

This guide assumes the reader has a basic understanding of Logic Worlds [[Building mechanic|building mechanics]], and has some experience building some of the more intermediate components, such as [[Full Adder|adders]], [[Random-access memory|memory]], and [[decoder|decoders]]. As well as at least some understanding of the [[wikipedia:Binary_number|binary numbers system]].

The first part of this guide will go over the hardware of a very basic computer system. This guide will not be covering things like text and image processing, internet browsing, operating systems, file systems, windows and graphical user interfaces and other systems generally associated with personal computers. These systems are all built using software, and covering them, as well as software in general, is an entire subject unto itself. This guide will only be focusing on creating hardware that can execute software. Furthermore, this guide will only be focusing on ''core'' hardware, the bare minimum required to run software. This guide will not be covering peripheral hardware such as screens, graphics processor units, storage devices, co-processors, or multi-core setups. Nor will this guide be covering the topic of source code compilation. These are all topics that require their own study and as such are outside the scope of this guide.

The second part of this guide will be covering the process of designing your computer. It will bring up key details you should consider when planning your computer build, as well as providing a basic layout that you can use if you don't want to design everything from scratch yourself.

The third part will of this guide will cover building your computer.

== Hardware Theory ==
All computers, regardless of complexity, need at least these 4 components. Program memory typically made using [[ROM|read-only memory]], an [[Arithmetic logic unit|ALU]], working memory typically made using individual [[Register|registers]] and [[random-access memory]], and a [[Control Unit|control unit]].
[[File:Computer_Structure_diagram.png|right|thumb|300x300px|The structure of the computer in this article]]
Program memory is where the program to be executed is stored. It takes the form of a list of binary numbers called machine code, and each number is called an instruction or opcode. The computer will step through this list one instruction at a time, grabbing each instruction, interpreting it, and performing an action corresponding to that instruction. This process is referred to as the fetch-decode-execute cycle.

Actions that a computer can perform can vary greatly, but two of the most common actions are moving data around, and performing operations using data.

The ALU is what allows a computer to perform these operations, and working memory is where the data being operated on is stored.

Moving data around may seem pointless at first, but often ALU's don't have direct access to working memory, but instead must use whatever is stored in more local registers. Data must therefore be juggled between working memory and registers in order to give the ALU access to the entire dataset. It's also useful for organizing data into larger data structures.

While it might be hard to wrap your head around this at first, everything that computers do can mostly be reduced to these two operations: moving data around, and operating on data. How these two operations can be structured to do things like browse the internet or play games requires a study of software, and is thus outside the scope of this article. But under the hood, millions of these operations are happening at a rate of billions a second, and it's this size and speed that allows computers to perform much more complicated tasks.
[[File:A schematic view of a very basic control unit.png|thumb|A lookup table takes in as its inputs the content of a step counter and an instruction register, and produces as its outputs various read, write, and function signals. On the clocks rising edge, the step counter is incremented. The lookup table immediately updates its outputs, reading from various components and sending function signals. The write signals do not get sent out though until the falling edge of the clock. As this diagram suggests, the lookup table is in control of its own instruction register, and has the ability to reset the step counter. The instruction register is updated at the beginning of every instruction sequence, and the step counter is reset at the end of every instruction sequence.]]
Coordinating these instruction fetches, data moves, and ALU operations is the control unit. It's job is to decode the instruction fetched from program memory and decide what control signals to send out and when.

While this module can get very complicated, the simplest control unit consists of a [[Lookup Table|lookup table]] that takes the current instruction and the value of a [[counter]] as a combined input, and produces all the read, write, and function signals the computer needs as an output. A clock is used to increment the counter, and to a pulse for the write signals through the use of a [[Edge Detection|falling edge detector]], while the table is configured to read from program memory and write to an instruction register when the counter is 0, then increment an instruction pointer register when the counter is 1. From there, the table can be configured to do different things depending on the value of the instruction register. The counter register is reset when the instruction is complete, and the fetch-decode-execute cycle repeats.

On top of being able to move data around and perform operations, there is a third common type of action a computer can perform called a control flow instruction. These consist of instructions like jumping, conditional branching, calling and returning, and software interrupts. Though we'll only be focusing on jumping and conditional branching here. These all have one thing in common, and that is to break the linear sequence of the program.

Normally, as part of the fetch-decode-execute cycle, the instruction pointer used to index the program memory is incremented after each instruction fetch. Setting up the next instruction in the list to be executed when the current instruction is complete. By writing a new value to the instruction pointer, we queue up a different section of the program memory, and the first instruction in that section is primed to be executed next.

This is often used to create infinite loops in your program, or finite loops if you use a conditional branch that resumes a normal execution sequence if a condition is met, like two numbers being equal or one being greater than the other.

These three action types are the minimum required to create a [[wikipedia:Turing completeness|turing complete]] computer - a computer that can calculate anything.

== Planning A Computer ==
While you might be inclined to jump head-first into building, computers are complicated things, as the previous section shows. A little bit of forethought is required before you start building in order to help guide your building decisions. Otherwise you will end up with a computer that's too messy to modify, and if it ends up malfunctioning, it'll be too messy to troubleshoot as well. '''Documentation is key'''.

Before you begin, think about what you want this computer to do. What ALU functions do you want it to have? What special instructions or special hardware? You'll also want to consider key details such as the width of your ALU, the width of your working memory and program memory, as well as the size of these memory modules, as this will determine the width of your address bus and indexing registers.

=== Example Computer ===
Since you'll likely not know what to add, this section will provide for you a very basic plan for you to follow.

==== Component Sizing ====
Our computer will be very basic. We'll be using an 8 bit ALU and 8 bit working memory. We can do a lot with 8 bits without needing to make the hardware too big.

We'll also have 256 addresses in our program memory, so an 8 bit address bus and 8 bit indexing register is in order, since 2^8 is 256. The width of the program memory is determined by our computers instruction set.

==== Instruction Set ====
This is the most influential part of planning. This will not only dictate what your computer does, but also how programs will be stored in program memory.

You can design your own instruction set from scratch if you want something more complex. But for our instruction set, we will be adding 4 types of instructions: load immediate, operate, move, and jumping/branching. These will be organized with the prefixes <code>00</code> <code>01</code> <code>10</code> and <code>11</code> respectively.

We will be squeezing our instructions into 8 bits, making our program memory 8 bits wide. With 2 of those bits being used as a prefix, that leaves 6 bits to be used as instruction arguments.

Below is the instruction set we will be using:
{| class="wikitable"
|+
!Name
!Opcode (8 bits)
!Operands
!Description
|-
|Immediate
|00 xxx xxx
|x: The immediate value.
|Puts a value given by x into register 0.
|-
|Add
|01 000___
|
|Adds the values in register 1 and 2, and puts the result in register 3.
|-
|Subtract
|01 001___
|
|Subtracts the value in register 1 from register 2 and puts the result in register 3.
|-
|And
|01 010___
|
|Bit-wise ANDs the values in register 1 and 2, and puts the result in register 3.
|-
|Or
|01 011___
|
|Bit-wise ORs the values in register 1 and 2, and puts the result in register 3.
|-
|XOR
|01 100___
|
|Bit-wise XORs the values in register 1 and 2 and puts the result in register 3.
|-
|Not
|01 101___
|
|Bit-wise NOTs the values in register 1 and 2 and puts the result in register 3.
|-
|Move
|10 xxx yyy
|x: The register to move data from. y: The register to move data to.
|Moves the data from register x into register y.
|-
|Test
|11 000___
|
|Tests the values in register 4 and 5 against each other, putting the result into the flags register.
|-
|Jump zero
|11 001___
|
|Jumps to the instruction in register 6, if the zero flag is {{On}}.
|-
|Jump carry
|11 010___
|
|Jumps to the instruction in register 6, if the carry flag is {{On}}.
|-
|Jump negative
|11 011___
|
|Jumps to the instruction in register 6, if the negative flag is {{On}}.
|-
|Jump equal
|11 100___
|
|Jumps to the instruction in register 6, if the equal flag is {{On}}.
|-
|Jump
|11 101___
|
|Jumps to the instruction in register 6, regardless of an flags.
|}
Notice that most instructions only use 3 of the 6 argument bits. Move immediate uses all 6, allowing the user to load an immediate value of 0-63, and move also uses all 6 to index 2 registers.

==== Registers ====
Since we have 3 bits available to index registers with, our computer will include 8 all-purpose registers.

If you design your own computer, you will need to consider what registers to include, and what will they be used for.

In our case, while all of our registers will be general purpose, meaning you can use them for whatever purpose you like, most of them will be used in a specific way for specific instructions. The registers and their purposes are as follows:

* Register 0 - destination for immediate values
* Register 1 - source of one argument of an operation
* Register 2 - source of the other argument of an operation
* Register 3 - destination of the result of an operation
* Register 4 - source of one argument for a comparison
* Register 5 - source of the other argument for a comparison
* Register 6 - target address for a jump
* Register 7 - general purpose

Note that the instruction pointer and instruction register are separate to these all-purpose registers, so our program will not be able to ''directly'' edit the values in these registers.

Editing of these registers is done by the control unit either during the fetch-decode-execute cycle, or through the use of a jump instruction.

==== Flags ====
If you decide to include conditional branching in your instruction set, you will need to decide what conditions (called flags) you want to check for and how you're going to check them.

In our case, we will have the following 4 flags in our computer:
* Zero flag - This flag will be {{On}} only if the first value from the last test instruction was equal to 0.
* Carry flag - This flag will be {{On}} only if that last add (or subtract) instruction carried/overflowed.
* Negative flag - This flag will be {{On}} only if the first value from the last test instruction was negative (had its most significant bit {{On}}).
* Equal flag - This flag will be {{On}} only if the values from the last test instruction were equal to each other.
We will also be storing the states of these flags in another register called a flag register. Allowing us to capture the state of these flags with one instruction (test) and use the state of these flags in another instruction (jump).

You do not need to store the state of these flags in a register, or perform a test and branch in two separate instructions. You can perform your comparison and use the results immediately, if you want. Doing so will just require a more complex execution sequence, and possibly bigger instructions.

==== Example Program ====
Putting everything together, we can use our instruction set to write a Fibonacci program:
<syntaxhighlight lang="asm">
; Initialise registers
Immediate 0 ; 00 000000
Move 2, 0 ; 10 000 010
Immediate 1 ; 00 000001
Move 1, 0 ; 10 000 001
;
; Main loop
Add ; 01 000 ___
Move 2, 1 ; 10 001 010
Move 1, 3 ; 10 011 001
Immediate 4 ; 00 000100
Move 6, 0 ; 10 000 110
Jump ; 11 101 ___
</syntaxhighlight>Note that in this notation, the instruction name comes first, and subsequent numbers are the operands of the instruction. Instructions such as the ''Move'' instruction have two operands; The first is the destination register, which describes the register to save data to, the other is the source register, which describes the register to load data from. For example, the Move instruction moves the data from the source register, and '''copies''' it to the destination register directly.

Visualizing the process, we can imagine the first instruction being copied into the instruction register, the instruction pointer being incremented, then the value being copied from the instruction register to register 0.

Then the step counter resets, and we begin again, fetching the instruction, incrementing the instruction counter, and moving the content of register 0 to register 2. Reset the step counter and on and on it goes.

This is what our computer ''should'' do when it's complete.

With the planning done, it's now time to move on to building.

==Building the Computer==

=== Mental Preparations ===
Depending on the size and complexity of your computer, the building phase will take several days to several months to complete. This is a full-scale project, so be aware of what you're committing to. Our example computer is simple, and should only take 1-3 days to build depending on your skill and availability. Even still, you will need to mentally prepare yourself if you're not used to working on larger scale projects. Things won't work the first time, you will need to troubleshoot things. You will learn how to do things better as you work on this, give yourself time and space to tear things down and start again if you deem it necessary. Prototypes aren't just small-scale quick-and-dirty versions of the final product that you assemble to get something done now. ''They're practice runs''. They give you the experience needed to determine what works and what doesn't. Be patient. Be willing to try when you don't know what to do, and be willing to throw it all away when you find out it doesn't work.

If you want to know what it takes to carry out a big project, the book "How Big Things Get Done" by Bent Flyvbjerg and Dan Gardner is an invaluable resource. If you read it, you might get the impression that the "correct" way to handle a project like this is to plan every little detail on paper ''before'' you start building.

'''Do not do this!'''

The key idea you should take away from this book is there are some things you just don't think about until you start putting shovels in the ground. Rather than waiting until this moment, instead try putting a spoon in a sandbox first. Do it for real, but on a smaller and cheaper scale.

Nothing is cheaper than a digital sandbox, so Logic World has you covered there. But you'll still have to build something, make your mistakes, learn, and try again. No amount of forethought will ever prepare you for what you've never tried before. Though a bit for forethought is still good practice.

=== Start With The Major Components ===
What components do you know your computer will need? What are their inputs and outputs? What do they do? These are the best places to start when building a computer.

In our example computer, we know our computer needs an 8-bit ALU. We know this ALU will have 6 functions, and we know it will produce 4 flag outputs along with the normal result output. Start by building that. Use [[Socket|sockets]] to make this component modular and to make connecting to other components easier.

We also know this computer will need registers. We'll need to be able to read from and write to these registers, but things like the ALU can also access the state of these registers directly. Building a single register with a data in/out connection, a read, write, and enable input, and a state output will allow us to duplicate the design and build our register file much faster.

We can also reuse this design for other registers like the instruction register.

The flag register, instruction pointer register, and step counter will all need to be custom built, as their behavior differs slightly from our register template. But these too are components who's inputs, outputs, and behaviors are known, and thus can quickly be built in isolation.

'''Test as you go!'''

While it may seem like extra work, you'll want to know that each component is in working order ''before'' you use them in your final build. This isn't strictly necessary, but as a general rule of thumb when building things, it '''''never''''' works right the first time. When it comes time to put everything together, it's better to only have to deal with issues that arise at that level, rather than to run around trying to fix every problem with every component at every level.

Continue to build each of the remaining components in isolation. Moving on to a small portion of [[switch]]-based program memory, and any other major components you might discover you need along the way, such as [[Multiplexer|multiplexers]], [[Decoder|decoders]], and smaller [[Lookup Table|lookup tables]] for controlling things like translating portions of the instruction register into control lines for the general purpose registers or the ALU. ''Save the control lookup table for last!'' As the inputs and outputs of this component will change as you begin to define what components you have and what their inputs/outputs are.

For example, we may discover that it'd be much easier to send a single "register read/write" line to the registers, and then use a decoder to translate bits from the instruction register into enable lines to exact fine control over the individual registers.

Or, we may discover that our lookup table needs to take the state of our flag register into account when performing certain instructions.

These are things we discover as we build, and as such, it's best to leave things like the control unit for last.

=== Putting It All Together ===
Alright! You have all your components built, and they're all working in isolation. Pat yourself on the back.

Now comes time to wire it all together.

Don't be afraid to make a mess. Remember, we haven't actually tested everything together as a whole yet. We have no idea if it will work, or if we overlooked something. Doing our fine-polishing work now if something isn't working properly will just be a waste of time and lead to frustration as we try to squeeze patches into what was once our finest masterpiece.

This is also why we built a small portion of switch-based program memory. The smaller size means we don't invest too much time building a massive component that we just don't need right now, and making it switched based will eliminate the need to reprogram our program memory every time we want to conduct a test.

You can even make multiple copies of your program memory and load different test programs on each one for a more thorough testing procedure.

Lay out all your major components as best as you can. It helps to have them surround a large open area. Use buses to make the connections, and when you feel like everything is ready, load your program memory with a small test program, start the clock and see what happens.

More than likely, things will not work as you had expected. Here's where you're going to need to slow down and troubleshoot things. Use the [[Tick|simulation controls]] to slow down, stop, and step the logic simulator. At this level, most issues you will experience are related to timing. Register inputs are not being held during the duration of a write. The ALU output is not stabilizing in time. Things like that. Though it is also possible that one of your components isn't working as it should, or its behavior needs to change in some way.

This is why we made our components modular. If this does happen, take the defective component out, fix or rebuild it, and plug it back in.

Be sure to run all of your test programs again after making a change. Sometimes changing one thing can fix one issue, and create another. Don't assume previous tests will pass just because they were passing before the change.

=== Refine and Repeat ===
Eventually, after many cycles of testing, troubleshooting, and repairing, your rough prototype will be in working order.

Congratulations! You just built your first computer!

Now comes time to polish things up, if you want to.

You can replace your test program memory modules with a full sized program memory module, if you want. Or you can begin the process of organizing your components.

Compress them down, rearrange them, stack them in a neat package. Just be sure to do it one step at a time, and test after each change.

When you're happy with how things look, you can call it done.

Again, be sure to replace your test program memory modules with a full sized module, and for easy programming/using of your computer, consider adding a programmers interface where you can punch in programs and read the state of your registers.

Whatever you do, make it yours.

Your First Computer

2025-09-20T13:14:20Z

Lawrziepan:

{{stub}}

If you're a new player, you might have already built a few circuits already: an [[Full Adder|adder]], some kind of memory, a [[decoder]]. But getting to the next level where you have a functioning and [https://en.wikipedia.org/wiki/Turing%20completeness turing complete] computer, is incredibly daunting. This article will serve as a guide to how you might build your first computer.

== Planning The Computer ==
[[File:Computer Structure diagram.png|300px|right|thumb|The structure of the computer in this article]]While you might be inclined to jump head first into building, this results in at the very least messy building in Logic World, or a malfunctioning computer. In our computer we are going to first plan and '''document''' the capabilities our computer will have.

To start with the planning section, it helps to think about what this computer we are building is for. This could range from wanting to test out an [[wikipedia:Arithmetic_logic_unit|ALU]] you built, or to perform a specific program you have in mind, e.g. matrix multiplication.

In this guide, our computer will be built as a way to learn each of the different parts of a computer, without any bells or whistles. So, we are going to give the computer the bare minimum.

=== Data Width ===
Data width refers to how many bits the binary numbers in our computer will use. This doesn’t have to be universal across an entire computer; for example, the memory might store in 32 bits, but our ALU only 16. In our computer however, we will use the same data width across our entire computer. While you can definitely go smaller, 8 bits is a good number to make it less complicated while being able to do a lot with our computer, so our data width is going to be 8 bits.

=== The ROM ===
The read only memory in our computer is where we are going to store all of the instructions for our computer. We aren’t looking for anything too big, so to keep with our data width of 8 bits, we will have 2^8 or 256 addresses in our ROM (this only needs to be addressed with 8 bits). And each address will store 8 bits of data for our instructions.

=== Instruction Set ===
This is the most influential part of planning. It’s tough for a beginner to get a feel for how to design an instruction set, and has the most impact on how easy it will be to build your computer. If you wanted to design a more advanced computer, you should design your own instruction set, and see how that influences your computer.

Every instruction has an opcode that tells the computer what instruction you ''actually'' want it to perform. There are roughly 4 main types:

* Data management. This involves moving data from one register to another, loading or saving to memory, or loading an arbitrary value into your registers, etc.
* Operations. These instructions use your ALU to transform data in a specific way, e.g adding two registers or using bitwise logic.
* Conditional logic. This is where jumps come into play. These instructions let you test registers against each other, and change the order the computer executes instructions based on tests.
* Interrupts. While you generally wouldn’t find interrupts in a computer in Logic World, these let you talk to computer hardware, or call specific kernel functions (don’t worry if you don’t understand what that means, it isn’t important for this guide).

With that, this is the instruction set we are going to base our computer around:
{| class="wikitable"
|+
!Name
!Opcode (8 bits)
!Opperands
!Description
|-
|Immediate
|00 xxxxxxxx
|x: The immediate value.
|Puts a value given by x into register 0.
|-
|Add
|01 000___
|
|Adds the values in register 1 and 2, and puts the result in register 3.
|-
|Subtract
|01 001___
|
|Subtracts the value in register 1 from register 2 and puts the result in register 3.
|-
|And
|01 010___
|
|Bit-wise ANDs the values in register 1 and 2, and puts the result in register 3.
|-
|Or
|01 011___
|
|Bit-wise ORs the values in register 1 and 2, and puts the result in register 3.
|-
|XOR
|01 100___
|
|Bit-wise XORs the values in register 1 and 2 and puts the result in register 3.
|-
|Not
|01 101___
|
|Bit-wise NOTs the values in register 1 and 2 and puts the result in register 3.
|-
|Move
|10 xxx yyy
|x: The register to move data from. y: The register to move data to.
|Moves the data from register x into register y.
|-
|Test
|11 000___
|
|Tests the values in register 4 and 5 against each other, putting the result into the flags register.
|-
|Jump 0
|11 001___
|
|Jumps to the instruction in register 6, if the 0 flag is {{On}}.
|-
|Jump carry
|11 010___
|
|Jumps to the instruction in register 6, if the carry flag is {{On}}.
|-
|Jump negative
|11 011___
|
|Jumps to the instruction in register 6, if the negative flag is {{On}}.
|-
|Jump equal
|11 100___
|
|Jumps to the instruction in register 6, if the equal flag is {{On}}.
|-
|Jump
|11 101___
|
|Jumps to the instruction in register 6, regardless of an flags.
|}
===Registers===
We will use 8 all-purpose registers, because of the 3-bit limit imposed by the Move instruction. Note that the program counter and instruction register is seperate to these all-purpose registers, so our program will not be able to ''directly'' edit the values in these registers.

=== Flags ===
We will only have 3 flags in our computer, as can be seen in the instruction set:

* 0 flag. This flag will be {{On}} only if the first value from the last test instruction was equal to 0.
* Carry flag. This flag will be {{On}} only if that last add (or subtract) instruction carried/overflowed.
* Negative flag. This flag will be {{On}} only if the first value from the last test instruction was negative (had its most significant bit {{On}}).
* Equal flag. This flag will be {{On}} only if the values from the last test instruction were equal to each other.

=== Example Program ===
This will show our instruction set using a fibonacci program.
<syntaxhighlight lang="asm">
; Initialise registers
Immediate 0 ; 00 000000
Move 2, 0 ; 10 000 010
Immediate 1 ; 00 000001
Move 1, 0 ; 10 000 001
;
; Main loop
Add ; 01 000 ___
Move 2, 1 ; 10 001 010
Move 1, 3 ; 10 011 001
Immediate 5 ; 00 000101
Move 6, 0 ; 10 000 110
Jump ; 11 101 ___
</syntaxhighlight>
==Building the Computer==

Your First Computer

2025-09-20T13:13:49Z

Lawrziepan:

Your First Computer

2025-09-14T13:40:32Z

Lawrziepan: /* Example Program */ made comments all aligned

Your First Computer

2025-09-14T13:34:41Z

Lawrziepan: Added Registers, Flags and Example Program sections into the Planning heading.

{{stub}}

If you're a new player, you might have already built a few circuits already: an [[Full Adder|adder]], some kind of memory, a [[decoder]]. But getting to the next level where you have a functioning and [https://en.wikipedia.org/wiki/Turing%20completeness turing complete] computer, is incredibly daunting. This article will serve as a guide to how you might build your first computer.

== Planning The Computer ==
[[File:Computer Structure diagram.png|300px|right|thumb|The structure of the computer in this article]]While you might be inclined to jump head first into building, this results in at the very least messy building in Logic World, or a malfunctioning computer. In our computer we are going to first plan and '''document''' the capabilities our computer will have.

To start with the planning section, it helps to think about what this computer we are building is for. This could range from wanting to test out an [[wikipedia:Arithmetic_logic_unit|ALU]] you built, or to perform a specific program you have in mind, e.g. matrix multiplication.

In this guide, our computer will be built as a way to learn each of the different parts of a computer, without any bells or whistles. So, we are going to give the computer the bare minimum.

=== Data Width ===
Data width refers to how many bits the binary numbers in our computer will use. This doesn’t have to be universal across an entire computer; for example, the memory might store in 32 bits, but our ALU only 16. In our computer however, we will use the same data width across our entire computer. While you can definitely go smaller, 8 bits is a good number to make it less complicated while being able to do a lot with our computer, so our data width is going to be 8 bits.

=== The ROM ===
The read only memory in our computer is where we are going to store all of the instructions for our computer. We aren’t looking for anything too big, so to keep with our data width of 8 bits, we will have 2^8 or 256 addresses in our ROM (this only needs to be addressed with 8 bits). And each address will store 8 bits of data for our instructions.

=== Instruction Set ===
This is the most influential part of planning. It’s tough for a beginner to get a feel for how to design an instruction set, and has the most impact on how easy it will be to build your computer. If you wanted to design a more advanced computer, you should design your own instruction set, and see how that influences your computer.

Every instruction has an opcode that tells the computer what instruction you ''actually'' want it to perform. There are roughly 4 main types:

* Data management. This involves moving data from one register to another, loading or saving to memory, or loading an arbitrary value into your registers, etc.
* Operations. These instructions use your ALU to transform data in a specific way, e.g adding two registers or using bitwise logic.
* Conditional logic. This is where jumps come into play. These instructions let you test registers against each other, and change the order the computer executes instructions based on tests.
* Interrupts. While you generally wouldn’t find interrupts in a computer in Logic World, these let you talk to computer hardware, or call specific kernel functions (don’t worry if you don’t understand what that means, it isn’t important for this guide).

With that, this is the instruction set we are going to base our computer around:
{| class="wikitable"
|+
!Name
!Opcode (8 bits)
!Opperands
!Description
|-
|Immediate
|00 xxxxxxxx
|x: The immediate value.
|Puts a value given by x into register 0.
|-
|Add
|01 000___
|
|Adds the values in register 1 and 2, and puts the result in register 3.
|-
|Subtract
|01 001___
|
|Subtracts the value in register 1 from register 2 and puts the result in register 3.
|-
|And
|01 010___
|
|Bit-wise ANDs the values in register 1 and 2, and puts the result in register 3.
|-
|Or
|01 011___
|
|Bit-wise ORs the values in register 1 and 2, and puts the result in register 3.
|-
|XOR
|01 100___
|
|Bit-wise XORs the values in register 1 and 2 and puts the result in register 3.
|-
|Not
|01 101___
|
|Bit-wise NOTs the values in register 1 and 2 and puts the result in register 3.
|-
|Move
|10 xxx yyy
|x: The register to move data from. y: The register to move data to.
|Moves the data from register x into register y.
|-
|Test
|11 000___
|
|Tests the values in register 4 and 5 against each other, putting the result into the flags register.
|-
|Jump 0
|11 001___
|
|Jumps to the instruction in register 6, if the 0 flag is {{On}}.
|-
|Jump carry
|11 010___
|
|Jumps to the instruction in register 6, if the carry flag is {{On}}.
|-
|Jump negative
|11 011___
|
|Jumps to the instruction in register 6, if the negative flag is {{On}}.
|-
|Jump equal
|11 100___
|
|Jumps to the instruction in register 6, if the equal flag is {{On}}.
|-
|Jump
|11 101___
|
|Jumps to the instruction in register 6, regardless of an flags.
|}
===Registers===
We will use 8 all-purpose registers, because of the 3-bit limit imposed by the Move instruction. Note that the program counter and instruction register is seperate to these all-purpose registers, so our program will not be able to ''directly'' edit the values in these registers.

=== Flags ===
We will only have 3 flags in our computer, as can be seen in the instruction set:

* 0 flag. This flag will be {{On}} only if the first value from the last test instruction was equal to 0.
* Carry flag. This flag will be {{On}} only if that last add (or subtract) instruction carried/overflowed.
* Negative flag. This flag will be {{On}} only if the first value from the last test instruction was negative (had its most significant bit {{On}}).
* Equal flag. This flag will be {{On}} only if the values from the last test instruction were equal to each other.

=== Example Program ===
This will show our instruction set using a fibonacci program.
<syntaxhighlight lang="asm">
; Initialise registers
Immediate 0 ; 00 000000
Move 2, 0 ; 10 000 010
Immediate 1 ; 00 000001
Move 1, 0 ; 10 000 001
;
; Main loop
Add ; 01 000 ___
Move 2, 1 ; 10 001 010
Move 1, 3 ; 10 011 001
Immediate 5 ; 00 000101
Move 6, 0; 10 000 110
Jump ; 11 101 ___
</syntaxhighlight>
{{Todo|I will expand this article later}}

Your First Computer

2025-09-10T22:10:19Z

Lawrziepan: Added instruction set planning section

{{stub}}

If you're a new player, you might have already built a few circuits already: an [[Full Adder|adder]], some kind of memory, a [[decoder]]. But getting to the next level where you have a functioning and [https://en.wikipedia.org/wiki/Turing%20completeness turing complete] computer, is incredibly daunting. This article will serve as a guide to how you might build your first computer.

== Planning The Computer ==
[[File:Computer Structure diagram.png|300px|right|thumb|The structure of the computer in this article]]While you might be inclined to jump head first into building, this results in at the very least messy building in Logic World, or a malfunctioning computer. In our computer we are going to first plan and '''document''' the capabilities our computer will have.

To start with the planning section, it helps to think about what this computer we are building is for. This could range from wanting to test out an [[wikipedia:Arithmetic_logic_unit|ALU]] you built, or to perform a specific program you have in mind, e.g. matrix multiplication.

In this guide, our computer will be built as a way to learn each of the different parts of a computer, without any bells or whistles. So, we are going to give the computer the bare minimum.

=== Data Width ===
Data width refers to how many bits the binary numbers in our computer will use. This doesn’t have to be universal across an entire computer; for example, the memory might store in 32 bits, but our ALU only 16. In our computer however, we will use the same data width across our entire computer. While you can definitely go smaller, 8 bits is a good number to make it less complicated while being able to do a lot with our computer, so our data width is going to be 8 bits.

=== The ROM ===
The read only memory in our computer is where we are going to store all of the instructions for our computer. We aren’t looking for anything too big, so to keep with our data width of 8 bits, we will have 2^8 or 256 addresses in our ROM (this only needs to be addressed with 8 bits). And each address will store 8 bits of data for our instructions.

=== Instruction Set ===
This is the most influential part of planning. It’s tough for a beginner to get a feel for how to design an instruction set, and has the most impact on how easy it will be to build your computer. If you wanted to design a more advanced computer, you should design your own instruction set, and see how that influences your computer.

Every instruction has an opcode that tells the computer what instruction you ''actually'' want it to perform. There are roughly 4 main types:

* Data management. This involves moving data from one register to another, loading or saving to memory, or loading an arbitrary value into your registers, etc.
* Operations. These instructions use your ALU to transform data in a specific way, e.g adding two registers or using bitwise logic.
* Conditional logic. This is where jumps come into play. These instructions let you test registers against each other, and change the order the computer executes instructions based on tests.
* Interrupts. While you generally wouldn’t find interrupts in a computer in Logic World, these let you talk to computer hardware, or call specific kernel functions (don’t worry if you don’t understand what that means, it isn’t important for this guide).

With that, this is the instruction set we are going to base our computer around:
{| class="wikitable"
|+
!Name
!Opcode
!Opperands
!Description
|-
|Immediate
|00xxxxxxxx
|x: The immediate value
|Puts a value given by x into register 0.
|-
|Add
|01000___
|
|Adds the values in register 1 and 2, and puts the result in register 3.
|-
|Subtract
|01001___
|
|Subtracts the value in register 1 from register 2 and puts the result in register 3.
|-
|And
|01010___
|
|Bit-wise ANDs the values in register 1 and 2, and puts the result in register 3.
|-
|Or
|01011___
|
|Bit-wise ORs the values in register 1 and 2, and puts the result in register 3.
|-
|XOR
|01100___
|
|Bit-wise XORs the values in register 1 and 2 and puts the result in register 3.
|-
|Not
|01101___
|
|Bit-wise NOTs the values in register 1 and 2 and puts the result in register 3.
|-
|Move
|10xxxyyy
|x: The register to move data from
y: The register to move data to
|Moves the data from register x into register y.
|-
|Test
|11000___
|
|Tests the values in register 4 and 5 against each other, putting the result into the flags storage
|-
|Jump 0
|11001___
|
|Jumps to the instruction in register 6, if the 0 flag is ON.
|-
|Jump carry
|11010___
|
|Jumps to the instruction in register 6, if the carry flag is ON.
|-
|Jump negative
|11011___
|
|Jumps to the instruction in register 6, if the carry flag is ON.
|-
|Jump
|11100___
|
|Jumps to the instruction in register 6, regardless of an flags.
|}
{{Todo|I will expand this article later}}

XOR Gate

2025-09-07T22:08:40Z

Lawrziepan: Changed timing scenario to correct definition of only one input is on

{{Infobox component|title=XOR Gate|id=MHG.XorGate|caption=XOR gate|configurable=0|io.minInputs=2|io.maxInputs=2|io.outputs=1|io.propagationDelay=1}}

The '''XOR gate''' is a basic digital logic component whose output will be {{on}} if only '''one''' of its inputs are '''ON'''.

An XOR gate is 2 tiles wide and 1 tile tall, and its body is 1 tile long, but its inputs and outputs extend its area to 3 tiles.

== Logic ==
The XOR gate's output will only be active if '''one''' of its inputs are '''ON'''.{{Truth table|0 0 0|1 0 1|0 1 1|1 1 0|inputs=Input 1, Input 2|outputs=1|caption=XOR Gate Truth Table}}
Below are alternative XOR definitions.<br>
The XOR gate's output will only be {{on}}:

*if inputs are '''not equal'''.
:Helpful to compare values.
*if number of {{on}} inputs is '''odd'''.
:Helpful for XOR's with multiple inputs.

== Timing ==
[[File:XOR gate activation delay.png|thumb|A demonstration of two XOR gates being activated. The top XOR gate has one of its inputs active, but its output is not yet active because a delay of 1 tick has not yet passed. The bottom XOR gate has had one of its inputs active for at least 1 tick, and its output is therefore active.]]
The XOR gate has a latency of 1 tick, so in the instance when one input is {{on}}, the output will become active 1 tick later. As demonstrated in the example on the right.

== Configurability ==
The XOR gate cannot have its number of inputs changed, but can have its output position flipped by pressing 'F' on it. The bottom XOR gate in the image on the right has had its output flipped.

[[Category:Vanilla components]]
[[Category:Circuitry components]]

Your First Computer

2025-09-07T22:05:34Z

Lawrziepan:

Your First Computer

2025-09-07T21:12:55Z

Lawrziepan: This article now flows nicer, started a planning section

Your First Computer

2025-09-07T12:15:52Z

Lawrziepan: Wrote the opening of the guide

If you're a new player, you might have already built a few circuits already: an [[Full Adder|adder]], some kind of memory, a [[decoder]]. But getting to the next level where you have a functioning and [[wikipedia:Turing_completeness|turing complete]] computer, is incredibly daunting. This article will serve as a guide to how you might build your first computer.

[[File:Computer Structure diagram.png|300px|right|thumb|The structure of the computer in this article]]Every computer follows this simple process:

* A place that stores instructions sends an instruction to the computer.
* The instruction gets decoded by the control, and tells the rest of the computer what to do.
* Sometimes these instructions the [[Arithmetic and Logic Unit]] (henceforth, ALU), to operate on data given by the [[Register|registers]].

File:Computer Structure diagram.png

2025-09-07T11:29:32Z

Lawrziepan: A digram of the structure of a computer.

== Summary ==
A digram of the structure of a computer.

Multiplexer

2025-09-07T11:28:03Z

Lawrziepan: Initial creation

[[File:Multiplexer Diagram.png|300x300px|A diagram of a multiplexer|alt=A diagram of a multiplexer|thumb]][[File:Multiplexer Circuit.png|300x300px|An in-game circuit of a multiplexer|alt=A diagram of a multiplexer|thumb]]A multiplexer's job is to select from the input data, using flags. A multiplexer is an essential piece of any circuit in Logic World.

== Behaviour ==
A multiplexer has at least 2 inputs of any bit size, and a select input that is either:

* A bit array with a length of the number of inputs, and whichever bits are '''ON''', their corresponding inputs get bitwise-ORed to the output.
* A value which corresponds to an input to send directly to the output.

== Uses ==
Multiplexers are very versatile, and can be used for many circuits. Multiplexers are mainly used for:

* Selecting between registers to use in operations by the computer.
* Indexing memory.

File:Multiplexer Circuit.png

2025-09-07T11:25:18Z

Lawrziepan: A screenshot of a multiplexer circuit ingame.

== Summary ==
A screenshot of a multiplexer circuit ingame.

File:Multiplexer Diagram.png

2025-09-07T10:30:26Z

Lawrziepan: A simple diagram showing the inputs and outputs of a multiplexer.

== Summary ==
A simple diagram showing the inputs and outputs of a multiplexer.

Panel Display

2025-09-07T09:53:25Z

Lawrziepan: Changed 'in-game measurements' to 'measurements' in order to match the linked page

{{Infobox component
| title = Panel Display
| id = MHG.PanelDisplay
| caption = A 1x1 Panel Display with 1 input
| io.minInputs = 1
| io.maxInputs = 9
| io.outputs = 0
}}

The '''Panel Display''' is one of five components that can only be placed through [[Circuit_Board|circuit boards]]. The Panel Display is generally used analogously to the [[Display]] component, but due to the fact its input peg is on the other side of a [[circuit board]], it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see [[measurements]]).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its [[palette]] when any of its inputs are '''on'''. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the index in its specified [[Palette|color palette]].

== Timing ==
The Panel Display changes color on the same frame the input (or inputs) change state.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its [[Palette|color palette]] can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the [[Display]], the Panel Display can have up to 9 input pegs when resized from its default size, whereas the [[Display]] can only have up to 4 input pegs.

[[Category:Vanilla components]]
[[Category:Output components]]

Panel Display

2025-09-07T00:01:31Z

Lawrziepan:

The '''Panel Display''' is one of five components that can only be placed through [[Circuit_Board|circuit boards]]. The Panel Display is generally used analogously to the [[Display]] component, but due to the fact its input peg is on the other side of a [[circuit board]], it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see [[Measurements|in-game measurements]]).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its [[palette]] when any of its inputs are '''on'''. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the index in its specified [[Palette|color palette]].

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its [[Palette|color palette]] can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the [[Display]], the Panel Display can have up to 9 input pegs when resized from its default size, whereas the [[Display]] can only have up to 4 input pegs.

Panel Display

2025-09-06T23:58:14Z

Lawrziepan:

The '''Panel Display''' is one of five components that can only be placed through [[Circuit_Board|circuit boards]]. The Panel Display is generally used analogously to the [[Display]] component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see [[Measurements|in-game measurements]]).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its [[palette]] when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the index in its specified [[Palette|color palette]].

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its [[Palette|color palette]] can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the [[Display]], the Panel Display can have up to 9 input pegs when resized from its default size, whereas the [[Display]] can only have up to 4 input pegs.

Panel Display

2025-09-06T23:51:11Z

Lawrziepan:

[[:File:Panel Display thumbnail render.png|Panel Display thumbnail render.png]]The '''Panel Display''' is one of five components that can only be placed through [[Circuit_Board|circuit boards]]. The Panel Display is generally used analogously to the [[Display]] component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see [[Measurements|in-game measurements]]).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its [[palette]] when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the index in its specified [[Palette|color palette]].

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its [[Palette|color palette]] can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the [[Display]], the Panel Display can have up to 9 input pegs when resized from its default size, whereas the [[Display]] can only have up to 4 input pegs.

Panel Display

2025-09-06T23:50:07Z

Lawrziepan: Added thumbnail image

[[File:[[:File:Panel Display thumbnail render.png|Panel Display thumbnail render.png]]]]The '''Panel Display''' is one of five components that can only be placed through [[Circuit_Board|circuit boards]]. The Panel Display is generally used analogously to the [[Display]] component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see [[Measurements|in-game measurements]]).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its [[palette]] when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the index in its specified [[Palette|color palette]].

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its [[Palette|color palette]] can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the [[Display]], the Panel Display can have up to 9 input pegs when resized from its default size, whereas the [[Display]] can only have up to 4 input pegs.

Measurements

2025-09-06T23:35:36Z

Lawrziepan: Initial creation

There are two main ways components and circuits can be measured in Logic World:

* Tiles
* Real world measurements

Tiles are the most widely used measurement in Logic World Due to the fact that they are the easiest measurement to use. Simply, one square in the world (on a circuit board, or on the ground, in a gridlands world), is one tile wide and one tile tall.

Real world measurements are also used in Logic World. Every tile is exactly equal to 30 centimetres.

Panel Display

2025-09-06T23:29:41Z

Lawrziepan: Added hyperlinks to other wiki pages

The '''Panel Display''' is one of five components that can only be placed through [[circuit boards]]. The Panel Display is generally used analagously to the [[Display]] component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see [[Measurements|in-game measurements]]).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its [[palette]] when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the index in its specified [[Palette|color palette]].

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its [[Palette|color palette]] can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the [[Display]], the Panel Display can have up to 9 input pegs when resized from its default size, whereas the [[Display]] can only have up to 4 input pegs.

Panel Display

2025-09-06T23:26:45Z

Lawrziepan: Changed 'panel' to 'circuit board'

The '''Panel Display''' is one of five components that can only be placed through circuit boards. The Panel Display is generally used analagously to the Display component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see in-game measurements).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its palette when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the index in its specified color palette.

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its color palette can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the Display, the Panel Display can have up to 9 input pegs when resized from its default size, whereas the Display can only have up to 4 input pegs.

Panel Display

2025-09-06T23:23:38Z

Lawrziepan: Changed 'input' to 'index

The '''Panel Display''' is one of five components that can only be placed on panels. The Panel Display is generally used analagously to the Display component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see in-game measurements).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its palette when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the index in its specified color palette.

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its color palette can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the Display, the Panel Display can have up to 9 input pegs when resized from its default size, whereas the Display can only have up to 4 input pegs.

Panel Display

2025-09-06T23:20:26Z

Lawrziepan: Added resizability section, and subsequent changes

The '''Panel Display''' is one of five components that can only be placed on panels. The Panel Display is generally used analagously to the Display component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see in-game measurements).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its palette when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the input in its specified color palette.

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3 at its default size, and a maximum of 9 if resized. The default amount of input pegs is 1.
* Its color palette can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Resizability ==
The Panel Display can be resized from a default 1 by 1 size, to 12 by 12.

If the Panel Display is at least 2 by 2 in size, its input pegs can be increased from a maximum of 3 to a maximum of 9.

== Trivia ==
Unlike its counterpart, the Display, the Panel Display can have up to 9 input pegs when resized from its default size, whereas the Display can only have up to 4 input pegs.

Panel Display

2025-09-06T23:14:44Z

Lawrziepan: Added trivia section

The '''Panel Display''' is one of five components that can only be placed on panels. The Panel Display is generally used analagously to the Display component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see in-game measurements).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its palette when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the input in its specified color palette.

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3, and is 1 by default.
* Its color palette can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.

== Trivia ==
Unlike its counterpart, the Display, the Panel Display can have up to 9 input pegs when resized from its default size, whereas the Display can only have up to 4 input pegs.

Panel Display

2025-09-06T23:09:53Z

Lawrziepan: Initial creation

The '''Panel Display''' is one of five components that can only be placed on panels. The Panel Display is generally used analagously to the Display component, but due to the fact its input peg is on the other side of a panel, it is often used to hide internal wiring in displays.

The Panel Display is about <math>2 \frac{1}{6}</math>tiles long, 1 tile in width, and 1 tile in height (65cm by 30cm by 30cm, see in-game measurements).

== Behaviour ==
When a Panel Display is configured to have a single input, the color of its display is blank when its input is '''off''', and colored when its input is '''on'''.

When a Panel Display is configured to have multiple inputs, the color of its display is blank when all inputs are '''off''', and a color determined by its palette when any of its inputs are on. The inputs are read as a binary number, where the shortest input peg is the least significant bit, and the longest input peg is the most significant, this number then corresponds to the input in its specified color palette.

== Timing ==
The Panel Display changes its display one tick after its input is changed.

== Configurability ==
The Panel Display can be configured in two ways:

* Its amount of input pegs can be changed via a 'Input Count' slider, which ranges from 1 to 3, and is 1 by default.
* Its color palette can be specified from the list of palettes in that world. Note that you can add or change palettes by clicking the 'Edit Configurations' button.