As people learn more about redstone, they'll start looking for good designs for various logic gates and other circuits. Those can often be hard to find, or badly displayed.
This thread attempts to combine all those circuits in a consistent, nice looking manner. It can act as a list of reference for more experienced redstoners but also contain a short description of each gate/circuit in plain English so beginners will know what they do. Some more advanced circuits also have short high quality videos attached, so you can better understand them. Note that most of these designs aren't made by me, but collected from around the community.Tl;dr: This thread has a lot of different designs shown in clear big images with the default texture pack

16. BUD Switch (Block update detector)
Creates a redstone pulse when certain blocks receive an update. This was originally considered a bug, however Mojang has confirmed that they will not fix it because it's useful.

Works because pistons are powered as if they were one block above where they actually are. However since redstone only updates 2 blocks, and since the pistons end up being 3 blocks away from the dust, it requires a block update next the piston to "catch up".

23. Instant wire
Circuit where the output reacts to the input instantly (within the same redstone tick). This includes repeaters, inverters and other circuits. They usually take advantage of the fact that when a piston changes state, the block that's attached to it will instantly stop powering (or blocking off signals) at its old position.

Credits
This is a list of people in alphabetical order that have created, or brought to my attention any of the designs above. Keep in mind it's impossible to tell who was actually the first person to create a certain circuit, which is why I didn't attach names next to any designs.

acmc

aj_s

Alfred0110

caramba2654

CodeCrafted

Cubehamster

DaftasBrush

DonutCannon

emeraldfyr3

Entity

Grizdale

Hans Lemurson

iammrhellohowareyou

jms_gears1

jumavittulauta

jxu

KillaMarci

Krackor

Lancelote123

larslolxz

last_username

Magix

Metapig

NerdFail

MinecraftAddict

ohmganesha

Peppe

peterjiangTW

richardmisiak

Selulance

Sethbling

SkyshockX

system_overload

TheMightyAnonym

UnKnown_Player

XxDOTxX

Zhul

----------------------------------------------Links
Since I don't want to take away from any of the previous peoples' efforts at making these types of collections, here's the links to them. They may also include more information about the circuits.

Promises to This has become a great collection! Thank you for working on it so much.

I'd like to add (sort of) a glossary/introduction of some technical terms appearing here, focusing on those that seem to cause the most confusion on this forum (instead of keeping my original, now very outdated suggestions in this post).

The idea is to use the same terms/names as in real-world electronical circuits, but also to say where some names cease to be appropriate and why.

Well, the analogy to electronics is not quite complete, because we have to deal with different "low level problems" in Minecraft (e.g. how updates are scheduled in Java) than in electronics (where e.g. parasitary capacitors may force us to leave the convenient "digital" way of thinking).

But once we got the basic components presented in this thread, both worlds are very similar with respect to how these work and how they can be combined, so let's focus on that part.

Note that I assume you already know the basic principles of redstone - e.g. how wires conduct power to blocks and how torches can act as inverters. Please read Magix's redstone guide if you're not sure about that.

This has become a rather long text, so feel free to skip any topics that don't interest you - I tried to mark all those that mainly serve as a background for others and aren't that important to know with a * as prefix.

Circuits

