The Dauug House Wright State University logo
Dauug|36 minicomputer documentation

Welcome to the Dauucumentation!

This site is the documentation repository for the Dauug|36 minicomputer.

🦖 Do you need a softcopy of this preprint?

The world’s most advanced transparently–functioning computer

Dauug|36 is a 36-bit architecture for owner-built CPUs, controllers, and minicomputers. Only maker-scale assembly tools are necessary, so this architecture can be implemented anywhere on the planet without a semiconductor foundry. All you need is a bare circuit board, about 300 components, and some soldering practice.

Even though Dauug|36 doesn’t even have a microprocessor, it offers 36-bit computing with paged virtual memory, preemptive multitasking, and a rich instruction set of nearly 200 opcodes.

A computer modeled after your own integrity

Many have written about the need for open-source firmware. Of course Dauug|36 delivers this, but it doesn’t stop with the firmware. It’s your own solder that determines and governs the electrical behavior of a Dauug|36 minicomputer. Not somebody else’s secret logic encased in somebody else’s proprietary silicon.

A computer where the manufacturer doesn’t lock out the owner

Most people have no idea the extent to which tamper protection is added to electronics for the exclusive benefit of the manufacturer. But Dauug|36 makes you the manufacturer. You don’t have to necessarily do the soldering yourself—lots of shops have turnkey board assembly at reasonable prices.

When you get your assembled minicomputer, whether your spouse built it or another country built it, everything can be inspected at visible scale, and every net on the circuit board can be accessed via leads and electrically verified at any time.

Low complexity is high security

Remember all those Rowhammer papers? Dauug|36 prohibits DRAM (dynamic random-access memory) within its security perimeter, so there is never an issue with memory cell leakage that can lead to an exploitable defect.

Remember Spectre and Meltdown? Dauug|36 has no memory cache, no speculative execution, and no out-of-order execution, so there is never an issue with these landfill-class vulnerabilities so frequently seen in traditional computers.

Remember practicing stack-smashing attacks in your computer security courses? The Dauug|36 stack uses its own separate SRAM chip that is electrically isolated from all data. There are no buffers or even variables on the stack. In fact, the architecture doesn’t even support stack-based recursion at all, so programs that conform to its intent will never overflow the stack.

Have you seen CERT’s latest guidelines for mitigating silent arithmetic overflow and underflow in C programs? The Dauug|36 arithmetic instructions set a persistent flag whenever a result doesn’t fit in the destination register. So unlike traditional CPUs, a Dauug|36 CPU can be asked at any future time if the result of a long-ago arithmetic instruction was invalid, instead of having to check after every single instruction.

Have you ever been confused as a programmer as to whether a variable should be signed or unsigned? Dauug|36 doesn’t care! In this architecture, you can compute the maximum of a signed register and an unsigned register in one instruction, and write the result to either an unsigned or signed register. The Dauug|36 assembler will select the correct MAX opcode among the eight candidates, and the CPU will compute the correct maximum and indicate correctly—and remember—whether the maximum fits in your destination register. There are no promotion rules to remember: whenever a result fits, the result is correct, and whenever a result doesn’t fit, a flag is set and will remain set.

Install once, upgrade never

Dauug|36 minicomputers are designed to last the lifetime of the real-world critical assets they touch without requiring security updates. What most people don’t realize about security updates is this: computers and software don’t become insecure with the passage of time. They are either insecure at the outset, or they are not insecure.

The manner in which a system is insecure, or the availability of an exploit, generally take time for people to discover. But these vulnerabilities (at least the remotely exploitable ones) are always the outcome of an implementation error or neglect of stewardship by a human. Dauug|36 eschews a broad range of too-frequent security pitfalls, stringently limits the complexity and size of its hardware and firmware design, and places its design on the public record in full.

Marc W. Abel
Computer Science and Engineering
College of Engineering and Computer Science
Without secure hardware, there is no secure software.