Almost any contraption containing redstone can be called a circuit. This includes buttons, pistons, dispensers etc. You could even say that to mechanisms other than redstone, e.g. using water flows and items in Minecraft - the important aspect (that makes a structure interesting enough to be called a circuit) is that there are several options (one or more "ouputs" with two or more distinct possible values) that can be controlled in some way (using the circuit's "inputs").

As in digital electronics, in Minecraft we focus on how circuits deal with information (mainly in binary form: on vs. off, i.e. that they can be powered), not how exactly they are powered (i.e. that electrons actually travel in a loop, transmit energy and can do work).

Not clearly distinguishing between these two aspects when we say "on" is sloppy, but usually not a problem.

Basic Circuits (single output)

Gates

A gate is the special case of a circuit that has no internal state (no history, in particular no memory), i.e. where the accessible input(s) fully determine(s) the output(s), similar to a mathematical function.

We usually start with gates having 2 inputs and 1 output because these are the easiest - also known as binary Boolean operations/functions (note that this "binary" refers to them having two inputs, not that there are two states each). There are 16 (=2(possible output states)^2(possible states per input)^2(number of inputs)) of these, the most useful ones have well known names: AND, NAND, OR, NOR, XOR and XNOR.

(Of the 4 =2^2^1 possible unary gates, i.e. gates with 1 input and 1 output, only NOT is interesting enough to have a widely used name, the other 3 would be "constant off, ignoring the input", "constant on" and "output the same as the input".)

A truth table is a compact way of writing down all cases that can occur, so this is how gates are often defined.

For gates with more inputs the number of possible cases increases dramatically (already to 256 =2^2^3 for 3 inputs), but only very few of them are used often enough to have agreed upon names: multi-input AND (becomes ALL) and multi-input OR (becomes ANY) are the easiest of these.

Watch out to avoid ambiguities: E.g. already for 3 inputs there are two interesting, useful, but conflicting alternatives for generalizing XOR: Do we want a gate which determines whether exactly one input is on (which is called a "one-hot detector") or do we want a gate that determines whether an odd number of inputs is on (which is a "parity check"). Both are the same for 2 inputs, but differ for more. Sadly the parity check is often considered to be a "multi-input XOR", because it's so easy to build that out of several 2 input XORs. Calling the one-hot detector "multi-input exclusive or" would be more intuitive, because that's closer to how English treats "either or". So it's probably better to give up on saying "XOR" to any of the two and use the distinct names "parity function" and "one-hot detector" instead.

Some gates are a lot easier to realize than others, depending on which "hardware" we get to work with.
In Minecraft, the game basically (focusing on redstone) gives us only OR gates (blocks and wires that can be alternatively powered from different directions) and NOT gates (redstone torches). But these suffice to build all the other stuff, e.g. in redstone "a AND b" is actually built as "NOT( NOT a OR NOT b )" (this equivalence is known as De Morgan's law).

Monostables

If we admit that a circuit's output may not only depend on its inputs (at a specific moment), but also on its own history (e.g. its last output) we cannot call it a "gate" anymore.

A simple example of this are monostable circuits: After changing their output's state (becoming active when they received an input) they will return to their former (inactive) output after a while, just like a button (which thus is a simple monostable circuit itself, only admitting a direct user input - but here we're interested in circuits that accept redstone signals as input).

So a monostable's output will always be what is called a pulse, i.e. a signal that turns on and then off again (and with signal I mean some time sequence of on/off states on a single wire).

There are several more specialized names for monostables, emphasizing how long the output lasts (stays on) compared to how long the input lasts:

If the output pulse is brief compared to the input (but the input is also a pulse) we call them pulse shorteners (or pulse limiters).

If the output pulse is longer than the input pulse we call them pulse extenders (pulse sustainers or pulse lengtheners).

If we don't care how long the input stays on (may even be indefinite) we call them edge detectors.

Sometimes we're more interested in when a signal turns off (instead of on): A "negative pulse" turns off and then on again. For a falling edge detector it matters when the input turns off (but its output is a positive pulse, i.e. on and then off again) - and so if we want to emphasize that it matters when it turns on we can say rising edge detector. And a dual edge detector emits (outputs) a (positive) pulse at both a rising and a falling edge of the input signal.

Latches

Another important circuit is a memory cell, also called a latch or a flip flop - the latter suggesting that these have not one but two stable output states (therefore these circuits are also called bistable). Think of "stable" as that the output might stay the same even if some of the inputs change. In what way the input is used to control that output (i.e. which changes to the inputs are considered important) is the difference between the most common latches:

an SR latch (also called RS latch) has two inputs, one to set and one to reset the output

This circuit is often built using two cross-coupled NOR gates. To emphasize this choice it can be called "RS NOR latch". However, I'd recommend not to do that, because a circuit should be called by what it does, not by what it is built out of. Saying "RS NOR" is a sloppy variant of that. These names are not applicable for SR latches built without using NOR gates (and the introduction of pistons to Minecraft allowed many such alternative designs).

a T flip flop has one input that toggles the output

So this circuit behaves like a lever (which is a "circuit" that can only be toggled by direct user input, while T flip flops also allow other redstone inputs).

a D flip flop has two inputs, often called "data" and "write" and sets the output to (i.e. reflects) the data input when a certain condition on the write input is met, e.g. when there's a rising edge on write.

This is what is the most intuitive version of a "memory cell": it can remember some old data (as long as write stays inactive).

How the "write" input is interpreted can be emphasized in the name: Sometimes "D latch" (output changes according to the data input as long as write is on) is distinguished from "D flip flop" (the data input can change the output only on the rising edge of write).

Both T and D flip flops are often built using an (internal) SR latch for the actual memory. Then you can also create hybrids by additionally allowing to control that SR latch directly, e.g. add a S and a R input to a T flip flop.

In electronics a latch's output is often called "Q" (probably because Q is similar to O, but different enough from zero).

Clocks

Now we've seen circuits with a single stable output state (monostables) and two stable output states (bistables).
How about circuits where neither output is stable, i.e. on turns into off after a while and vice versa? These are clocks (and you can also call them astable circuits).

There are three interesting numbers defining a clock: how long it stays on (its pulse length), how long it stays off and the sum of the two (its period).

Sometimes it is sufficient to only tell the period (how long until it turns on again), but I'd recommend to always tell the pulse length as well (e.g. if I say "a 1/4 clock" I mean a clock that is on for 1 out of 4 ticks, but so far there doesn't seem to be an agreed upon convention for this on this forum).

An alternative way of doing that is to define the clock's duty cycle, which is its pulse length divided by its period.

Registers, Counters and Adders

Digression: What are Numbers

So far we were mainly concerned with logic (after all "on" vs. "off", often written as "1" vs. "0" works well when talking about "true" vs. "false") and events in time (using e.g. an edge detector to measure exactly when something changed and maybe an RS latch to remember whether that actually did happen).

But how to deal with more than one distinct "somethings"? We could just use several copies of the circuits above, but that quickly becomes tedious because it's quite inefficient. So let's look at several more (or less) compressed ways to talk about "more":

Unary Numbers

The inefficient way of just adding more copies of "one" is actually not too bad for (very) small numbers: a system where e.g. holding up more than one finger (or sticks) or chiseling/writing more than one stroke (like the Romans did for I, II and III) represents growing numbers is called unary - where "unary" refers to the fact that we only use a single symbol (but are allowed to copy/repeat that).
.Decimal Numbers

These days most of us are taught the decimal numeral system, which happens to have ten different symbols (0,1,2,3,4,5,6,7,8 and 9) and an interesting way of using the positions of several such symbols next to each other to encode bigger numbers: 10 means "a ten and no ones" = 1*10 + 0*1 (instead of "a one and a zero" similar to Roman VI meaning "a five and a one").

Such symbols (here 0-9) arranged in positions are also called digits.

How to calculate with decimal numbers is also quite ingenious: For 9+1 we run out of symbols to represent "ten" as a single one (note that the word "ten" still manages that and that we also don't say "one-teen" and "two-teen" but eleven and twelve, remnants of using 12 instead of only 10 as a base). The solution is to wrap around to 0 in that position, remember to "carry one over to the next position" and to add that there, allowing 29+11 to be solved as 9+1=0, carry 1, then 2+1+(that carried)1=4 with the final result written down as 40.

Binary Numbers

There's no particular reason forcing us to have exactly ten different numeral symbols (well, having ten fingers might be the historical reason, but that's unimportant from a technical perspective). Sometimes we use twelve (e.g. for counting time), sometimes even more exotic systems (e.g. for counting points in tennis).

Counting in the binary system is kind of an extreme: Here we restrict ourselves to use only two different symbols (0 and 1), but otherwise use the same positional rules for calculations as in decimal. This means that we already run out of symbols to represent 1+1, which is solved again by wrapping around to 0 and carrying 1 over to the next position, with a result written down as 10, which in this context means "two".

To emphasize that a number is written down in binary (not in decimal), add a suffix "b", e.g. 10b = decimal 2 (alternatively, a prefix "0b" can be used).

The reason that binary numbers are important in technical applications (like computers) is that it's impressively easy to build them in hardware.

The drawback is that binary numbers generally require more digits, e.g. decimal 2012 (=2*1000+0*100+1*10+2*1) becomes binary 11111011100 (=1*1024+1*512+1*256+1*128+1*64+0*32+1*16+1*8+1*4+0*2+0*1), but this is still much better than writing down 2012 separate lines as you'd need to in unary.

A "binary digit" is usually abbreviated as bit (and a group of 4 bits is called a "nibble", one of 8 bits is called a "byte" etc., pun intended).

*Hexadecimal Numbers

While binary is the perfect system for computers to think in, it is not for us - because computers are faster, but we're better at recognizing patterns.

A good compromise is to use hexadecimal numbers: these have 16 different symbols (for writing these down the decimal 0 to 9 are used, and then A to F to mean "ten" to "fifteen") with hexadecimal 10 (=1*16+0*1) meaning "sixteen", often written with a prefix "0x" (i.e. 0x10) to emphasize that it's not a decimal number.

Hexadecimal numbers are very easy to translate to binary, because each hexadecimal digit becomes exactly 4 bits, e.g. 0xBADA55 = 1011 1010 1101 1010 0101 0101b. And they're about as short to write (slightly better) as in the usual decimal system.

*Binary Coded Decimal (BCD) Numbers

To translate binary and decimal numbers from and to each other is not as easy as we'd like (mainly because 10=2*5, and five is a complicated thing in binary: 101).

A workaround to allow us to think in decimal while still using only bits to "write down" any numbers is to actually use hexadecimal numbers (0 to F), but deliberately avoid all the symbols bigger than 9, so that "10" can mean "ten" instead of "sixteen" again.

Binary coded decimal numbers do precisely that: 4 bits are used to "write" each decimal digit. But because 4 bits allow to count up to 15, 6 of these cases (A to F in hexadecimal) have to become "unused". This makes it harder to calculate: We have to force decimal 9 = binary 1001 "plus 1" to wrap around to decimal 0 = binary 0000 (instead of 1010). And to do the carry to the next group of four bits (being the next decimal digit) there, too.

This is usually done by comparing the 4 bits to (be greater than or equal to) decimal 10 (=binary 1010) and if so adding decimal 6 (=binary 0110), which in effect skips "ten" to "fifteen" (in hexadecimal) whenever possible (the result is binary 1 0000).

So the benefit is more convenience for us humans, (damned to be?) used to think in decimal. The drawback is that it's much harder to implemenent this way of "writing down numbers" in binary - and thus more work for the engineer working on that level (of bits).

*Shift Registers

If we group several latches with the intention to treat them as a unit (read or write them together), that group can be called aregister if it has some special purpose other than just serving as memory.

The typical use is to represent (more than one bit's worth of) information about a piece of hardware - and that "piece of hardware" can be a quite complicated thing, e.g. a CPU (where registers hold the current state of the computation being processed).

A particularly interesting kind of registers are shift registers: These can shift their bits over by one position, possibly filling up the (then vacant) first bit from some input and sending the "overflowing" last bit away as an output. If this shifting can happen in both directions (left and right, so "first" and "last" can switch roles) it's a bidirectional, otherwise a unidirectional shift register.

Shift registers are very useful

to translate between a serial representation of data (a time sequence of bits on a single wire) and a parallel version of the same data (that sequence stored at different positions in the register);

as an important step for the multiplication and division of binary numbers (because a shift left acts like a multiplication by 2 and a shift right like a division by 2).

We can also choose to feed the last bit (the "overflow" output) back as the first bit, then having a circular shift register.

A barrel shifter can also shift by more that just one position (and may also be circular).

Another application is a relatively easy way to generate (pseudo-) random numbers: In a linear feedback shift register the first bit is set to the parity (using some simple XORS) of some of the other bits. This has the interesting result that the output (the last bit) can be very unpredictable (random) and that it can take a long time to repeat the same sequence (depending on how many bits we use).

Unary and Ring Counters

A counter that has several outputs that turn on one after the other is called

a unary counter if the outputs that are on already stay on when the next output turns on (because that's what unary numbers look like - think of a unary counter as a good solution for a "progress bar").

a ring counter if only one output is on at a time and counting up from the last output wraps around to the first.

So a ring counter is a good choice for single digits of a number system different than binary, e.g. 10 outputs called "0" to "9".
(Note that technically a T flip flop can be seen as a ring counter with only two outputs).

Both can be unidirectional (can only count up) or bidirectional (can count down, too).

A single track of piston tape is a compact way to realize them, however, these are difficult to reset (or set to any number you'd like to start with).

So you might want to use a shift register, which becomes

a unary counter if you always set its "next first bit" to 1 (or it's "next last bit" to 0 when counting down);

a ring counter if you make sure that always only one bit is set.

Unary Adders and One-Hot Detectors

A unary adder can be used to add (in unary) how many (parallel) inputs are on (not how often a single input was turned on as a unary counter does), in effect "sorting" all the set bits to one side (e.g. input 1001101 becomes output 0001111).

This is useful for building one-hot detectors, which (are multi-input gates that) assert that exactly one out of many inputs is on - which can be implemented as "the first bit of a unary adder is set, but not the second" (i.e. first output AND NOT second output).

Binary Counters

It's a bit hard to define a binary counter other than saying: well, it can count, and the output encodes/represents a binary number.

The simplest binary counters can be built by just hooking up several T flip flops, so that each bit toggles when the preceding bit wraps around. Thus binary counters are (a special kind of) registers.

Binary counters can be unidirectional (can only count up) or bidirectional (can also count down), resettable (to zero), settable (to any number you want, just like an ordinary register) and synchronous (all output changes occur in the same game tick)

Which binary counter fits your needs best depends on which of these properties you want it to have.

*Binary Adders (and Subtractors)

Calculating with binary numbers is technically easy to do. The first step is to allow any two numbers to be added (not just 1 to a number like a counter does).

A very simple version that can just add two bits (the inputs) is called a half adder with two outputs: the result bit (at the same position as the inputs) and a possibly set carry bit (for the next higher position, in the case 1+1=10).
A full adder can also accept such a carry bit (from the previous position) as additional input, in effect adding three single-bit inputs (with the possible results 00,01,10 and 11).

A ripple-carry adder consists of several (as many bits as you want) such full adders hooked up to each other (the carry out of each position connected to the carry in of the next). These are easy to build, but often suffer from the delay caused by the "ripple": Each full adder in there has to wait for its carry input and only then can produce a carry output for the next position.

However, in Minecraft there are ways to speed things up using instant wire techniques - if used for the carry signals the resulting adder can be called an instant carry adder.

In reality some other alternatives have been found to build faster adders, e.g. the carry-lookahead adder.

Any binary adder can be turned into a subtractor by adding the two's complement of the number you want to subtract. The two's complement is easy to get by inverting all the bits (usually by using XORs as conditional inverters) and adding 1 - which can be done by using the carry-in of the first bit's adder.

Take care to use enough bits to represent all the numbers you need and to treat overflow correctly when using the two's complement encoding: e.g. if you only got 4 bits you can encode either

0 to 15 (then failing when asked to add e.g. 6+11, which becomes binary 0110+1011=0001 with a set carry-out of the 4th bit's adder, i.e. signalling overflow) or

-8 to 7.(then having e.g. 6-5 showing as the same binary 0110-0101=0110+1011=0001, still setting the 4th bit's adders carry-out but now not counting as an overflow).

hmm, not sure if we really need this, but I guess it's nice to have a thread with useful circuit designs. In any case, if you do continue this, I suggest you add a half and full adder section. Also, you should easily be able to find some d-flip flop designs (there is a very good piston version on grizdale's compendium). You should also be able to find a vertical one as well if you look around a bit. But yeah, here's one i came up with:

Pretty small design, but I believe it's referred to as a d-latch instead of a d flip flop (could be mistaken). The only real difference is that this one allows you to freely toggle the output, and then lock it with the enable input, while the d flip flops only accept the data input when the enable input is on. Also I believe the input is inverted, and you may also need to slightly adjust it because of the change in redstone formation in 1.0.0.

If circuits differ only minimally by layout it might be easier to explain the principle than to show a lot of alternatives.

You mean like XNOR=XOR+inverter? Yeah, I tried explaining that in the little text bit as well, but for the sake of being complete I still added the pictures. If you mean more specific cases, well.. examples? =P

Would you prefer the smallest circuit in each category? Or both a redstone-only and one using pistons maybe?

How about trade-offs, e.g. speed vs. size vs. cost?

Basically anything goes that provides a benefit in comparison to the other ones in terms of speed, compactness, etc. Prolly shouldn't put much emphasis on cost. Everything should have a couple of viable non-piston versions though, in case you don't want the sound.

A D Flip flop is a flip flop where the input is the output as my Computer Engineering teacher put it. I've mostly used them in making counters, or sequence detectors . How it's made in Minecraft, I'm not sure, but I wouldn't imagine it to be that difficult.

Edit: By that, I mean on the clock cycle, if D=1, Q+=1, D=0 Q+=0. So it's a memory cell of a kind.

Hmm, something like "you can use repeaters as diodes to insulate wires from each other, e.g if you want to reuse one of the inputs elsewhere".

As for the DFF part, if somebody could write a nice short description of what it actually does, I'll add that and then find some designs.

"Flip flop", "memory cell" or "latch" are just different terms for the same thing.
They can be used differently and are categorized by what inputs there are, the most common ones are

RS for Reset and Set inputs - also called RS nor because that's how it's often built (also in real electronics)

T for a single Toggle input

D for Data, most used in computers to communicate on a common bus: if the enable input is on then the latch "reads" the current data input, otherwise (enable off) the last data is remembered. This is also very useful for synchronisiation: several D latches can take a snapshot of some signals, to be dealt with later.

JK for a latch that can emulate all of the above

All of them may have an additional clock input (in computers) to determine when updates may occur (we don't really need that in Minecraft). But you can also use edge triggers instead (e.g. the enable of a D flip flop is often edge triggered).

Well this looks certainly useful to adventure map makers, or people who just want to use some circuit to get something done, without wanting to learn. My opinion is that references like this one (and the wiki) are very bad for redstone engineers, as we call them.
For one, you sometimes isolate your inputs, sometimes you don't, it's not consistent. You use pistons in many designs, even though some people won't hear of pistons. Some circuits require special dimensions, and some people prefer speed above compactness. There are so many factors that count, and I do not think there is one 'best' solution for any wanted circuit.

For one, you sometimes isolate your inputs, sometimes you don't, it's not consistent. You use pistons in many designs, even though some people won't hear of pistons. Some circuits require special dimensions, and some people prefer speed above compactness. There are so many factors that count, and I do not think there is one 'best' solution for any wanted circuit.

That's exactly why I made this thread. There's no one best solution, which is why this thread contains all of the solutions.
Well, not yet. But eventually.

As for the isolated inputs, never really understood what that meant? I can change it to be more consistent if I know what's up.

But you're definitely right in the sense that this will probably be more helpful to people that aren't *very* advanced at redstone yet, because the advanced ones most likely already know all the designs or are capable of making their own. Regardless, I'm sure there will be people that have built all their CPUs and stuff and might still go "oh shiet, I didn't even think of that." when seeing some of the designs.

Edit: added Zhul's flat BUD and TFF. Will add some more tonight, time to do the whole christmas thing.

Well this looks certainly useful to adventure map makers, or people who just want to use some circuit to get something done, without wanting to learn. My opinion is that references like this one (and the wiki) are very bad for redstone engineers, as we call them.

True and true. It depends on the target audience whether this is useful or not.
You cannot become an engineer overnight, so this is for those who understood how to connect redstone modules, but not really how their thoughts (e.g. "and") are translated into redstone (where without pistons you only got NOT and OR with connection rules depending on directions and delays).

I cringe too everytime I see an inverter hooked up to an AND gate. But well, it works and gets the job done - and I prefer looking at that instead of even more complicated "new" designs seemingly born from random trial and error.

So I believe the circuits in here should be least confusing when you connect them together - even if that means some show an additional (in some applications unnecessary) diode (well, sometimes it's the repeater's strong power that's needed, not its insulation). Once you understand how they work and modify the layout you don't care (much), maybe having a respective comment in there is enough?

But what would be best for engineers? Teaching material on a more advanced level is hard to find, but also hard to publish.

If by "engineers" you mean advanced redstoners that build very complex circuits, well..
You can't say this thread is bad for them, because there is no thread for them. They don't need one. If you wanna learn real advanced "redstone", you will most likely want to learn electronics in school. No minecraft thread can teach you that.

What would you guys think about trying to get this stickied? Because otherwise no matter how we display these circuits, people are still not gonna find them. Since the thread will get buried down the pages.

I was looking around the internet a few days ago and couldn't find the D Flip-Flop I needed, which was one that was 4 blocks high, 1 wide, fully modular (both horizontally and vertically), and had the inputs on one side one above the other. So, I made it myself. I would be greatly pleased if you would use this in your list.

It requires two different layers, so the layers don't interfere with each other.
First one:

Second one:

Here's a picture proving it's fully modular:

I couldn't find this anywhere on the internet, so I'm pretty sure that I'm the first one to make it. It is the best design for a vertical D Flip-Flop out there. The best non-vertical design is here.

You should also add this T Flip-Flop to the list. Both of the pistons are non-sticky.

If by "engineers" you mean advanced redstoners that build very complex circuits, well..
You can't say this thread is bad for them, because there is no thread for them. They don't need one. If you wanna learn real advanced "redstone", you will most likely want to learn electronics in school. No minecraft thread can teach you that.

Even after you did learn real electronics, a survey like this helps a lot to learn how to translate it - I wouldn't want to reinvent the wheel too often.

What would you guys think about trying to get this stickied? Because otherwise no matter how we display these circuits, people are still not gonna find them. Since the thread will get buried down the pages.

I was looking around the internet a few days ago and couldn't find the D Flip-Flop I needed, which was one that was 4 blocks high, 1 wide, fully modular (both horizontally and vertically), and had the inputs on one side one above the other.
-snip-

Nice one! Similar to the one platypus1130 posted on Metapig's conspectus today, but using a redstone RS latch instead of a piston.

And yes, SkyshockX's DFF should be in this collection, too, as should Entity's TFF with the modification you show of taking dust instead of a button to redirect the wire, maybe also Lancelote123's version that is symmetrical (and thus instant in both positions - after that same modification).

I'll get working on those in a bit, I seriously don't recommend tinypic, they just randomly take a bunch of pictures you upload and turn them into horrible quality.. Worse than saving jpg in paint.
I just finished reuploading like 15 pictures to imageshack and replacing them.

Yeah, it's pretty much nearing the end of the 'beta' stage. I'll finish the DFF and add a couple more circuits and in a couple of days I'll prolly remove that tag after a couple of people proofread it.

On XNOR piston design you can put three repeaters together but facing same direction as toward to output. Also you can put repeater adjacent of piston so they would powered in each side except one side that extend for piston.

A sub for dual edge detectors would be good. Just need to find designs.

If you need a dual edge detector, here's a pretty good one

The end repeater is only there to extend the pulse and make it visible (and to also allow for it to affect torches). Also, I didn't make this. I just remember seeing this in someone's post on some thread a while ago. Dunno who originally made it though.

Umm... that vertical D Flip-Flop doesn't work. Say write is off, data is on, and the output is on. If I turn data off, it should keep it's on state in the output until I activate write, but it doesn't and turn the output off anyway. I believe someone said in that post that that's a D Latch, but not a D Flip-Flop.

Rollback Post to RevisionRollBack

I used to play survival, but then I took an arrow to the knee...
Now I mostly use redstone on creative.

Umm... that vertical D Flip-Flop doesn't work. Say write is off, data is on, and the output is on. If I turn data off, it should keep it's on state in the output until I activate write, but it doesn't and turn the output off anyway. I believe someone said in that post that that's a D Latch, but not a D Flip-Flop.

It works just fine in 1.0.0. Maybe you're playing on another version or built it incorrectly.

1.0.0 changed the way redstone works in some ways, which for example makes the DFF in Metapig's vertical logic thread broken.