Introduction

This is a book about building the tool you probably touch more than any other object you own: your keyboard. Not buying one. Building one, from a bag of circuit boards, sixty tiny switches, and a spool of solder, with your own hands.

The keyboard we are going to build is a Lily58: a small, split keyboard that comes apart into two halves, one for each hand, connected by a cable. It has 58 keys, a little screen on each half if you want one, and a shape that follows where your fingers actually are instead of where typewriter engineering put them in 1878. By the end of the book you will have chosen a kit, ordered every part and tool to a Canadian address with a real budget in Canadian dollars, learned to solder from zero, assembled and flashed the board, typed your first sentence on it, and fixed the one key that inevitably refuses to work on the first try.

The Lily58 is the excuse. The real subject is electronics assembly: reading a circuit board, making a good solder joint, finding a fault with a multimeter, and the quiet confidence that comes from knowing that if a gadget breaks, you are the kind of person who can open it up. Keyboards happen to be the friendliest possible way to learn all of that, because a keyboard kit is dozens of copies of the same three easy joints, and when you are done you get a genuinely excellent tool instead of a practice board destined for a drawer.

Who this is for

You, if you have never held a soldering iron and are not entirely sure which end gets hot. No electronics background is assumed, no programming background is assumed, and every part and tool is priced and sourced for someone shopping from Canada, mostly on amazon.ca plus a handful of keyboard shops that ship here cheaply. If you have soldered before, the soldering school part will be a quick review and the build chapters will still earn their keep.

We do assume you type. If you spend hours a day at a keyboard, for work, for writing, or for games, this project pays for itself in comfort. If you do not, it is still a lovely first electronics build, but a cheaper practice kit might scratch the itch.

What you will be able to do by the end

• Explain what actually happens between pressing a key and a letter appearing, from the switch to the diode to the firmware.
• Choose a first kit with open eyes: Lily58 against its rivals, solder against no-solder, wired against wireless, with honest pros and cons for each.
• Buy everything, parts and tools, from stores that ship to Canada, and know before checkout what the shipping, duties, and taxes will add.
• Solder through-hole and surface-mount-adjacent parts well, spot a bad joint by eye, and rework mistakes without wrecking the board.
• Assemble, flash, and customize a split keyboard, and debug it methodically when a key, a column, or a screen plays dead.

How the book is built

We go in phases, cheapest mistakes first. You do not put an iron to your one and only keyboard PCB in chapter one, the same way a flight school does not start you in the airliner. The order is deliberate:

1. Welcome to mechanical keyboards. What is inside a keyboard, why split boards exist, how to choose a kit, and a guided tour of every part in the Lily58 bag so nothing in the later chapters is a mystery object.
2. Shopping from Canada. Two chapters of pure logistics: the full bill of materials in Canadian dollars with shipping and customs explained, and the tool bench from amazon.ca, from the soldering iron down to the flux pen.
3. Soldering school. Fundamentals and safety, then deliberate practice on cheap boards where mistakes cost pennies, then the rescue skills: desoldering and rework. You arrive at the real build already competent.
4. The build. The Lily58 start to finish: parts check, the soldering sequence, assembly, firmware, troubleshooting, and then actually living with a split keyboard, which is its own small adventure.
5. Reference. A glossary and a curated list of vendors and communities.

A few honest words before we start

This hobby has a reputation for being expensive, and the reputation is earned at the deep end. It does not have to be. We will keep a running total in Canadian dollars for three budgets, and the cheapest one lands near what a decent store-bought mechanical keyboard costs, tools included. The tools stay with you for every future project, so the second build is dramatically cheaper than the first.

Soldering, likewise, has a reputation for being scary. It is a skill on the level of learning to fry an egg: there is a hot thing, there is a technique, the first few attempts are ugly, and then your hands learn it and it stays learned. Sixty hotswap sockets into the build you will be bored, which is exactly the right way to feel while soldering.

And one honest warning about the destination: the first two weeks on a split columnar keyboard, your typing speed will drop. Everyone's does. It comes back, and then some, and your wrists will thank you. We will get you through that dip in the last build chapter.

👉 First, a short note on how to read this book and what the price tags in it mean.

How to read this book

A short orientation before the tour starts.

The shape of each chapter

Most chapters teach a handful of ideas in the same rhythm: what the thing is, why it matters for your build, how it works in plain terms, and takeaways you carry forward. The build chapters are hands-on labs: numbered steps you actually do, each with a clear "you are done when..." so you never wonder whether it worked.

When two words are easy to mix up (a switch and a keycap, soldering and brazing, QMK and VIA), you will see a box like this:

Don't be confused. A switch is the mechanical part under each key that closes an electrical contact when pressed. A keycap is the plastic hat that sits on top of it with a letter printed on it. You buy them separately, and the keycap does nothing electrical at all.

Each chapter ends with a 👉 arrow pointing to the next one, so you always know where the road goes.

About the prices in this book

This book quotes prices constantly, because "budget for it honestly" is half its job. Every price is in Canadian dollars unless marked otherwise, and every price is approximate, as of mid-2026. Keyboard parts come from small shops and overseas warehouses; prices drift, sales happen, and listings vanish. Treat every number here as "expect something in this neighbourhood," and treat the relative comparisons (this vendor is roughly double that one; shipping will be a third of your order) as the durable lesson. Where a price crosses a threshold that changes your customs or shipping situation, we say so explicitly.

The same honesty applies to product links. We name specific products and stores because vague advice ("get a decent iron") is useless to a beginner, but stores rotate stock. If a named product is gone, the surrounding text always tells you what it was so you can find its current equivalent: the specs matter, the brand name does not.

Three ways to read this book

1. The full journey (recommended): read in order. You learn what you are building, buy everything with no surprises, become a competent solderer on cheap practice boards, and then build the Lily58 in one satisfying weekend.
2. "I already know how to solder." Read the welcome part (Chapters 1 to 3) for the keyboard-specific anatomy, do your shopping with Chapter 4 and Chapter 5, skim Chapter 8 for the keyboard-specific rescue notes, then jump to the build at Chapter 9.
3. "I want the keyboard but not the soldering." You have real options: a pre-soldered Lily58, a hotswap-everything kit, or a different board entirely. Chapter 2 maps those exits honestly, including what each costs and what you give up. If you take one, the firmware and living-with-it chapters (12 and 14) still apply to you word for word.

You do not need to buy anything to start reading

You can read the whole book with an empty desk. The shopping chapters exist so that when you do spend money, you spend it once, correctly. Nothing before Chapter 6 requires owning anything, and even soldering school starts with a chapter you should read before the iron arrives.

Safety, in one place

Stated once here, repeated where each matters:

• The iron is 350 degrees Celsius. It looks the same hot and cold. It gets a stand, it gets unplugged when you leave the desk, and it never gets caught when it falls. Chapter 6 covers setup so this stays theoretical.
• Solder fumes are flux smoke, not lead vapor, but you still ventilate: open window, small fan, done. We cover lead versus lead-free solder honestly in Chapter 5, including the wash-your-hands rule.
• Eye protection when clipping leads. Trimmed wire ends fly, fast, in random directions. Safety glasses cost five dollars and are on the tool list.
• Lithium batteries only enter the picture if you choose the wireless variant; the battery handling rules live with that option in Chapter 2 and Chapter 4.

A little bit of code, and why

Building a keyboard ends with flashing firmware, the small program that turns key presses into letters. You will not write firmware from scratch; you will edit a configuration that is mostly a big list of key names, using free web tools where possible. Chapter 12 holds your hand through it. If you can rename files in a folder, you have all the computer skill this book needs.

👉 With that, let us open the case and see what a mechanical keyboard actually is.

What a mechanical keyboard actually is

Before you choose a kit or touch a soldering iron, it pays to understand the object you are about to build. Not at the level of marketing copy ("premium typing experience") but at the level of parts: what is physically inside a keyboard, what each piece does, and how a press of your finger becomes a letter on the screen. Once that picture is in place, every later chapter is just details hanging off it. No background is assumed, and every term gets defined the first time it appears.

Membrane versus mechanical: what actually differs

Almost every cheap keyboard you have ever typed on, including the one built into your laptop, is a membrane keyboard. Under all the keys sits a single flexible plastic sheet (the membrane) printed with conductive traces. Pressing a key squishes a small rubber dome, which pushes two layers of that sheet together at one spot, closing a circuit. One sheet, dozens of keys, a few cents of rubber. It is a marvel of cost engineering.

A mechanical keyboard replaces that shared sheet with an individual, self-contained switch under every single key: a small plastic mechanism with its own spring and its own metal contacts. Fifty-eight keys means fifty-eight separate switches, each one a discrete part you could hold in your hand.

What does that actually buy you? Honestly, three things.

1. Consistency and feel. Every switch is the same mechanism, so every key feels the same, and you can choose exactly what that feel is: how much force, whether there is a bump, whether there is a click. Rubber domes feel mushy by comparison and vary key to key as they age.
2. Durability and repair. A switch is rated for tens of millions of presses, and if one dies you replace that one switch. When a membrane wears out or gets a coffee bath, the whole keyboard is done.
3. Choice. Because switches, keycaps, and boards are separate parts with standard shapes, you can mix and match. That modularity is the entire reason a book like this can exist.

And here is the honest part: membrane keyboards are fine. Billions of people type on them all day without complaint, and if a keyboard is just "the thing between me and the email," a membrane board is a perfectly rational choice. This book exists because you want more than that: a keyboard shaped to your hands, keys that feel exactly how you like, and the experience of having built it yourself. Those are real benefits, but they are benefits of craft and comfort, not necessity.

Don't be confused. "Mechanical" and "gaming" are not the same word. Marketing has glued them together (RGB lights, aggressive fonts, names like VENOM STRIKE), but a mechanical keyboard is defined only by having individual switches. Plenty of mechanical boards are quiet, plain, and office-friendly, and the one you will build has no gamer styling at all unless you add it.

The anatomy, from your fingertip down

Take one key on a mechanical keyboard and slice straight down through it. You pass through these layers, in order:

   your finger
        |
   [ KEYCAP ]        the plastic hat with the letter on it
   [ SWITCH ]        spring + stem + contacts: the mechanism
   [ PLATE  ]        a stiff sheet the switch clips into
   [ PCB    ]        the circuit board that senses the press
   [ CASE   ]        whatever holds it all off the desk

Let us take each one slowly.

The keycap is the removable plastic cap you actually touch. It does nothing electrical. It pulls straight off (there is even a cheap tool for it, the keycap puller, which lands on your shopping list in Chapter 5). Underneath, it grips the switch by a cross-shaped post. Keycaps come in different profiles (sculpted heights and angles), which matters later when we shop in Chapter 4.

The switch is the heart of the whole thing. Inside its plastic housing you find four parts:

• The stem: the colored plastic plunger that moves up and down. Its cross-shaped top is what the keycap grips. The cross shape is called an MX stem, after the Cherry MX switch that standardized it decades ago, and nearly every keycap on Earth fits it.
• The spring: a small coil that pushes the stem back up after you press. Stiffer spring, heavier key.
• The leaf: a pair of thin springy metal contacts. When the stem slides down, it lets the two leaves touch, closing the circuit. That touch is the electrical event that means "key pressed."
• The housing: the plastic shell (a top and a bottom) that holds it all together, with metal pins sticking out of the bottom to connect the leaf to the circuit board.

Switches come in three families, and the family is the single biggest "what does it feel like" decision you will make:

There is no correct answer, only preference. Linears suit people who bottom out every key anyway; tactiles give feedback without noise; clickies are joyful and will get you evicted from any shared office. There is also a second size standard worth knowing now: Kailh Choc switches are low-profile, roughly half the height of MX switches, with a different stem and different pins. They make wonderfully thin keyboards but lock you into a much smaller keycap selection. The Lily58 we build uses full-size MX switches; the Choc option comes up again when we compare kits in Chapter 2.

Don't be confused. The switch and the keycap are separate purchases and separate parts. The switch is the mechanism that does the electrical work; the keycap is the printed plastic hat on top. "I want clicky blue keys" is a switch decision. "I want retro beige keys" is a keycap decision. You can have both at once, or swap either later without touching the other.

The plate is a stiff sheet, usually fiberglass (called FR4), aluminum, or acrylic, with a grid of square holes. Each switch clips into a hole, which holds it perfectly straight and takes the wobble out of typing. Some cheap builds skip the plate and mount switches directly to the circuit board; the Lily58 kit includes one.

The PCB, or printed circuit board, is the flat green (or black, or purple) board that everything electrical lives on. "Printed" refers to the copper traces, thin flat wires printed onto the board, that connect every switch position back to the brain. The PCB is where you will do all your soldering, and Chapter 3 tours the Lily58's PCB in detail.

Here a fork in the road appears, and it shapes your whole build: how does the switch attach to the PCB?

• Soldered: the switch's two metal pins go through holes in the PCB and you solder them in place. Solid, cheap, permanent. Changing switches later means desoldering, which is real work.
• Hotswap: the PCB carries small metal hotswap sockets, one pair per key, and the switch pins simply push into them, no solder needed for the switch. You can pull any switch out with a tool and push a new one in, forever. The catch for a kit builder: on a Lily58 the sockets themselves arrive loose in a bag, and soldering them onto the board is your job. So you still solder, you just solder sockets once instead of committing to switches forever.

The controller is the keyboard's brain: a microcontroller, which is a complete tiny computer (processor, memory, USB hardware) on a single chip, sitting on a small board about the size of a stick of gum. Ours plugs into the PCB. A microcontroller is the same kind of chip that runs your microwave's keypad or a car's window switches: not powerful, not general-purpose, but perfectly suited to one dedicated job. Its job here is to watch the switches and talk to your computer over USB.

The firmware is the program running on that microcontroller. Hardware without a program does nothing; firmware is the "what to do" (which physical switch means the letter Q, what the screen shows, what happens when you hold a thumb key). It is called firmware rather than software because it lives permanently on the chip rather than on a disk. You will install ("flash") and customize yours in Chapter 12, and no, you will not have to write it from scratch.

From press to letter: the key matrix

Now the elegant part: how does the controller know which key you pressed?

The naive design would run one wire from every switch to the controller. With 58 keys that means 58 wires into a chip that has about 18 usable pins. It does not fit, and on a full-size 104-key board it does not fit spectacularly. So every keyboard ever made uses a trick called the key matrix.

Picture the keys arranged in a grid of rows and columns, like a spreadsheet. Wire all the switches in each row together on one shared wire, and all the switches in each column together on another shared wire. Each switch sits at one intersection: pressing it connects its row wire to its column wire. A 5-row by 6-column grid covers 30 keys using only 11 wires. That is the entire trick: 58 keys collapse into a dozen or so pins.

The controller reads this grid by scanning: it puts a signal on row 1 and checks which columns received it (any that did have a pressed key in row 1), then row 2, then row 3, cycling through the whole grid hundreds of times per second. To your reflexes this is instantaneous; to the chip it is a leisurely stroll.

One problem remains, and it is the reason your kit contains a little bag of 58 identical electronic components. Suppose you press three keys at once that form three corners of a rectangle in the grid. Electricity is lazy and flows through any closed path, so current can sneak backwards through one pressed switch, along a wire, and out through another, making a fourth intersection look pressed when it is not. The keyboard reports a key you never touched. This false key is called a ghost, and the phenomenon is ghosting. The mirror-image failure, where the keyboard protects itself by simply ignoring key combinations it cannot disambiguate, is called blocking. Cheap membrane boards do a lot of blocking, which is why mashing three keys in an old game sometimes dropped one.

The fix is a diode at every key. A diode is the simplest useful electronic component: a one-way valve for electricity. Current flows through it in one direction and is blocked in the other. Put one in series with each switch and current can never sneak backwards through a pressed key, so ghosts become impossible and the keyboard can correctly report any combination of keys held at once. That ability has a name you will see on spec sheets: N-key rollover, or NKRO, meaning "all N keys can roll over each other and every one still registers." Soldering those 58 diodes, each smaller than a grain of rice, is the first real task of the build, and the direction they face matters absolutely, which is why Chapter 3 teaches you to read their markings.

The last hop is the easiest to describe. The controller speaks to your computer using USB HID, the Human Interface Device protocol, the same standard language spoken by every mouse and keyboard made this century. When the scan finds a newly pressed switch, the firmware looks up what that grid position means (the letter J, say, or "switch to layer 2") and sends a standard HID report over the USB cable. Your operating system already knows the protocol, which is why a keyboard you built at your kitchen table needs no driver, no app, and no setup: plug it into any computer made in the last twenty years and it types.

Why split, and why the keys line up in columns

Look at your hands on a normal keyboard. Two things are quietly wrong.

First, your hands are forced together. Your shoulders are perhaps 45 centimetres apart, but the letter block of a keyboard is about 15 centimetres wide, so both wrists bend outward, pinky-ward, all day to aim your hands inward. That outward wrist bend has a medical name, ulnar deviation, and it is a documented contributor to wrist strain in people who type a lot. A split keyboard simply cuts the board in two so each half sits in front of its own shoulder, letting your forearms run straight. You can also tent the halves or angle them independently. This is the single biggest ergonomic lever a keyboard has.

Second, look at how the rows are offset. Q sits up and to the left of A, which sits up and to the left of Z. That diagonal row stagger is not ergonomics; it is archaeology. Mechanical typewriters needed each key's lever to reach the platen without colliding with its neighbours, so the rows were offset to make room for the linkages. The levers disappeared 150 years ago; the stagger never did. Your fingers, meanwhile, hinge straight forward and back. Columnar stagger (also called column stagger) arranges each finger's keys in a straight vertical column and then shifts whole columns up or down to match finger length: the middle-finger column sits higher because that finger is longer, the pinky column lower. The Lily58 is both split and column-staggered.

Now the honest note, because this book owes you one. The ergonomic reasoning is sound and the comfort gains are real for many people who type heavily. But there is an adaptation cost, and it is not small: your first one to two weeks on a split columnar board, your typing speed drops noticeably while your fingers unlearn forty years of typewriter compromise. It comes back, usually stronger, but the dip is universal and it is frustrating. And if you type two hours a day without any wrist complaints, the honest statement is that you may never notice a difference beyond "this is comfortable and I made it." Build the keyboard because you want to build it; treat the ergonomics as a strong bonus, not a medical promise. Chapter 14 is entirely about surviving and enjoying the transition.

Sizes, 58 keys, and the magic of layers

Keyboards are sold by size, usually expressed as a percentage of the full 104-key layout:

The Lily58's 58 keys put it in comfortable territory: it keeps the full number row (a genuine kindness to beginners) and gives each thumb a small cluster of keys, sacrificing only the F-row, the arrows, and the navigation keys as dedicated buttons.

So where did those keys go? Into layers, and this idea is the key to every small keyboard. You already use a layer daily: hold Shift and the whole keyboard changes meaning, 3 becomes #, a becomes A. A programmable keyboard generalizes that. Hold a designated layer key (usually under a thumb) and the board remaps: I, J, K, L become arrow keys, the number row becomes the F-row, whatever you choose. Release, and it is a letter board again. Your fingers never leave the home row to reach arrows, which, once learned, feels like a cheat code. You will define your own layers in Chapter 12.

Takeaways

• A mechanical keyboard has an individual switch under every key instead of one shared rubber membrane; membrane boards are fine, mechanical buys feel, repairability, and choice.
• The stack under your finger is keycap, switch, plate, PCB, case, with a microcontroller running firmware as the brain.
• Switches are linear (smooth), tactile (bump), or clicky (bump plus noise); MX is the standard size, Kailh Choc the low-profile alternative.
• Keys are wired in a matrix of rows and columns that the controller scans; a diode per key prevents ghosting and enables full N-key rollover; the result is sent to the computer as ordinary USB HID, no drivers needed.
• Split halves fix ulnar deviation, columnar stagger fixes a typewriter leftover; the comfort is real but so is a one to two week adaptation dip.
• 58 keys keeps the number row; everything missing lives on layers, reached with a thumb key.

👉 Now that you know what lives inside the case, Chapter 2 puts the Lily58 next to its rivals so you can choose your first build with open eyes.

Choosing your first build: Lily58 and its rivals

This book builds a Lily58, but you should not take that on faith. A first keyboard build is a real commitment of money and evenings, and the right board for you depends on decisions nobody can make on your behalf: how much soldering you want to do, how many keys your brain wants, whether a cable between the halves bothers you. This chapter lays out those decisions first, then puts the Lily58 next to its main rivals with honest pros, cons, and Canadian price tags. By the end you will either agree with the book's choice or know exactly which exit to take, and both outcomes are fine.

A reminder from the reading notes: every price below is in Canadian dollars, approximate as of mid-2026, and quoted as a range on purpose. Treat the comparisons between options as the durable information and the absolute numbers as the neighbourhood.

The four decisions that define your build

Decision 1: how much do you want to solder?

There is a spectrum, and every point on it is a legitimate choice:

• A solder kit arrives as bare PCBs and bags of loose parts: diodes, sockets, jacks, controllers. You solder everything. Cheapest, most educational, most hours. This is the book's main path.
• A hotswap-PCB kit has some or all of the fiddly parts pre-installed at the factory, most importantly the hotswap sockets, so your soldering shrinks to a few components or nothing. You pay for the factory's time. Note the vocabulary trap here: "hotswap" describes how switches attach (push in, no solder), and a kit can include hotswap sockets you must solder yourself. The Lily58 kits in this book are exactly that.
• A pre-soldered board is a fully assembled PCB sold as a part: you add switches, keycaps, and a case, and solder nothing. Typeractive.xyz sells the Lily58 this way, among others.
• A prebuilt keyboard arrives in a retail box, done. You are a customer, not a builder.

Since this is a book about learning to solder, we lean toward the left end. But if halfway through soldering school you discover you hate it, the right end of this spectrum is waiting for you with no judgment.

Decision 2: wired or wireless?

A wired split keyboard has a USB cable to the computer and a second small cable (TRRS, explained in Chapter 3) linking the halves. It is simpler, cheaper, and never needs charging. Its firmware is usually QMK, the oldest and largest open-source keyboard firmware project.

A wireless build replaces each controller with a nice!nano (a controller with Bluetooth and a battery charging circuit built in), adds a small lithium battery per half, and runs ZMK, a newer firmware written for wireless from the ground up. The halves talk to each other and to the computer over Bluetooth: no cables at all on your desk.

Wireless is genuinely lovely to live with, and Typeractive.xyz (the shop run by the nice!nano's creator) has made it a well-paved path. It costs more (a nice!nano runs roughly 35 to 45 CAD per half versus 10 to 25 for a wired controller, plus batteries), and it brings lithium battery care into your life: do not puncture or crush the cell, do not solder near it, do not leave it at zero charge for months, and buy the battery from a keyboard vendor who sells the right connector and protection circuit rather than the cheapest cell on the internet. None of this is hard, but it is a real list, and this book's main build skips it by going wired. The wireless route reappears at the end of this chapter as a legitimate exit.

Decision 3: MX or Choc low-profile?

Chapter 1 introduced the two switch sizes. MX is the tall standard: the widest choice of switches by far, thousands of keycap sets, forgiving spacing. Kailh Choc is low-profile: about half the height, shorter travel, and it makes a split board thin enough to slip into a laptop sleeve. The costs are a much smaller keycap universe (mostly flat, mostly blank) and less switch variety. Most boards in this chapter exist in both flavours; the book builds MX because a beginner benefits from the bigger ecosystem. If a slim board is the whole reason you are here, decide now, because the PCB, switches, and keycaps all change together.

Decision 4: how many keys does your brain want?

Small-board people talk about key count the way sailors talk about boat length. The practical question for a beginner is simpler: do you want a physical number row? Boards in the 36 to 44 key range delete it and put numbers on a layer. That works beautifully once learned, but it front-loads the learning: you are adapting to a split layout, columnar stagger, and layered numbers and symbols all in the same two weeks. Boards in the 56 to 60 key range keep the number row, so day one is closer to normal typing. The Lily58's 58 keys are a deliberately gentle landing.

The contenders

Lily58: the book's choice

The Lily58 is an open-source split board: 58 keys, full number row, column stagger, a four-key thumb cluster per side, and a spot for a small OLED screen on each half. Because the design is open source (anyone may manufacture it), kits are sold by many shops at many prices, from polished packages at Canadian and US keyboard stores to bare-bones clone kits on AliExpress and Etsy for a fraction of the price. Typeractive.xyz also sells a wireless, pre-soldered Lily58 variant, which is the no-solder exit mentioned above.

Pros

• Number row and a generous key count: the gentlest split-columnar landing for a beginner.
• Enormous community. Build guides, videos, and troubleshooting threads exist for nearly any problem you will hit.
• Cheap to source: clone kits on AliExpress or Etsy can put the PCB kit portion under 60 CAD.
• Optional OLEDs are a fun, low-stakes extra.
• Open source: no single vendor can strand you.

Cons

• More keys means more soldering: about 58 diodes and 58 sockets per build, roughly 40 percent more joints than a Corne.
• Quality varies across vendors, since anyone can make one. A clone kit may arrive with thin documentation.
• Some layouts eventually feel 58 keys is more than needed; downsizers exist.

Approximate complete-build cost (PCB kit, case/plates, controllers, switches, keycaps, cables; tools excluded): roughly 120 to 350 CAD depending on sourcing, detailed in the totals section below.

Corne (crkbd): the popular minimalist

The Corne, also called crkbd or Helidox, is probably the most popular split kit in the world: 42 keys, three rows plus thumbs, no number row. It shares most of its DNA and ecosystem with the Lily58 (same controllers, same firmware, similar parts bag), and it is slightly cheaper and slightly less soldering. The price is that numbers, symbols, and the F-row all live on layers from day one. Plenty of first-time builders manage it happily; plenty of others wish they had eased in.

Pros: biggest community of any split board; cheapest to build; less soldering; forces good layer habits immediately. Cons: aggressive layer reliance on day one; no number row is a real adjustment for spreadsheet and data work. Approximate complete build: 110 to 320 CAD.

Sofle: the Lily58 with knobs

The Sofle is close kin to the Lily58: 58 keys plus support for one or two rotary encoders, the twistable knobs you can map to volume, scrolling, or zoom. If a volume knob makes you grin, this is your board. The encoder is one more part to solder and one more thing to configure in firmware, so it adds a little complexity for a fun rather than essential feature.

Pros: everything the Lily58 offers plus knobs; similar community and sourcing. Cons: slightly more parts and firmware fiddling; kit availability is a bit thinner than Lily58 or Corne. Approximate complete build: 130 to 360 CAD.

Iris and Iris CE (Keebio): the polished one

Keebio is a long-running US keyboard shop, and the Iris (56 keys) is its flagship split: a more finished product than the community kits, with tidy documentation, an integrated controller on current revisions (no separate Pro Micro to buy or socket), and options like per-key lighting. The Iris CE goes further: it ships pre-built and hotswap, so it is a "plug in switches and type" product, at a correspondingly higher price. Buying from Keebio in Canada means US shipping and possibly duties; check their current shipping page before ordering.

Pros: polished hardware and docs; a single vendor accountable for the whole kit; CE removes soldering entirely. Cons: costs more than community kits; one vendor, one stock level; shipping from the US adds cost and border friction. Approximate: Iris kit path complete build 250 to 400 CAD; Iris CE with switches and keycaps roughly 300 to 450 CAD.

Ergodox EZ and Voyager (ZSA): the buy-it-done option

ZSA sells finished, warrantied ergonomic split keyboards: the long-running Ergodox EZ and the slim, travel-friendly Voyager. Zero soldering, zero assembly, excellent configuration software (Oryx) that requires no firmware fiddling at all, and a real warranty with a real support team. The price is the price: expect in the neighbourhood of CAD 500 landed in Canada, sometimes less on sale, sometimes more with options. If your reaction to soldering school is "absolutely not," this is the premium version of that honesty.

Pros: no build risk at all; superb software and support; warranty. Cons: around triple the cost of a budget self-build; you learn nothing about electronics; less "yours" in the way this book cares about.

The non-split sanity check: a Keychron hotswap board

One more honest option, for a reader partway through this chapter thinking "actually, I am not sure about the split part at all." A mainstream hotswap mechanical board, such as one of Keychron's V or K series (roughly 100 to 150 CAD on amazon.ca or Keychron's site), gives you mechanical switches, swappable switches, and programmable firmware in a normal, familiar shape. No adaptation period, no soldering, no layers required. Some people buy one, love it, and stop there; others use it as the daily driver while their Lily58 parts cross the Pacific. Neither is failure.

Side by side

Don't be confused. A kit and a prebuilt both arrive in a box, but a kit is a box of parts and a prebuilt is a keyboard. Listings do not always shout the difference. If the product page mentions soldering, diodes, or "PCB only," it is a kit or a bare part; if it shows someone typing on it out of the box, it is prebuilt. When in doubt, the price usually tells you: a 60 dollar Lily58 is parts, a 300 dollar one is probably assembled.

Who should not build a Lily58

Read this section as a friend, not a salesperson.

• You need to be typing at full speed next week. The build takes evenings, shipping takes weeks if you go the AliExpress route, and the layout adaptation takes one to two more. A deadline and a first build do not mix.
• You mostly play fast games. Many gamers keep a conventional board for games (row stagger and dedicated keys have muscle-memory value there) even when they love a split for work. You might be buying two keyboards, not one.
• Numbers are your livelihood. The Lily58 has a number row but no number pad. If you live in spreadsheets ten hours a day, try layers first on your current board (most operating systems or a Keychron can fake it) before betting on them.
• You want zero risk of a dud. A first solder build carries a real, if small, chance of a dead column and a frustrating evening with a multimeter. Chapter 13 exists because of it. If that possibility ruins the fun rather than adding stakes, buy the ZSA or the Iris CE and enjoy them without guilt.
• The total honest cost bothers you. Add tools (Chapter 5, roughly 80 to 150 CAD if you own nothing) to the build cost. If the sum stings, a Keychron delivers most of the mechanical-keyboard experience for a third of the money.

Why this book proceeds with the wired, solder-it-yourself Lily58

Three reasons, in order of weight.

First, it teaches the most per dollar. The wired solder kit is the cheapest complete path in the table, and it is the only path where you practice every skill this book promises: reading a PCB, through-hole soldering, surface-mount-adjacent soldering on sockets and diodes, socketing a controller, flashing firmware, and multimeter debugging. Every other path deletes some of the curriculum.

Second, the Lily58 specifically is the gentlest full-curriculum board: the number row softens the layout transition, the community is huge when you get stuck, and the parts are commodity items sold by a dozen vendors, several of them Canadian (Chapter 4 names them).

Third, wired keeps the failure surface small. A first build has enough unknowns without adding Bluetooth pairing, battery polarity, and split-wireless firmware to the debugging space. Cables are boring, and boring is what you want under everything you are learning.

That said, mark the exit clearly: the Typeractive wireless, pre-soldered Lily58 is a legitimate way to own this exact keyboard without building it. You buy their assembled board, nice!nanos, batteries, switches, and keycaps; you assemble with a screwdriver; you configure ZMK with their web-based tooling. Expect the premium end of the price range. If you take that exit, skip the soldering chapters entirely and rejoin the book at Chapter 11; the firmware chapter covers ZMK's equivalents, and Chapter 14 applies to you word for word.

The three budgets, named

These totals recur through the shopping chapters, so let us name them once. All are complete builds (parts only, tools separate), approximate as of mid-2026:

• Budget, roughly 120 to 180 CAD: AliExpress or Etsy Lily58 clone kit, budget Gateron switches, basic keycaps, generic cables. Slow shipping, thin documentation, real keyboard at the end.
• Mid-range, roughly 250 to 350 CAD: kit and parts from dedicated keyboard shops (Canadian ones where possible), name-brand switches you chose on purpose, keycaps you actually like, faster shipping and someone to email.
• Premium or wireless, roughly 350 to 500 CAD: the Typeractive wireless route, or a wired build with premium everything.

Chapter 4 breaks each budget into a line-by-line bill of materials with vendors and shipping honestly included.

Takeaways

• Four decisions define the build: how much solder (kit, hotswap PCB, pre-soldered, prebuilt), wired or wireless (nice!nano and ZMK versus cables and QMK), MX or Choc, and how many keys (really: do you want a number row).
• The Lily58 wins for this book on gentle key count, community size, cheap sourcing, and teaching value; Corne is smaller and more layer-hungry, Sofle adds knobs, Iris CE and ZSA boards trade money for zero build risk, and a Keychron is the honest non-split fallback.
• Complete-build neighbourhoods: budget 120 to 180, mid-range 250 to 350, premium or wireless 350 to 500 CAD, plus tools.
• The wireless pre-soldered Typeractive Lily58 is a real exit, not a consolation prize; take it and rejoin at assembly if soldering is not your hobby.

👉 Decision made (or at least framed), it is time to meet the patient. Chapter 3 opens the Lily58 kit bag and identifies every single object inside.

The Lily58 up close

A Lily58 kit arrives as a padded envelope full of smaller bags, and the first time you tip them out onto a desk it looks like someone disassembled a calculator and mailed you the evidence. This chapter is the guided tour: every object in those bags, what it does, why it is shaped the way it is, and the handful of facts about each one that will matter when the soldering iron comes out. By the end, nothing in the later chapters will be a mystery object. Exact contents vary a little between vendors (a clone kit may skip the OLEDs, a nicer kit may include extras), so treat this as the canonical parts list and check it against what your vendor's page says is included.

The two PCBs, and the word "reversible"

The biggest things in the box are two PCBs (printed circuit boards, introduced in Chapter 1): flat fiberglass boards, usually black or white, each one shaped like half a keyboard with a grid of switch positions and a cluster of smaller holes near the top edge.

Here is the fact that shapes the entire build, so it gets stated early and often: the two boards are identical. The designer did not draw a left board and a right board; they drew one board and you flip one of them over. This is called a reversible PCB, and it is a cost trick (manufacturing one design is cheaper than two) with one enormous consequence for you:

Every component must be soldered onto the correct side of each board, and the correct side is different for the left and right halves.

The boards have components on one face and switches on the other. Which face is which depends on whether that board is playing the left half or the right half. Solder your diodes to the wrong face and you have built two left halves, and the fix is an evening of desoldering (Chapter 8 exists partly for this). The build chapters will drum this in with a mark-the-boards ritual before any solder flows (Chapter 9), but plant the idea now: with a reversible PCB, which side is the first question about every single part.

The silkscreen (the printed white lettering on the board) helps: component outlines and labels are printed on the side the parts go on, and most Lily58 PCBs print a marker telling you which face you are looking at. Learn to trust the silkscreen; it is the board's own instruction manual.

58 diodes: the one-way valves

A small bag holds the smallest components in the kit: about 58 diodes (plus, from a considerate vendor, a few spares). Chapter 1 explained their job: one per key, each acting as a one-way valve for current so the key matrix can tell any combination of pressed keys apart without ghosts.

The part itself is a 1N4148, a signal diode so common and so old it is practically the alphabet of electronics. It comes in two packages, and your kit has one or the other:

• Through-hole: a tiny orange-red glass bead with a wire leg sticking out of each end. You bend the legs, feed them through two holes in the PCB, solder, and snip. The glass bead has a black band painted around one end.
• Surface-mount (SMD), the variant called 1N4148W: a black speck about the size of a grain of rice with two flat metal ends that solder directly onto pads on the board's surface. It has a painted line across one end.

That band or line marks the cathode: the end current flows out of. The valve only works one way, so the diode only works installed one way. The PCB's silkscreen prints a matching bar (or the bar of a diode symbol) at each diode position; your entire job, 58 times, is to point the band at the bar. A diode installed backwards does not break anything, but its key will never register, and "one dead key in an otherwise perfect board" is the classic signature of one flipped diode. Chapter 13 will send you looking for exactly this.

58 hotswap sockets

Another bag: about 58 Kailh hotswap sockets, small black plastic pieces with two shiny metal contacts, shaped a bit like a tiny pair of headphones. Each one solders onto the back of the PCB over a switch position, and afterwards a switch's two pins push into it from the other side, no solder on the switch itself, ever.

What hotswap buys you, concretely: you can try different switches next month without desoldering anything; you can replace one dead switch in thirty seconds; you can lend your board a whole new personality for the cost of switches alone. What it costs you: the sockets themselves (cheap) and the job of soldering them on (yours). Soldering sockets is surface-mount work, but of the friendliest possible kind: the contacts are huge by SMD standards, and after the first ten you will do them on autopilot. They are the "sixty easy joints" the introduction promised.

Don't be confused. The hotswap socket and the switch are two different parts. The socket is soldered to the PCB once, permanently, by you. The switch clicks into the socket and can be swapped forever after. "Hotswap keyboard" does not mean no soldering happened; it means the soldering happened once, to sockets, so the switches never need any.

Two TRRS jacks, and the cable rule

Two small metal-and-plastic sockets, one per board, each with four little legs: these are TRRS jacks, and they are how the halves talk to each other. TRRS stands for Tip, Ring, Ring, Sleeve, which describes the four metal segments on the plug of a TRRS cable: the same 3.5 mm plug as old wired headphones with a microphone. One half of the keyboard (the one plugged into the computer over USB) acts as the brain for both; the TRRS cable carries power and data across to the other half.

One rule about this cable outranks all others, so here it is in bold before the tour continues: never plug or unplug the TRRS cable while the keyboard is connected to USB power. The reason is mechanical: as the plug slides in or out, its segments drag across the jack's contacts, momentarily connecting the power line to pins that were never meant to receive power. That instant of wrong wiring can kill a controller. The habit to build is unbreakable and simple: USB out first, then touch the TRRS. The assembly and living-with-it chapters (11 and 14) repeat this because it is the easiest way to break an otherwise finished keyboard.

Two reset switches

Two tiny rectangular buttons with four legs: tactile reset switches. Each solders to a marked spot on its PCB. Pressing one restarts the controller, and more importantly, a press (or double press, depending on the controller) puts it into bootloader mode, the state where it accepts new firmware. You will press these a great deal during Chapter 12 and essentially never afterwards. They are the least glamorous part in the bag and among the most useful.

Two controllers: the Pro Micro and its descendants

Two small boards, each about 33 by 18 mm with a USB connector on one end and a row of twelve holes down each long side. These are the brains, one per half, and the holes are how they connect to the keyboard PCB.

The Lily58, like most split kits, is designed around the Pro Micro footprint. The original Pro Micro is a minimal board built around the ATmega32u4 microcontroller, and its physical shape (size, pin arrangement) became a standard the way MX stems did: dozens of newer, better boards copy the footprint exactly so any of them drops into any Pro Micro-shaped kit. Your kit or vendor will have supplied one of these:

• A classic Pro Micro (ATmega32u4): cheapest, everywhere, runs QMK happily. Two warnings. First, many classic units still use a micro-USB connector, and the Pro Micro's micro-USB port is infamous for tearing clean off the board if the cable is yanked; builders reinforce it with a blob of epoxy. Prefer a USB-C clone if you are buying separately; they cost a dollar or two more and remove the problem. Second, the ATmega32u4 is an old chip with little memory; it runs a keyboard fine but has no headroom for fancy extras.
• An RP2040-based drop-in, such as the Elite-Pi (Keebio) or Frood: same footprint, USB-C, a modern RP2040 processor (the chip from the Raspberry Pi Pico) with vastly more memory, and drag-and-drop flashing where the board appears on your computer as a little USB drive. A few dollars more, and the recommended choice in Chapter 4 if your kit lets you pick.

Either path works with this book; the firmware chapter covers both flashing procedures.

Don't be confused. A Pro Micro is not an Arduino, though the words travel together. Arduino is a brand of beginner-friendly microcontroller boards and the software around them; the Pro Micro is a third-party design that happens to be programmable with Arduino tools. For this build the distinction barely matters, because you will never touch the Arduino software: keyboard firmware (QMK) has its own toolchain. If a listing says "Pro Micro compatible" or "Arduino Pro Micro," it means the same physical footprint, which is the only compatibility the Lily58 cares about.

Sockets for the controller: the Mill-Max question

Your kit includes strips of header pins: rows of metal pins in a plastic spacer, meant to be soldered into the controller's twelve-hole rows and then into the PCB, joining the two permanently. That is the standard, cheapest way, and it works.

This book will argue for spending a few extra dollars on socketing instead: solder low-profile sockets (round machined ones, commonly called Mill-Max sockets after the main manufacturer) into the keyboard PCB, press matching pins into the controller, and the controller then plugs in and pulls out like a chip in an old computer. The argument is blunt: the controller is the most likely part of your keyboard to die. It carries the USB connector (yank hazard), it is what a TRRS hot-plug kills, and it is the only complex component on the board. A soldered-in dead controller means desoldering 24 joints from under a board, one of the nastiest rework jobs there is. A socketed one means pull, replace, done, about 15 CAD and five minutes. The parts (sockets plus pins) run roughly 10 to 20 CAD for both halves from keyboard vendors; Chapter 4 prices the options, and Chapter 10 covers the small extra care socketing takes (the OLED can crowd the socket height, which is why low-profile Mill-Max parts are the standard advice).

Two OLED displays (optional, delightful)

If your kit includes them: two small OLED displays, each a little glass window on a four-hole carrier board. The standard part is an SSD1306 controller driving a 128 by 32 pixel screen, which is enough for a logo, the active layer name, or a bouncing animation. Each connects to its half through a four-pin header (supplied) soldered to marked holes near the controller.

Two build notes to file away now. First, many Lily58 PCB revisions have solder jumpers for the OLED: two tiny bare copper pads printed close together, which you bridge with a small blob of solder to connect the display's data lines. Unbridged jumpers are a classic "my screen is dead but everything else works" cause. Second, the OLED sits directly above the controller, which is exactly the height-clearance interaction the socketing section mentioned. Both come up again, with pictures of the sequence, in Chapter 10. If your kit has no OLEDs, nothing else changes; the keyboard neither knows nor cares.

Plates, standoffs, screws, and feet

The flat, key-shaped sheets in the box are the plates, usually FR4 (the same fiberglass as the PCB) or acrylic:

• The top plate (or switch plate) carries the grid of square holes; switches clip into it before meeting the PCB, which holds them straight and rigid.
• The bottom plate is the keyboard's floor, protecting the solder side from your desk.

Joining them: a bag of M2 standoffs (small threaded metal pillars) and M2 screws. The sandwich is bottom plate, standoffs, PCB, more standoffs, top plate, and Chapter 11 walks the order. Also in the bag: bumpons, small adhesive rubber feet for the underside, so the finished board neither slides nor scratches.

Switches and keycaps

These usually arrive in their own boxes, chosen and bought separately (Chapter 4): 58 MX-style switches (buy 60 or more; spares are cheap insurance) and 58 keycaps. One shopping note that bites beginners: the Lily58 uses only small keys, so you need a keycap set that includes enough 1u caps (1u is one standard key width) plus a few 1.5u for the inner thumb keys, depending on your preference. Ordinary keycap sets designed for normal keyboards usually cover this, but check the set's contents list. Profile means the sculpted shape and height of the caps across rows; on a column-staggered board many builders pick a uniform profile (every cap the same shape, such as DSA or XDA) so caps can move between positions freely, but sculpted profiles work too. This is aesthetics and feel, not electronics; nothing breaks either way.

One half, mapped

Component side of one half, roughly (not to scale, an illustrative sketch rather than an exact board drawing):

        USB
         |
   +-----------------------------------------+
   | [controller]  [OLED]      o  <- reset    |
   |  (12 holes    (4 holes)   [TRRS jack]    |
   |   per side)                              |
   |                                          |
   |  [s][s][s][s][s][s]     each [s] is one  |
   |  [s][s][s][s][s][s]     switch position: |
   |  [s][s][s][s][s][s]     hotswap socket + |
   |  [s][s][s][s][s][s]     diode            |
   |  [s][s][s][s][s][s]                      |
   |               [t][t][t][t]  <- thumb keys |
   +-----------------------------------------+

Thirty switch positions on one half, twenty-eight on the other (the thumb clusters differ by one key), 58 in all.

The ritual: lay it all out and count it

Before any real build begins, Chapter 9 will have you do a full inventory: every bag opened over a tray (SMD diodes bounce, and carpet eats them), every part identified using this chapter, every count checked against the vendor's kit list. Here is the checklist you will use, so it looks familiar when you meet it again:

Missing or damaged parts discovered now cost an email to the vendor; discovered mid-solder, they cost a stalled build. Count first.

Takeaways

• The two PCBs are identical and reversible: one is flipped to become the other half, so which side each part goes on is the first question of the entire build.
• The diodes (1N4148, glass bead or rice-grain SMD) are direction-sensitive: band toward the silkscreen bar, 58 times.
• Hotswap sockets are soldered once so switches never are; the socket and the switch are different parts.
• Never hot-plug the TRRS cable: USB out first, always, because a sliding plug can feed power to the wrong pins and kill a controller.
• The controller (classic ATmega32u4 Pro Micro or an RP2040 drop-in like the Elite-Pi or Frood) is the likeliest part to die, which is the argument for Mill-Max socketing it instead of soldering it in; prefer USB-C over fragile micro-USB.
• Optional OLEDs (SSD1306, 128x32) need their headers and possibly solder jumpers bridged, and they crowd the controller's height.
• Plates, M2 standoffs, screws, and bumpons form the case sandwich; switches and keycaps come separately, and the inventory ritual in Chapter 9 counts everything before solder flows.

👉 You now know every object in the bag by name. Time to fill the bag: the shopping chapters begin with Chapter 4, the full bill of materials in Canadian dollars.

The full bill of materials, in Canadian dollars

In Chapter 3 you met every part in the Lily58 bag and learned what each one does. Now we buy them. This chapter is the complete shopping list for a wired, solder-it-yourself Lily58 with hotswap sockets, priced in Canadian dollars, sourced from stores that actually ship here, with the customs and shipping math done in the open so nothing surprises you at the door.

One reminder from the how-to-read chapter: every price below is approximate as of mid-2026. Stores rotate stock and currencies drift. The neighbourhoods and the relative comparisons are the durable part.

The master list

Here is everything, at a glance. Each row gets its own section below with real buying advice.

Add tools and consumables from Chapter 5 and you have the entire project.

The Lily58 PCB kit

The heart of the order. A PCB kit is the pair of printed circuit boards (one left, one right, and they are different, not mirror copies of the same board) plus the small electronic parts that solder onto them: about 58 diodes, 58 hotswap sockets, two TRRS jacks, and two reset switches. Most sellers bundle all of this together under a name like "Lily58 PCB kit" or "Lily58 Pro kit", and the bundle is what you want. Buying the bare boards and hunting down the small parts separately saves almost nothing and multiplies the ways to get a wrong part.

Where to find one:

• Etsy.ca. Search "Lily58 PCB kit" and filter by seller location. A number of small makers, including Canadian ones, sell exactly this bundle. A Canadian Etsy seller is the jackpot: domestic shipping, no customs, and you can message a human with questions.
• AliExpress. The same search phrase. Cheapest by a wide margin, often the full kit with case plates included, with the usual AliExpress trade: two to five weeks of waiting and photos you should read skeptically. Check the listing text confirms hotswap sockets and diodes are included.
• US keyboard shops. Little Keyboards and Boardsource both carry Lily58 boards and parts, priced in US dollars, and ship to Canada. Clear listings, fast support, and you pay for that in exchange rate and shipping.
• Custom KBD (Australia) also stocks Lily58 kits and ships worldwide, worth a look when others are out of stock.

Expect roughly CAD 40 to 80 for the PCB kit once converted, before shipping. When comparing listings, the checklist is: both PCBs, diodes, hotswap sockets, TRRS jacks, reset switches. If a listing is vague about any of those, ask or move on.

Don't be confused. "Hotswap" in this book means hotswap sockets for the switches, so you can pull a switch out later without desoldering. You still solder those sockets on, along with everything else. It is not the same as a "no-solder" keyboard, where the factory already did all of this. We chose the solder-it-yourself hotswap route in Chapter 2 because it teaches the most and forgives the most.

Case and plates

The Lily58's usual "case" is a sandwich: a top plate the switches clip into, a bottom plate that covers the solder side, and a set of M2 standoffs and screws (M2 is the thread size, two millimetres) holding the layers apart. Plates are cut from FR4 (the same fibreglass material as the PCB itself, cheap and sturdy) or acrylic (clear plastic, shows off your work, cracks if you overtighten).

Many PCB kit listings, especially on AliExpress and Etsy, include the plates and hardware. Read the listing carefully; "PCB only" means you will be ordering plates separately from the same sort of vendor for another CAD 20 to 50. Getting plates and PCBs from the same seller in one order is worth a few dollars of premium, because they are guaranteed to match.

Controllers: two Pro Micro compatibles, and which kind to get

Each half of the Lily58 carries a microcontroller, a thumb-sized computer board that scans the switches and speaks USB to your computer. You need two. The Lily58 is designed around the footprint of the classic Pro Micro, so anything sold as "Pro Micro compatible" fits the same holes.

Within that footprint there are two families, and the choice is easy:

• RP2040 boards with USB-C (sold as Elite-Pi, Frood, or generic "RP2040 Pro Micro" on AliExpress and amazon.ca). These use the Raspberry Pi RP2040 chip: 16 MB of storage, a sturdy USB-C connector, and firmware flashing that works by dragging a file onto what looks like a USB drive. Roughly CAD 8 to 25 each depending on vendor. Buy these.
• Classic ATmega32u4 Pro Micros with micro-USB. This is the 2016 option: 32 KB of storage (modern firmware barely fits), and a micro-USB port that is infamous for ripping clean off the board if the cable gets yanked. The only reason to choose one today is a legacy firmware setup that specifically requires the ATmega chip, which does not apply to this build.

Search terms that work: "RP2040 Pro Micro USB-C" on AliExpress or amazon.ca, or the names Elite-Pi (Keebio) and Frood at keyboard shops. Canadian shops, including Clickety Split, stock Pro Micro compatible controllers too, which keeps the whole order domestic.

Sockets and Mill-Max pins for the controllers

Strongly recommended, and here is the pitch. The controller is the one part of this build that both costs real money and can die (a botched flash, a static zap, a failed USB port). If you solder it directly to the PCB, replacing it means desoldering 24 joints from your finished keyboard, which is the hardest rework job in this hobby. If instead you solder cheap socket strips to the PCB and press Mill-Max pins (precision machined pins, named for the main manufacturer) into the controller, the controller just plugs in like a cartridge and pulls out the same way.

The insurance costs about CAD 10 to 20 for enough sockets and pins for two controllers, sold as a "controller socketing kit" at keyboard shops or as Mill-Max 0305 pins plus female headers at Digi-Key Canada (more on Digi-Key in Chapter 5). It also lifts the controller a few millimetres, which matters if you add OLEDs. Pay the twenty dollars.

OLED screens (optional)

Each half can carry a small OLED display, the 128 by 32 pixel kind built on the SSD1306 chip (that chip name is the search term). They show the active layer, a logo, or whatever the firmware draws, and they peek through a window in many Lily58 cases. Entirely optional, mildly delightful, and cheap: about CAD 5 to 15 for a pair on AliExpress or amazon.ca. Search "SSD1306 128x32 OLED". Make sure you get the 128x32 size, not the squarer 128x64, which does not fit the Lily58's header position or cover.

The cables

Two cables, one of which hides a classic beginner trap.

The two halves talk to each other through a TRRS cable, a cable with 3.5 mm headphone-style plugs. TRRS stands for tip, ring, ring, sleeve: the four metal segments on the plug, giving four conductors. The Lily58 needs all four. A TRS cable (tip, ring, sleeve, three segments, the standard aux audio cable) looks nearly identical and will not work, or will work in a maddening half-broken way.

Don't be confused. Count the black separator rings on the plug. Three rings between four metal segments means TRRS, correct. Two rings means TRS, an audio cable, wrong. Listings that just say "aux cable" are usually TRS. Search "TRRS cable 4 pole" on amazon.ca and expect CAD 5 to 15.

You also need a USB-C cable from the left half to your computer, and it must be a data cable, not a charge-only one. Charge-only cables are common freebies with gadgets and are the source of many "my keyboard is dead" panics (we will meet this again in Chapter 13). Any USB-C cable that has ever synced data for you is fine, so this line is often free.

Switches: 60 or more, and the per-switch math

The Lily58 has 58 keys, so you need 58 MX-style switches (MX is the de facto standard stem and pin layout, from the original Cherry MX design). Buy at least 60; spares cost cents and a bent pin costs a switch.

Switch shopping is per-switch economics. Prices run from about CAD 0.35 to 1.20 per switch, so a board's worth is CAD 21 at the bottom and CAD 72 at the top. The budget default this book recommends is the Gateron Milky Yellow, a smooth linear switch, usually near the bottom of that range, with a huge fan base at ten times the price point. If you already know you love clicky or tactile switches, buy what you love; Chapter 1 covered the differences.

Where to buy matters more for switches than any other part, because switches are heavy. Sixty switches plus keycaps is a few hundred grams, and international shipping is priced by weight. Canadian shops shine here:

• Deskhero.ca (British Columbia): big switch selection, quick Canada Post shipping.
• Apex Keyboards (Calgary): switches, keycaps, and accessories.
• Ashkeebs (Ontario): switches and DIY parts.
• Clickety Split (clicketysplit.ca, Edmonton): the Canadian shop that specializes in split keyboards specifically, and stocks controllers, TRRS cables, and sockets alongside switches, so it can cover half this table in one domestic order.
• AliExpress and amazon.ca also sell Gateron switches; AliExpress often wins on raw price and loses on wait.

Keycaps: the shape matters more than the brand

Keycaps are the plastic hats, sold in sets, and the Lily58 makes one unusual demand: its keys are almost all the same size, 1u (one unit, the width of a letter key), plus two 1.5u thumb keys. A normal keycap set is shaped for a normal keyboard, with wide shift keys and a long spacebar you cannot use, and worse, its rows have different sculpted heights that look odd on the Lily58's column-staggered layout.

The clean answer is a uniform profile set, where every cap is the same shape: XDA and DSA are the two common uniform profiles, and sets sold as "ortho" (for ortholinear keyboards) are built exactly for boards like this, heavy on 1u caps. Check the listing includes at least a couple of 1.5u caps for the thumbs.

Legends or blank? Blank caps (no letters) are cheaper, always in stock, and a surprisingly practical choice because Chapter 12 will have you moving keys around anyway. Legended caps are friendlier for the first two weeks. No wrong answer.

Budget: a cheap AliExpress XDA set runs CAD 25 to 40; a decent PBT set (a harder, grippier plastic that does not go shiny with wear) from a Canadian or US shop runs CAD 30 to 60. Search "XDA blank keycaps" or "DSA ortho keycap set".

Sidebar: the wireless variant

This book builds the wired Lily58, but Chapter 2 mentioned the wireless exit, so here is its bill of materials delta. Wireless replaces the two controllers with two nice!nano v2 boards (a Pro Micro compatible with Bluetooth, about CAD 35 to 45 each), adds two small LiPo batteries (lithium polymer; sizes around 301230, a code meaning 3 mm thick, 12 mm wide, 30 mm long, though anything similar that fits under the controller works), and two tiny power switches. The TRRS cable disappears; the halves talk over Bluetooth.

Typeractive.xyz, the shop behind the nice!nano, sells all of this and even bundles complete wireless Lily58 kits, which is the least error-prone way to go wireless. Two cautions for Canadians: everything is in USD, and loose lithium batteries are restricted in air mail, so battery shipping options to Canada can be limited or slower, and some vendors will not ship batteries here at all. Buying batteries domestically (Canadian keyboard shops and electronics shops stock compatible LiPos) sidesteps that entirely. Budget roughly CAD 100 to 150 extra over the wired build, and note the battery-handling safety rules in Chapter 0.

Getting it all to Canada: the logistics

Now the part that this book exists for. Here is the vendor landscape from a Canadian chair:

Duties, taxes, and brokerage, in plain words

Three different hands can reach into an imported parcel, and beginners blur them together:

• Duty is an import tariff on the goods themselves. Good news: consumer electronics and keyboard parts are almost all duty-free into Canada regardless of origin, so duty is usually zero for this hobby.
• Tax is your regular GST/HST, owed on imports just like on local purchases. This one is real and unavoidable in the long run.
• Brokerage is a service fee the courier charges for doing the customs paperwork. It is not a government charge at all, and it is the one that stings: UPS and FedEx ground shipments commonly add CAD 10 to 30 in brokerage on top of the tax. Canada Post charges a flatter CAD 9.95 handling fee when it collects on a postal import, and often small parcels sail through with nothing collected.

Don't be confused. When a courier demands "customs charges" at your door, read the breakdown. The tax portion is legitimate and you would owe it anywhere. The brokerage portion is the courier billing you for paperwork, and the way to avoid it is choosing vendors and shipping methods, not arguing at the door.

There is also a floor under all of this, the de minimis threshold. Under the CUSMA trade agreement, parcels arriving by courier from the US or Mexico are duty-free under CAD 150 and tax-free under CAD 40. Parcels by post, or by courier from anywhere else, use the old threshold: CAD 20. So a USD 60 controller order couriered from a US shop typically arrives with tax owing but no duty, and whether you pay a fee at the door depends mostly on who carried it. AliExpress, meanwhile, has collected GST at checkout since 2021, which is why those parcels almost never come with a surprise bill.

Rules of thumb

1. Buy heavy things in Canada. Switches and keycaps dominate the parcel weight. A Canadian shop's CAD 12 Canada Post rate beats any international option once weight is involved, and there is no customs step at all.
2. Light and cheap can come from anywhere. PCBs, controllers, OLEDs, and cables weigh almost nothing; US or AliExpress shipping is fine for them.
3. Consolidate. Every separate international order is a separate shipping fee and a separate roll of the brokerage dice. Two orders beats five.
4. Prefer postal or "economy" shipping from US shops over UPS/FedEx ground when offered, precisely to dodge brokerage.

Three complete carts, landed in CAD

Three honest ways to buy this keyboard, end to end. All figures approximate, mid-2026, tax assumed at 13 percent HST (adjust for your province).

Cart A: budget, AliExpress-heavy, lands around CAD 130 to 180. Lily58 PCB kit with plates from AliExpress, generic RP2040 controllers, OLEDs, TRRS cable, Gateron Yellow switches, and an XDA keycap set, all from AliExpress with GST collected at checkout. Add a socketing kit from a Canadian shop. The cost is time: plan on a month before everything is on your desk.

Cart B: mid-range US and Canada mix, lands around CAD 250 to 350. The worked example, line by line:

Two orders total, everything arrives inside two weeks, and every vendor has a support inbox that answers.

Cart C: wireless via Typeractive, lands around CAD 350 to 500. The complete wireless bundle (boards, nice!nanos, batteries if they will ship them, cases) plus switches and caps. The nice!nanos alone are about CAD 90 of the difference, USD pricing and exchange do the rest, and batteries may need a separate domestic purchase per the sidebar above.

How long you will wait

Honest wait times, because the parcel-tracking phase of this hobby is real: AliExpress, two to five weeks. US shops, one to two weeks with postal shipping, sometimes faster by courier (at brokerage risk). Canadian shops, two to six days. If you want to build on a specific weekend, count backwards from it and order the slow things first. And if a slow parcel is in flight, Chapter 6 and Chapter 7 are exactly what the wait is for.

Takeaways

• One PCB kit, two RP2040 USB-C controllers, sockets and pins for them, a TRRS (four-pole!) cable, 60+ switches, and a uniform-profile keycap set is the whole keyboard. OLEDs are a cheap, optional treat.
• Socket your controllers. It is CAD 10 to 20 against the worst rework job in the hobby.
• Duty is nearly never the problem; courier brokerage fees and HST are. Buy heavy items (switches, caps) from Canadian shops, light items from anywhere, and consolidate orders.
• Landed budgets: about CAD 130 to 180 patient and cheap, CAD 250 to 350 comfortable, CAD 350 to 500 wireless.
• Order before you need it: AliExpress in weeks, the US in a week or two, Canada in days.

👉 Parts are only half the shopping. Next: the tool bench, from the soldering iron down to the flux pen, all from amazon.ca.

Tools and consumables from amazon.ca

Chapter 4 bought the keyboard. This chapter buys the bench: every tool and every consumable you need to solder it, what each one is, why you need it, what to look for in a listing, and roughly what it costs on amazon.ca as of mid-2026. Almost everything here is a one-time purchase that will serve every electronics project you ever do after this one, which is the right way to think about the total at the bottom.

A consumable is anything the work uses up: solder, flux, wick, alcohol. Tools you buy once; consumables you will eventually buy again, though a first purchase of each outlasts several keyboards.

As always: prices approximate, listings rotate, and the search terms matter more than any specific listing. Where a brand is named, it is an anchor, not the only good answer.

The soldering iron

The one decision people agonize over, so here are the three honest tiers.

Tier 1: Pinecil V2, roughly CAD 50 to 70. A small USB-C powered smart iron from Pine64 (an open-source hardware outfit). It heats in seconds, holds its temperature well, and takes a huge ecosystem of cheap tips. Buy it from the pine64 store directly (USD pricing, cheap but slower shipping), from amazon.ca resellers at a markup, or from Canadian resellers (Breadstick Innovations at shop.breadstick.ca is one that stocks it domestically). The catch: it has no plug of its own. It needs a USB-C PD power brick of 65 W or more (PD is Power Delivery, the fast-charging standard), the same brick that charges most modern laptops. If you own such a charger, the Pinecil is a spectacular deal. If you do not, add CAD 30 to 40 for one, and it will also charge your devices forever after.

Tier 2: TS101, roughly CAD 90 to 120. The other well-known smart pen iron, similar performance, can also run from a barrel-jack supply. Fine, slightly more expensive for what you get.

Tier 3: a bench station. The Hakko FX-888D (roughly CAD 150 to 190) is the classic: a base unit with a transformer, a proper iron holder, and decades of reputation. Budget stations from Yihua and similar brands (CAD 60 to 90) do the same job with less refinement. A station is the right call if you know electronics is becoming a permanent hobby and you have a permanent desk for it.

This book's recommendation is the Pinecil V2. It is more iron than this project needs, portable, cheap to tip, and the money saved buys better solder and a multimeter.

One tip about tips: irons ship with a conical needle tip, and beginners assume finer means better. It is the opposite. A needle tip touches the joint at a single point and transfers heat poorly, so you sit there cooking a joint that will not flow. A small chisel or bevel tip lays a flat face against the work, heat pours in, and the joint finishes in two seconds. If your iron offers a tip choice or a spare, take a fine chisel.

Solder

Solder is the metal you melt: a wire on a spool with a core of flux (a chemical that cleans oxide off the metal so the solder can bond; more on flux below). Two decisions:

Leaded or lead-free. The beginner-friendly default is 63/37 leaded solder (63 percent tin, 37 percent lead). It melts lower, flows better, and makes shiny joints that are easy to judge by eye. The honest safety picture: the lead risk is from handling, not fumes. Soldering temperatures are far below the point where lead vaporizes; the smoke you see is flux, which you ventilate anyway. The rule is simply: wash your hands after soldering, and do not eat at the bench. Follow that and leaded solder is a reasonable, widely used choice for hobby work. Lead-free (SAC305, a tin-silver-copper alloy) is also perfectly workable and is what the electronics industry uses; it wants the iron about 30 degrees hotter and its correct joints look duller, which makes joint inspection slightly harder to learn. Either is fine. This book's photos and temperatures assume 63/37; Chapter 6 gives the lead-free adjustments.

Diameter: 0.6 to 0.8 mm. Thicker solder dumps too much metal per touch on small keyboard joints; much thinner and you feed forever.

Look for rosin-core (flux-core) on the label; solid-core solder without flux is for plumbing, not electronics, and will not work here. Kester and MG Chemicals are the reliable names on amazon.ca; a 100 g spool runs about CAD 15 to 30 and will outlive several keyboards. Search "63/37 rosin core solder 0.8mm".

Flux and cleanup

The flux inside the solder is enough for most fresh joints, but a separate flux pen or paste (roughly CAD 12 to 20, MG Chemicals no-clean flux is the common amazon.ca pick) is the fix for everything difficult: reworking a joint, desoldering, or coaxing solder onto a pad that refuses to wet. "No-clean" means its residue is safe to leave on the board, though it looks like brown varnish.

For that reason, buy the cleanup kit alongside: a bottle of 99 percent isopropyl alcohol (the 70 percent pharmacy kind leaves water behind) and lint-free wipes or cotton swabs, maybe CAD 15 together. A quick scrub after soldering turns a sticky amateur-looking board into a clean one.

Don't be confused. Flux and solder wick solve different problems, and beginners reach for the wrong one. Flux helps solder flow and bond; it adds nothing and removes nothing. Solder wick (next section) removes solder. If a joint will not take solder, you want flux. If a joint has too much solder or the wrong solder, you want wick.

Desoldering gear

You will make a mistake. Chapter 8 teaches the rescue; these are its instruments:

• Solder wick, 2 to 2.5 mm wide: braided copper ribbon that soaks up molten solder like a paper towel. About CAD 8 to 12 a spool.
• A solder sucker (spring-loaded vacuum pump): cocks like a pen, and a button snaps a plunger up to slurp molten solder out of a hole. The Engineer SS-02 (CAD 25 to 35) has a soft silicone nozzle that seals against the board and genuinely works better; generic suckers (around CAD 10) are serviceable. If the budget allows one splurge in this chapter, this is a good one.

Iron accessories

• A stand and brass wool. The Pinecil is a pen with a 350 degree tip and no base, so a stand is not optional. Small stands with a coil holder and a tub of brass wool (curly brass shavings you stab the tip into to clean it; gentler than a wet sponge, which thermally shocks the tip) run CAD 10 to 15. Search "soldering iron stand brass tip cleaner".
• Tip tinner, about CAD 12: a little puck of solder and cleaning compound. When a tip goes black and stops taking solder, a dab of this resurrects it. One tin lasts years.

Hand tools

• Flush cutters (CAD 10 to 15): small snips with one flat face, for clipping component legs close to the board. The flat face leaves a clean stub where ordinary side cutters leave a spike. Any "flush cutter electronics" listing in this price range is fine.
• Fine ESD tweezers (CAD 8 to 12): pointed stainless tweezers for placing diodes and holding small parts. ESD-safe means they will not build static charge. Usually sold in cheap multi-packs.
• Small Phillips screwdrivers, #0 and #1 (CAD 10 to 20): the case screws are tiny M2s. A basic precision set is enough; an iFixit-style driver kit (CAD 30 to 40) is a lovely upgrade that opens every gadget you own, but it is a luxury here.

The bench itself

• A silicone soldering mat (CAD 15 to 25): heat-proof rubber mat with little parts trays molded in. Protects the table from the iron and, just as valuably, keeps 58 diodes from rolling onto the carpet. Search "silicone soldering mat large".
• Helping hands or a small PCB vise (optional, CAD 15 to 40): a clamp that holds the board at an angle so both of your hands are free for iron and solder. Nice, not necessary; a keyboard PCB lies flat on the mat perfectly well for most of the work.
• Lighting and magnification (optional): a bright desk lamp is worth more than any gadget. For inspection, you already own a loupe: your phone camera, zoomed in, focuses closer than your eyes and lets you examine joints at poster size. We use that trick constantly in Chapter 10.

Safety gear

• Safety glasses (CAD 5 to 10): non-negotiable, mostly for clipping leads. A trimmed diode leg leaves the cutter at genuinely dangerous speed in a random direction. Any ANSI-rated pair is fine; you likely saw this rule in Chapter 0 and it is repeated here on purpose.
• Ventilation. The smoke from soldering is vaporized flux, an irritant you should not breathe as a habit. An open window plus any small desk fan pushing air across (not at) the work is honestly adequate for a hobby build. Bought fume extractors (a fan behind a carbon filter, CAD 40 to 60 on amazon.ca) are tidier, and a DIY version is just a PC fan strapped to a carbon filter sheet. Nice to have; the window and fan are the requirement.

The multimeter: the debugging chapter's main character

A multimeter measures electricity, and the mode that matters for keyboards is continuity: touch the two probes to two points, and the meter beeps if they are electrically connected. That single beep answers almost every keyboard question: Is this joint actually connected? Is this switch closing? Is this TRRS wire intact? Are these two pads bridged that should not be? Chapter 13 is essentially a guided tour of continuity mode.

Any meter in the CAD 20 to 35 class with a continuity beeper does the job; AstroAI and Kaiweets are the ubiquitous amazon.ca brands in that range. Search "multimeter continuity buzzer". You do not need auto-ranging, high accuracy, or any premium feature for this book, though none of them hurt.

Keycap and switch pullers

A keycap puller (a wire fork that grabs a cap) and a switch puller (a squeeze tool that releases a switch's clips from the plate) usually come as a pair for CAD 5 to 10, and switch vendors often toss one in free. The wire kind of keycap puller is worth insisting on; the plastic ring kind scratches caps. Cheap, and you will use them for the life of the keyboard.

A sourcing note: Mill-Max pins and other precision parts

The controller socketing pins from Chapter 4 (Mill-Max part 0305 is the standard one) are an example of a part amazon.ca is bad at and the electronics distributors are great at. Digi-Key Canada and Mouser Canada are giant component warehouses that ship into Canada quickly and cheaply, with free shipping over a modest order threshold, duties and taxes handled at checkout. The alternative is friendlier: most keyboard shops, including the Canadian ones from Chapter 4, sell ready-made "socketing kits" with the pins and headers counted out for two controllers. Either route is good; the distributors win when you are already ordering other components.

The whole bench on one table

Running totals, approximate: the bare-minimum bench, every must-have at the cheap end, lands around CAD 120 to 160. The comfortable bench, with the SS-02, a PD brick, a vise, and a few of the nice-to-haves, lands around CAD 200 to 280. And nearly all of it is permanent: the iron, meter, cutters, tweezers, mat, and pullers serve every repair and project after this one. Only the solder, flux, wick, and alcohol are truly consumed, slowly.

Sidebar: when a local shop beats Amazon

Canada still has real electronics counters, and they earn their keep in two situations: when you need something today (mid-build, out of wick, Saturday afternoon), and when you want a human to put the right thing in your hand. Lee's Electronics in Vancouver and Creatron in Toronto are the best-known storefronts, both stocking irons, solder, flux, and tools, both with online stores that ship across the country. Digi-Key Canada and Mouser Canada, mentioned above, are the mail-order equivalent: not local, but fast, exact, and often cheaper than amazon.ca for genuine name-brand consumables like Kester solder. Amazon wins on one-cart convenience; the specialists win on getting exactly the right part, first try.

Takeaways

• The Pinecil V2 plus a chisel tip is the recommended iron; the real total includes a 65 W USB-C PD brick if you do not own one.
• 63/37 rosin-core solder, 0.6 to 0.8 mm, is the forgiving default. The lead rule is wash your hands and do not snack, and the smoke is flux either way, so ventilate.
• Flux makes solder flow; wick takes solder away. Buy both, plus a sucker.
• The multimeter's continuity beep is the single most useful debugging tool in this hobby. CAD 20 to 35 buys all the meter you need.
• Bare-minimum bench about CAD 120 to 160; comfortable about CAD 200 to 280; nearly all of it is a one-time purchase.
• Digi-Key/Mouser Canada for precision parts and name-brand consumables; Lee's and Creatron when you want it today or want advice with it.

👉 The parcels are ordered and the bench is stocked. Time to learn what a good solder joint actually is, in Chapter 6: soldering fundamentals.

Soldering fundamentals and safety

This is the chapter to read before the iron arrives, and to reread the evening it does. Nothing here requires touching hot metal yet. The goal is that when you first plug the iron in (next chapter, on a practice board that cost less than lunch), your hands already know the plan and your bench is set up so that nothing can go wrong in a way that hurts.

If your iron and solder have not shipped yet, Chapter 5 has the shopping list. Everything below assumes that kit: a temperature-controlled iron, rosin-core solder, a stand, brass wool, and the supporting cast.

What soldering actually is

Soldering is joining two metal parts by melting a third metal, called solder, between them. The solder melts at a much lower temperature than the parts do, flows into the gap, and freezes into a joint that is both mechanically strong and electrically conductive.

Here is the part beginners get wrong, and it changes everything about technique: solder is not glue. Glue is a blob that grabs two surfaces. Solder alloys with the surfaces it touches: when molten solder meets clean, hot copper, the tin in it dissolves a little of the copper and forms a thin layer of new metal that is part solder and part copper. The joint is not solder stuck to copper; it is solder grown into copper.

That growing-into behaviour has a name: wetting, and you have seen it in your kitchen. Water on a clean glass spreads into a thin film: it wets. Water on a greasy pan beads up into droplets: it does not. Molten solder behaves the same way. On clean, hot metal it flows out flat and hugs every contour. On dirty or cold metal it balls up and sits there like mercury, touching almost nothing. A joint where the solder wetted is strong and conductive. A joint where it beaded up merely looks connected, and those fake joints cause most "my keyboard half is dead" mysteries. The whole craft of soldering is arranging for wetting to happen: clean metal, hot metal, solder fed at the right moment.

Why flux exists

There is an enemy of wetting that you cannot see: oxide. Metal exposed to air grows a microscopically thin skin of metal oxide within minutes (it is the same chemistry as rust, just faster and invisible). Solder will not wet oxide. It will bead up on an oxidized pad the way water beads on that greasy pan.

Flux is the chemical that fixes this. It is a mildly acidic compound (traditionally rosin, refined pine sap) that does nothing at room temperature but turns aggressive when heated: it dissolves the oxide and shields the freshly bared metal from the air for the few seconds you need, then burns off as a wisp of smoke. That smoke is the smell of soldering, and it is why your joint works at all.

Here is the convenient part. The solder you bought is rosin-core: a thin tube of solder wire with flux running down the middle like the jam in a rolled cake. Every time you feed solder into a joint, a dose of flux arrives with it, melts first, and clears the way. For the fresh, factory-clean pads on a new keyboard PCB, the core flux is almost always enough. The separate flux pen from your tool list earns its keep during rework in Chapter 8, when you reheat old joints whose flux burned away long ago.

Don't be confused. Flux and solder are different substances with different jobs, even though they travel together in one wire. Solder is the metal filler that becomes the joint. Flux is the cleaning chemical that lets the solder wet the metal, and it is gone (as smoke and brown residue) by the time the joint exists. When a joint refuses to take solder, the usual cure is more flux, not more solder. Piling on more solder just builds a bigger ball on top of the same dirty surface.

Don't be confused. Soldering is not welding. Welding melts the actual workpieces together and needs thousands of degrees. Brazing is soldering's big sibling: same melted-filler idea, but with fillers that melt above 450 degrees Celsius, used for plumbing and bike frames. Electronics soldering melts only the filler, at around 220 degrees, and the parts themselves never come close to melting. This is why a 350 degree iron can safely touch a plastic-bodied component for a few seconds.

Lab: set up your bench

This lab is real even though nothing gets hot. A good bench prevents most accidents before they can start. Do it once, properly, and the habit stays.

1. Clear a solid table and lay down the silicone mat. The mat from Chapter 5 protects the table from heat and stray solder blobs, and its little trays corral tiny parts. Nothing flammable lives on or near it: no paper pile, no curtains brushing the desk.
2. Place the iron stand at your dominant-hand side, toward the back. The iron always, always goes in the stand when it is not in your hand. Not on the mat, not balanced on the desk edge. In the stand. Position it so your forearm never has to cross over it to reach something.
3. Route the iron's cable. This is the step everyone skips and later regrets. Run the cable away from you, off the back of the desk, with slack near the iron so it never tugs. The cable must not cross your lap, dangle where a knee or a chair arm can hook it, or run under the mat where you will pull it while repositioning. A snagged cable pulls a 350 degree iron off the desk, and (memorize this now, we will repeat it in the safety section) you do not catch it.
4. Set up ventilation. Open a window. Put a small desk fan a foot or two to the side, blowing gently across the work toward the window, not at the work. Across, because you want the smoke carried away from your face. Not at, because a direct blast cools the joint you are trying to heat and blows tiny parts around. If you bought a fume extractor (the little filtered fan from the tool chapter), it sits on the far side of the joint, mouth toward the work.
5. Sort out lighting. You will be inspecting joints a few millimetres wide. A desk lamp you can angle, or a headlamp, makes the difference between seeing a solder bridge and shipping one. Overhead room lighting alone is not enough; it puts your own shadow on the work.
6. Dampen the brass wool? No. Trick step. The brass wool in your iron stand's cup is used dry; you stab the hot tip into it to scrape off old solder. If your stand instead came with a flat sponge, that one does get water: damp like a wrung-out cloth, never dripping. Brass wool is gentler on the tip (no thermal shock) and is what your tool list specified, but know both, because you will meet both.
7. Stage your consumables within reach of your non-dominant hand: solder, tweezers, flush cutters, safety glasses. The dominant hand holds the iron and should never have to wander.

You are done when... you can sit at the bench, mime picking up the iron from the stand and returning it, and nothing (cable, clutter, your own arm) crosses the path; and a lit, ventilated, empty mat is in front of you.

Temperature: hotter and faster beats cooler and slower

Your iron is temperature controlled, so set it deliberately:

• Leaded solder (60/40 or 63/37): 320 to 350 degrees Celsius.
• Lead-free solder: 350 to 380 degrees Celsius, because lead-free alloys melt about 30 degrees higher.

Beginners reliably make the same mistake here: "heat is scary, so I will turn the iron down and be gentle." The result is worse joints and more damage. A properly hot iron brings the pad and lead to solder-melting temperature in about a second, the solder flows, and you are gone in three seconds total. A too-cool iron pours heat in slowly, so you sit there for ten or fifteen seconds waiting for the solder to reluctantly slump, and all that time heat is soaking outward: into the component's plastic body, and into the glue bonding the copper pad to the fibreglass board. That glue is the weak point. Cook it long enough and the pad peels off, the one injury a PCB does not shrug off (Chapter 8 covers the rescue, and it is not fun). Total heat delivered is temperature multiplied by time, and time is the dangerous factor. Hot and brief is kind. Cool and lingering cooks pads.

Tinning the tip

Tinning means keeping the working face of the iron's tip coated in a thin, bright layer of solder. You tin constantly, as a reflex, because it matters twice over.

First, heat transfer. A dry tip touches a pad at a few microscopic high points and heat trickles across. A tinned tip carries a tiny bead of molten solder that bridges tip to pad with liquid metal, and heat floods across: a one-second joint instead of a ten-second struggle.

Second, tip survival. The tip's plating oxidizes fast at working temperature unless a solder coat seals it from the air. A bare hot tip crusts over black within minutes, and oxide will not wet, which brings us to the classic beginner emergency:

"My tip turned black and nothing melts anymore." This will happen to you, probably in week one. The tip oxidized because it sat hot and bare. The recovery ritual:

1. Turn the temperature down to about 300 degrees (less oxidation while you work).
2. Stab and twist the tip in the dry brass wool to scrape the crust.
3. Immediately press fresh solder against the tip. Feed generously; the flux in the core is doing the cleaning. Wipe in the brass wool and feed again, several rounds.
4. If it still refuses, use tip tinner (the little tin of gritty paste from the tool list): press the hot tip into it, let it fizz, wipe, and re-tin with solder. This revives all but the truly dead.
5. Prevent the relapse: feed a blob of solder onto the tip every time you park the iron in the stand, and turn the iron off when you are not actively soldering. A tip that always rests under a solder coat lasts years.

The routine at the bench is: wipe in brass wool, tin, solder a few joints, wipe, tin, park with a blob. Shiny tip, always.

The core technique: one through-hole joint

Everything in this book funnels into the next few lines. A through-hole joint is the classic kind: a component's wire leg (its lead) passes through a hole in the board, and the copper ring around the hole (the pad) gets soldered to it. Your Lily58 build is dozens of these, plus the surface-mount cousins we rehearse in Chapter 7. Learn this as a ritual, counted out loud at first:

1. Prepare. Tip freshly tinned and shiny. Solder wire in your other hand with a few centimetres sticking out, held like a pencil.
2. Heat both. Touch the tip so it presses against the pad and the lead at the same time, in the corner where they meet. Hold for one second. Both metals must be hot, because solder flows toward heat and wets only hot metal.
3. Feed the solder to the joint, not the iron. Touch the solder wire to the far side of the joint, against the hot pad and lead, opposite the tip. It should melt on contact and flow around the lead. Feed for one to two seconds, enough to form a small cone, then stop. If the solder will only melt when touched to the iron itself, the joint is not hot yet: that is the ritual failing, not a cue to melt solder on the tip and dab it over.
4. Remove the solder first, then the iron. Solder away, one beat, iron away. This order leaves flux working until the end.
5. Hold still for one second. The joint freezes in about a second. If the lead moves while the solder is half frozen, the joint sets as a grainy, cracked mess (a cold joint, described below). Then breathe; you are done.

Total contact time: about three seconds. Say the ritual as a chant while you work through the practice labs: heat both... feed away... solder off, iron off... hold. By joint twenty it will be muscle memory, which is the state we want you in before the Lily58 comes out of its bag in Chapter 9.

What a good joint looks like

A good through-hole joint is a small, concave cone: solder rising smoothly from the pad up the lead, curving inward like the sides of a volcano or a Hershey's Kiss. With leaded solder it is shiny, like chrome. (Lead-free freezes slightly dull even when perfect; judge it by shape, not shine.) The solder visibly hugs both surfaces, feathering onto the pad and climbing the lead, and the lead's silhouette still shows inside the fillet.

GOOD JOINT (side view)          BALL / NO WETTING
        |                              |
        |  lead                      (   )   solder balled on lead,
       /|\                           (   )   sitting ON the pad,
      / | \   concave sides,     ____(___)____  a crack of dark
 ____/  |  \____  wetted to      ====PAD=====   board visible
 ====PAD=====    pad AND lead                   underneath

And the rogues' gallery, in words:

• Cold joint. The solder froze while the lead was moving, or never got fully molten. It looks grainy, dull, lumpy, sometimes with a visible crack ringing the lead. It may work today and fail next month. Fix: reheat properly with a touch of fresh solder.
• Insufficient wetting. The ball in the sketch above: solder clinging to the lead or sitting as a dome on the pad, with a visible dark seam where it never bonded. The pad was dirty or never got hot. Fix: flux, reheat, let it collapse into a cone.
• Solder bridge. A shiny strand or blob connecting two pads that should be separate, creating a short circuit. Cause: too much solder, or a sloppy iron exit. On a keyboard this is the classic "two keys fire at once" bug. Fix in Chapter 8; it takes thirty seconds with wick.
• Overheated joint / lifted pad. Scorched brown board around the pad, or worse, the copper ring itself tilted up or torn free, sometimes dangling on the lead. Cause: lingering too long, usually with a too-cool iron, often plus prying force. This is the injury the "hot and brief" rule exists to prevent.

   COLD JOINT              BRIDGE                 LIFTED PAD
       |                 |       |                    |
     ~~|~~  grainy,      |       |                   /
    ~~ | ~~ cracked,   __########__   solder     ___/  pad peeled
 ___~~_|_~~___  dull   ==PAD==PAD==   spans      ==     up off the
 ====PAD=====          two pads: short!          board, trace torn

Inspect every joint for the first hundred you make. It takes two seconds each and trains your eye faster than anything else.

Safety, complete

All of it, in one place. None of this is meant to frighten you; a soldering bench run with these habits is about as dangerous as a kitchen.

• Burns. The iron is 350 degrees Celsius and looks identical hot or cold. Assume hot whenever it is plugged in or was recently. If you do get burned (most solderers eventually collect one small one): cool the burn under cool running water for a full ten minutes. Not ice, not butter, not a quick rinse; ten timed minutes of cool water, then cover loosely. See a doctor for anything bigger than a small coin, blistered badly, or on the face.
• The falling iron. If the iron slips off the desk, let it fall. Step back, let it hit the floor, then unplug it and pick it up by the handle. Every instinct says catch it, and catching it means gripping a 350 degree barrel. Rehearse the thought now so instinct loses later. (This is why the cable-routing step in the bench lab matters.)
• Fumes. The smoke rising from a joint is burning flux, not metal vapor. It is still an irritant you should not breathe daily: hence the open window and the cross-blowing fan. Position the work so the smoke plume drifts away from your face, and notice that heat makes it rise straight into your nose if you hunch directly over the joint. Sit slightly back.
• Leaded solder hygiene. Lead at soldering temperature does not vaporize; it is nowhere near hot enough. The hazard is contact and ingestion: lead residue ends up on your fingers and the bench. So: no food or drink at the bench, ever. Wash your hands with soap after every session and before you eat. Keep solder, wick, and clipped joints away from kids and pets (a curious toddler or a dog that eats dropped things is the real risk scenario), and wipe the mat down now and then. If this list is more than you want to manage, lead-free solder exists and Chapter 5 weighs the trade honestly.
• Eyes. Safety glasses go on before you clip component leads. Flush cutters launch trimmed wire ends at genuinely surprising speed in random directions, and an eye is the one part of you this hobby can permanently damage. Molten solder can also spit, rarely, when it hits a pocket of moisture or flux. Five-dollar glasses, zero drama.
• Fire. Nothing flammable on or beside the mat. The iron lives in its stand. And the iron gets unplugged whenever you leave the desk, even "just for a minute," because a minute becomes twenty and a hot unattended iron is exactly how bench fires start. Unplugging also saves your tip, so the safe habit and the frugal habit are the same habit.

Takeaways

• Soldering is a metallurgical bond, not glue: molten solder wets clean, hot metal and grows into it. Everything about technique serves wetting.
• Flux strips the invisible oxide that blocks wetting; your rosin-core solder carries its own supply. When solder will not take, add flux, not more solder.
• 320 to 350 degrees for leaded, 350 to 380 for lead-free. Hot and brief beats cool and lingering, because time, not temperature, is what cooks pads.
• Keep the tip tinned. Shiny tip, fast joints. Black tip, brass wool and re-tin.
• The ritual: heat pad and lead together (1 second), feed solder to the joint (1 to 2 seconds), solder off, iron off, hold still. About three seconds per joint.
• A good joint is a shiny concave cone wetted to both pad and lead. Know the four villains: cold joint, ball, bridge, lifted pad.
• Safety is a handful of habits: stand, unplug, ventilate, wash hands, glasses when clipping, and never catch a falling iron.

You now know what soldering is, how a joint forms, and how to run a bench that cannot surprise you. What you do not have yet is the hand skill, and no chapter can install that. Only repetitions can, and they should be cheap ones.

👉 Next: Practice before you touch the kit, where you burn your first ugly joints into a ten-dollar board instead of your keyboard.

Practice before you touch the kit

Your first twenty solder joints will be bad. This is not pessimism, it is scheduling. Every solderer's first joints are lumpy, cold, or bridged, the same way everyone's first pancake is a write-off. The only question is where those bad joints happen: on a ten-dollar practice board that goes in a drawer afterward, or on the one Lily58 PCB you own.

That PCB deserves a moment of respect before we go on. Of everything in your kit bag, it is the single part that is genuinely annoying to replace. Switches come in bags of spares, diodes cost pennies apiece, but the PCB is a specific board from a specific shop, often overseas, and a replacement means CAD 25 to 40 plus shipping plus one to three weeks of waiting while your half-built keyboard stares at you (Chapter 4 has the sourcing details). And a lifted pad on it (the injury from Chapter 6, where the copper ring tears off the board) is the kind of damage that turns into an hour of rework, or a dead key, or that replacement order.

So the deal this chapter offers is: spend roughly the cost of a pizza and one relaxed evening, and arrive at the real build with hands that already know the ritual. Flight school before the airliner, exactly as promised in the introduction.

What to buy for practice

You need something with pads and holes that does not matter. Three good options, all findable on amazon.ca (search the quoted phrases; as always, prices are approximate as of mid-2026 and the specific listings rotate):

My recommendation for this book's path: the raw parts (for Lab 1), one practice or gadget kit (for Lab 2), and the SMD trainer (for Lab 3). Total damage around CAD 40, and you can trim that by skipping the gadget kit and doing Lab 2 on more perfboard.

Don't be confused. Perfboard and a practice kit PCB look similar but behave differently. Perfboard (perforated board) is a grid of independent holes, each with its own little copper ring and no connections between them; you supply the parts and there is no circuit, just joints. A kit PCB has printed copper traces connecting the pads into a working circuit, plus printed labels telling you what goes where. Perfboard is for repetitions; kits are for rehearsing the sequence of a real build. You want both experiences, which is why there are three labs.

A note on the iron: practice with the exact iron, tip, and solder you will use on the Lily58. The point of practice is calibrating your hands to your tools, so do not borrow a friend's station for the labs and then build with your own.

Lab 1: twenty joints on perfboard

Pure repetitions. No circuit, no polarity, no stakes. Just the ritual from Chapter 6, twenty times, with inspection.

1. Set up the bench exactly as in the Chapter 6 bench lab: mat, stand, cable routed, window open, fan across, lamp on, glasses within reach. Every lab starts this way until it is automatic.
2. Prepare ten resistors. Bend both legs of each resistor down at right angles so it looks like a staple (fingers are fine; the plastic body should sit flat between the bends). Which resistor values? Irrelevant. We are using them as leg-delivery devices.
3. Populate the board. Push each resistor through the perfboard so its legs come out the copper side, spreading the ten parts out so you have working room. Splay each pair of legs outward maybe 30 degrees so the parts do not fall out when you flip the board.
4. Flip the board copper side up and prop it so it does not rock. (A strip of masking tape over the parts before flipping keeps them seated; the PCB holder or helping hands from Chapter 5 earns its money here.)
5. Solder all twenty joints, chanting the ritual. Heat pad and lead together, one second. Feed solder to the joint, one to two seconds. Solder off, iron off, hold still. Wipe and re-tin the tip every three or four joints. Do not rush, and do not stop to mourn a bad joint; note it and move on.
6. Clip the legs with flush cutters, glasses ON, just above each solder cone. Cup your free hand over the cutter, or aim the board so the leg flies at the mat, not across the room.
7. Inspect all twenty against the checklist (below), under your lamp, tilting the board so light rakes across the joints. Grade each joint out loud: good, cold, ball, too much.

Expect the first five to be ugly. Genuinely. Lumps, dull spots, one pad you had to poke at three times. Around joint eight or ten, something clicks: the solder starts flowing for you instead of despite you, and the joints start coming out identical. That click is the entire purpose of this lab.

You are done when... all twenty joints are soldered, clipped, and graded, and your last five in a row pass the checklist without excuses.

The good-joint checklist

For every joint, ask:

• Shape: a concave cone (volcano sides curving inward), not a ball, not a flat splat.
• Shine: bright and smooth for leaded solder (lead-free is allowed to be satin; judge it on shape).
• Wetting: solder visibly feathers onto the pad AND climbs the lead, no dark crack ringing either.
• Coverage: the whole pad ring is wetted, and the lead's silhouette still shows through the cone (buried lead means too much solder).
• Neighbours: no strand or blob reaching toward the pad next door.

Lab 2: build a full practice kit

Lab 1 taught the joint. This lab teaches the build: reading a board's printed labels, placing parts in order, and above all, respecting polarity.

Some components work either way around; some absolutely do not. A resistor has no polarity. An LED (light-emitting diode) does: it passes current in one direction only, and installed backward it simply does nothing. The convention: the long leg is positive (the anode), and the LED's plastic body usually has a flattened edge on the negative side, matching a marking on the board.

Why belabour this on a ten-dollar toy? Because the Lily58 is full of diodes (one per key; Chapter 3 explains why they exist), and a diode installed backward means a key that types nothing. An LED is just a diode that lights up, so every polarity check you perform in this lab is a direct rehearsal of the discipline that makes Chapter 10 go smoothly. Backward diodes are the number one first-build defect, and this is where you vaccinate yourself.

1. Unpack the kit and inventory it against its parts list before heating anything. (Also a rehearsal: Chapter 9 does exactly this for the Lily58.)
2. Solder lowest parts first: resistors and diodes flat against the board, then upright parts, then bulky parts. Short parts first means the board still lies flat on the mat for as long as possible.
3. Check polarity before every diode, LED, buzzer, and electrolytic capacitor. Long leg to the positive marking, flat edge to the flat marking. Say it out loud: "long leg, plus." Check, insert, check again, then solder. Ten seconds of checking beats ten minutes of desoldering.
4. Solder, clip, inspect in batches of a few parts, running the Lab 1 checklist each time.
5. Power it up per the kit's instructions (usually a coin cell or battery pack). Blinking lights or an obnoxious noise is your diploma.

If it does not work: do not despair, diagnose. Check every polarized part's orientation first, then reinspect every joint for the villains from Chapter 6 (a cold joint or a ball that never wetted is an open circuit). This debugging loop is, again, a rehearsal: it is a miniature of Chapter 13.

You are done when... the kit does its thing when powered, and every joint on the back passes the checklist.

Lab 3: surface-mount practice (the keyboard-specific one)

Here is where keyboard building departs from generic practice kits. Through-hole parts poke through the board; surface-mount parts (SMD, surface-mount device) sit flat on the board, soldered to bare pads on the surface, with no holes and no legs to grip. Two of the Lily58's part types are surface-mount or close to it:

• The diodes in most modern Lily58 kits are 1N4148W diodes in a package called SOD-123: a black grain of rice, about 3 by 1.5 millimetres, with a flat metal tab at each end and a painted line marking the cathode (the direction matters, as always).
• The hotswap sockets (the sockets that let you push switches in without soldering them, from Chapter 2) are surface-mount too: each one has two metal wings that solder to two big pads on the back of the board.

Neither can be soldered with the through-hole ritual, because there is no lead to heat and nothing holding the part in place. The SMD technique instead goes: anchor one end, then do the other.

1. Tin one pad. Touch the iron to one of the part's two pads and feed a small blob of solder onto it. Just that pad. Remove the iron; the blob freezes into a little mound.
2. Slide the part in while reheating. Pick up the part with tweezers (fingers are hopeless at this scale). Reheat the mound so it goes molten, and slide the part's end into the molten solder, holding it flat and aligned. Remove the iron, hold the part still with the tweezers for a second while the solder freezes. The part is now anchored.
3. Inspect the anchor. Flat against the board? Aligned with both pads? Polarity line pointing the right way (for the diode)? If not, reheat and nudge; the anchor is cheap to redo now.
4. Solder the free end normally. Heat that pad and the part's metal tab together, feed a little solder, done. This joint is easy because the part cannot move anymore.
5. Optionally, touch up the anchor end with a dab of fresh solder if the first mound looks lumpy (it often does, since it was soldered without flux flowing at the perfect moment).

Practice this on the SMD trainer board (search "SMD soldering practice board", around CAD 10-15; get one whose parts go down to about the "0805" size, roughly the size of the Lily58's diodes, and do not worry about the dust-speck sizes). Some Lily58 kits also ship a couple of spare diodes and the PCB sometimes has unused pads; spares are fair game after the trainer, never as your first attempt.

Do at least ten SMD parts. The skill being trained is the three-way coordination of tweezers, iron, and eyes, and it arrives around part six.

You are done when... you can place an SMD part flat, aligned, and wetted at both ends in under a minute, without the tweezers slipping.

How to grade yourself

Three tests, cheapest first:

• The visual checklist from Lab 1, on every joint, under raking light. This catches most problems.
• The tug test. Grip the component (or its clipped lead stub) with tweezers and pull, firmly, like you mean it. A wetted joint does not care. A cold joint or an unwetted ball pops off or visibly shifts. Better it fails in your hand tonight than in your keyboard next month.
• The continuity beep. Set your multimeter (Chapter 5) to continuity mode (the icon that looks like a sound wave or a diode; it beeps when the probes are connected by metal). Put one probe on the component's lead above the joint and the other on the copper pad or its trace. A beep means electrical continuity through the joint. On the practice kit you can also beep across a trace from one part to the next. No beep across a joint that looks fine is the signature of a cold joint or hidden crack.

Troubleshooting your technique

When practice misbehaves, the symptom names the cause:

The bar: ten consecutive good joints

Here is the gate between practice and the real build, and it is deliberately strict: ten consecutive joints that pass the visual checklist and the tug test, with no do-overs in the streak. One dud resets the count. Then the same standard for SMD: five consecutive parts, flat and wetted at both ends.

This usually takes one to two evenings from a standing start. If it takes three, that is fine; perfboard is patient and the Lily58 is not going anywhere. What you must not do is talk yourself into "close enough" at seven joints, because the Lily58 will ask you for over a hundred joints in a row, and the build is only as reliable as your worst one.

Takeaways

• Practice on worthless boards because the Lily58 PCB is the one part that is slow and annoying to replace.
• CAD 25 to 40 of practice gear from amazon.ca covers all three labs: resistors and perfboard for repetitions, a practice kit for polarity and sequence, an SMD trainer for the keyboard-specific skill.
• Polarity discipline ("long leg, plus"; check, insert, check again) is the habit that prevents the number one first-build defect: backward diodes.
• SMD technique is tin one pad, slide the part in molten solder with tweezers, then solder the free end.
• Grade with three tools: eyes (the checklist), hands (the tug test), meter (the continuity beep).
• The gate: ten consecutive good joints, plus five consecutive clean SMD parts. Strict on purpose.

There is one more skill to bank before the build, and it is the one that turns mistakes from disasters into detours: taking solder off. Every builder desolders something eventually, and learning it on the practice board you just built (yes, we are going to partially un-build it) costs nothing.

👉 Next: Fixing mistakes: desoldering and rework.

Fixing mistakes: desoldering and rework

Every builder desolders something. Not most builders, every builder. A diode goes in backward, a solder bridge shorts two pads, a socket ends up on the wrong side of the board. The people who finish beautiful keyboards are not the people who never make these mistakes; they are the people who can calmly undo them. This chapter is that skill, and it is cheap insurance: an hour of practice tonight buys you the ability to shrug at any mistake in the real build.

Better still, you already own everything it needs, and you already built the perfect victim. The practice kit from Chapter 7 is about to be partially un-built.

The tools, briefly

All three came home with the Chapter 5 order:

• Desoldering wick (also sold as desoldering braid): flat copper braid that soaks up molten solder by capillary action, the way a paper towel soaks up a spill. Your precision tool.
• Desoldering pump (also called a solder sucker): a spring-loaded vacuum tube. Cock the plunger, melt the joint, click the trigger, and it slurps the molten solder out. Your bulk tool, best on through-hole joints with a hole full of solder.
• Flux pen or paste: the star of this chapter. Old joints have no live flux left (it burned off the day they were made), so reheated old solder is sluggish and sticky. Fresh flux makes it flow like new. When any rework step fights you, the answer is almost always "add flux."

Don't be confused. Desoldering and rework overlap but are not the same word. Desoldering is removing solder or a soldered part. Rework is the whole repair activity: desolder the mistake, clean up, and solder the correction in. Wick and pump are desoldering tools; rework is desoldering plus everything you learned in Chapter 6.

Solder bridges: the easiest fix in the book

Start here because bridges are the most common defect and the most satisfying repair. A bridge is excess solder spanning two pads that should be separate. Two cures, in order of effort:

The flux-and-drag. Apply flux to the bridge. Clean and tin your iron, then wipe it so it carries almost no solder. Drag the tip slowly through the bridge, along the gap between the pads, and away. Surface tension does the work: solder wants to pull into two neat blobs, one per pad, and fresh flux lets it. Often one pass fixes it, and you will feel slightly cheated by how easy it was.

The wick. If the bridge is fat, or the drag just smears it around, soak up the excess with wick using the technique below, then resolder both joints properly with fresh solder.

Wick technique, as a ritual

Wick fails for beginners for one reason: they treat it as a dabbing motion. It is a pressing-and-waiting motion. The steps:

1. Flux the wick. Touch the flux pen to the last centimetre of braid. Many wicks come pre-fluxed, but years in a warehouse kill that; fresh flux costs two seconds and doubles the wick's appetite.
2. Lay the wick flat on the joint, braid between the solder and your iron. Never touch the iron directly to the solder you are removing; the wick sits in the middle of the sandwich.
3. Press down with the flat of the iron tip on the wick, over the joint, with gentle firm pressure. Now wait. One second, two, sometimes three: heat must travel through the braid into the solder below.
4. Watch for the blush. The moment the solder underneath melts, it races up into the braid and the wick visibly turns silver at the contact point. That silver blush is the signal that it worked.
5. Lift wick and iron together, as one motion. This is the step that saves boards. If you lift the iron first, the solder freezes with the wick embedded in the joint, and pulling a cold, soldered-on wick off a pad is precisely how pads get torn from the board. Iron and wick leave together, always. If the wick does freeze on despite you: do not pull. Reheat through the braid until it releases.
6. Trim the spent section. Used wick is a solder-saturated stub that cannot absorb more. Snip off the silvered part with flush cutters and work with fresh braid each pass.

Two or three passes with fresh sections usually gets a pad nearly bare. A faint silver film left on the pad is fine; you are cleaning up, not restoring the factory finish.

Pump technique, for through-hole

The pump shines where the wick plods: a through-hole joint whose hole is full of solder, like the practice-kit resistor legs, or a header pin.

1. Cock the pump (push the plunger down until it latches).
2. Melt the joint with the iron until fully liquid, tip staying in contact.
3. Bring the pump's nozzle right up to the joint, as close to touching the molten solder as you can, tilted so it seals around the area. The iron stays on until the last instant; some people slide the iron out and the pump in as a single motion.
4. Trigger. The click sucks the molten solder up into the tube. Done well, the hole is suddenly, satisfyingly empty and you can see daylight through it.
5. Empty the pump every few uses (cock it and the solder crumbs fall out of the nozzle; do this over the bin, not the board).

The counterintuitive trick for old, stubborn joints: add solder first. A joint that will not fully melt, or melts on top while staying solid in the hole, is starved of flux and possibly oxidized through. Feed a little fresh solder onto it before desoldering. Fresh solder brings fresh flux, blends with the old alloy, and the whole joint suddenly goes properly liquid and comes out in one pull. Adding solder in order to remove solder feels absurd exactly once, and then it becomes your first move on any stubborn joint.

Removing a soldered part

Two-lead through-hole parts (resistors, through-hole diodes): the alternate-heat wiggle. Grip the part with tweezers or fingers on the body (the body stays touchable; the leads do not). Melt one joint and nudge that end a millimetre out. Melt the other joint, nudge that end. Alternate, and the part walks out over three or four rounds. Gentle nudges only: the pad tolerates heat plus patience, not heat plus force.

Multi-lead parts (headers, the OLED screen pins, a switch you soldered directly): the wiggle does not scale past two leads because you cannot keep three or more joints molten at once. Two honest options:

• Wick every pin bone dry, one at a time, then lift the part out. Slow, safe, and the method to use on anything you want to survive.
• The solder blob: deliberately flood across all the pins with a fat bead of extra solder so the whole row stays molten at once, then lift the part out with pliers while dragging the iron along the bead. Fast, effective, and it sacrifices neatness for speed; you then wick the mess off the pads. Use it on parts you are discarding, not parts you are saving.

Hotswap sockets deserve their own paragraph because they are the part you are most likely to reposition, and their pads are large, thin, and fragile. The socket is surface-mount: two wings, two pads. Alternate heat between the two pads, a second or two each, while lifting gently with tweezers under the socket body; after a few alternations both joints are soft enough that it comes free. Never lever against the board, and never pull while only one side is molten, because those big inviting pads peel off more easily than any other pad on the keyboard. If the socket fights, add fresh solder to both wings first (the stubborn-joint trick) and try again.

The disasters, and their honest fixes

Now the injuries themselves. Deep breath: every one of these has either a fix or a dignified workaround.

The lifted pad. The copper ring or SMD pad detaches from the board, tilting up like a peeled sticker or tearing away entirely, sometimes leaving with the component. Cause: too much heat for too long, plus pulling force, exactly the combination the last two chapters kept warning about. The honest news: that pad is gone; pads do not reattach. But the pad was only ever a convenient landing zone connected to a copper trace (the printed wire running away from it, usually visible as a faint line under the board's paint-like coating, the solder mask). The repair is to connect your component to that trace some other way:

1. Follow the trace a few millimetres from the crater and gently scrape away a patch of solder mask with a hobby knife until bright copper shows.
2. Tin the bared copper.
3. Solder a short piece of thin wire (a clipped component leg is perfect) from the component's lead to the bared trace. This little jumper is called a bodge wire, and it is a completely legitimate repair; the inside of plenty of commercial gear has one.
4. A drop of super glue over the wire keeps it from flexing loose.

On the Lily58 there is often an even easier route: each key's diode connects onward to a neighbouring key's pad in the same row or column, so instead of scraping traces you can sometimes run the bodge wire to the next component's pad and let the existing copper do the rest. Chapter 13 shows how to read the matrix to find that neighbour. And if the damage is ugly and the trace crumbles: it is one key out of 58. A dead key that you remap around in firmware (Chapter 12) while the replacement PCB ships is a legitimate interim ending, not a failure.

The tombstoned diode. An SMD part standing up on one end like a little gravestone: one end soldered, the other in the air, because the anchor-end solder pulled it upright while the far end was never wetted. Fix: hold the raised end down flat with tweezers, reheat the soldered end until molten so the part settles, then solder the free end. Thirty seconds. Check the polarity line survived the adventure pointing the right way.

The part on the wrong side of a reversible PCB. The classic Lily58 mistake, and if you make it, you join a large club. The Lily58 PCB is reversible: the same board design serves as the left half and the right half, depending on which face you solder the parts to. That elegance means every component has a plausible-looking home on both faces, and only one is correct for the half you are building. Prevention is the whole of Chapter 9's marking ritual (tape and a marker on each board's correct face before any soldering). The cure, if you find a diode or socket on the wrong face: it is just a part removal. Diode: SMD removal (alternate the two ends with tweezers ready, lift when both are molten, or use plenty of flux and wick). Socket: the hotswap procedure above. Wick the pads clean, then solder the part onto the correct face. Tedious in bulk, which is why Chapter 9 also tells you to solder ONE diode and stop and check, rather than discovering thirty wrong-side diodes at once.

The broken hotswap socket. Cracked plastic, or the internal leaf contact bent from a switch pin stabbing in at an angle. No repair; the socket is a two-dollar part. Desolder it (hotswap procedure), wick the pads, solder a spare. This is why Chapter 4 told you to order a handful of extra sockets.

The torn USB port. On older controller boards with micro-USB connectors, the port is held on by small surface pads, and one sideways yank of the cable can rip it off, pads and all. Reattaching a torn micro-USB port is genuinely hard, beyond fair beginner rework. This is why Chapter 4 steers you to controllers with USB-C (mechanically far stronger, and modern boards anchor it through the board), and why the habit of unplugging by gripping the plug, never the cable, is worth building. If it happens anyway: replacement controller, and read the next section first.

When to stop: heroics vs a new board

A rule of thumb for the moment you are staring at damage and wondering whether to keep fighting:

• One lifted pad, one torn trace, one broken socket: fix it. These are evening-sized repairs and good practice.
• Several lifted pads in one area, a trace repair that keeps failing, a board that has been reworked so many times the pads are dull and reluctant: stop. A bare Lily58 PCB is roughly CAD 25 to 40. Two more hours of fighting a wounded board, plus the doubt every future glitch will cast back on your repairs, is worth more than that. Buying a fresh board is not defeat; it is arithmetic. Your switches, sockets you can rescue, keycaps, controllers, and case all transfer.

And the biggest insurance of all: socket your controllers. The microcontroller is the most expensive single component on each half, and soldering it directly to the PCB means any controller or board failure entangles both. Mill-Max sockets (spring-pin sockets, named for the main maker; hotswap sockets for the controller, in effect) let the controller plug in and pull out like a cartridge. Chapter 4 prices them; they add about CAD 10 to 15 per keyboard and they are the undo button for the part you least want to un-solder. If you took that advice at ordering time, a dead controller is a thirty-second swap forever after.

Lab: un-build something on purpose

Rehearse all of this now, on the Chapter 7 practice kit, while nothing is at stake.

1. Pick two resistors on the practice board. Remove one with the pump (fresh solder first if it is stubborn), one with the alternate-heat wiggle.
2. Wick both sets of pads clean, watching for the silver blush, lifting wick and iron together every time.
3. Create a solder bridge on purpose across two unused pads or a trimmed joint, then remove it with the flux-and-drag.
4. Resolder one of the removed resistors back in with fresh solder, and beep it with the continuity tester.
5. If you have the SMD trainer from Lab 3: remove one SMD part and resolder it flat.

You are done when... the resoldered joints pass the Chapter 7 checklist and the tug test, and nothing about wick, pump, or the wiggle feels mysterious anymore.

Takeaways

• Everyone desolders. The skill turns mistakes into detours, and it costs one evening on the board you already built.
• Flux first, always. Old joints have no live flux; fresh flux (or fresh solder, which carries it) is what makes every rework technique work.
• Bridges: flux and drag, or wick. Wick: flux it, press flat, wait for the silver blush, lift wick and iron together, trim the spent end.
• Pump: melt fully, nozzle tight to the joint, trigger. Add fresh solder to stubborn old joints before removing them.
• Parts come out by alternate-heat wiggle (two leads), wick-every-pin or the solder blob (many leads), and patient alternating heat with a gentle lift (hotswap sockets, whose pads are fragile).
• Lifted pads are repaired with a bodge wire to the trace or a neighbouring pad; a single dead key remapped in firmware is an acceptable interim outcome.
• Know the arithmetic: one repair, fight for it; a wounded, much-reworked board, replace it (CAD 25 to 40). And Mill-Max sockets make the controller removable forever.

Stand back and look at what you have banked across these three chapters: you can make a joint, judge a joint, and unmake a joint. Make and unmake is the complete skill; there is no soldering situation left in this build that you cannot either do or undo. The practice boards go in the drawer with honour. Time to open the Lily58 bag.

👉 Next: Before you solder: the parts check, where we inventory the kit, mark the reversible boards, and set up the build so the mistakes in this chapter stay theoretical.

Before you solder: parts check and build order

The kit is here. The iron works, because you proved it on practice boards in Chapter 7. The urge to start melting solder in the next ten minutes is strong, and this chapter exists to slow you down for about an hour, because the mistakes you can make before the first joint are the most expensive ones in the whole build. Soldering a diode badly costs you two minutes of rework. Soldering fifty-eight sockets to the wrong side of a board costs you an evening with the desoldering pump and a bruised ego.

So: a parts inventory, a damage inspection, one genuinely important concept (the reversible PCB), a labeling ritual that makes the concept harmless, and the build order with its reasons. Treat it as a lab, same as always.

Lab part 1: unbox and inventory

Clear the desk, lay out a towel or a silicone mat so small parts do not bounce, and open every bag in the kit. Count everything against this checklist. Kits are packed by humans, and a missing part discovered now is an email to the vendor; a missing part discovered mid-build is a stalled project.

Print this table or copy it onto paper and tick the boxes for real:

Counts vary a little between vendors, and some pack the screws and standoffs by weight rather than by count, so a screw or two either way is normal. What you are really checking is that every row of this table is represented and that nothing electronic is short. The exact hardware counts for your kit are in its own documentation; when this table and your kit's list disagree, the kit's list wins.

Don't be confused. The PCB (printed circuit board) and the plates look similar, flat fiberglass or acrylic shapes cut in the Lily58 outline, but only the PCB has copper traces, silkscreen printing (the white lettering and symbols), and pads to solder. The plates are purely structural: the top plate holds switches straight, the bottom plate is the floor of the case. You never solder anything to a plate. If a flat part in the bag has no metal circuitry on it, it is a plate.

You are done when every row is ticked, spares are set aside in a labeled bag, and any shortage has been photographed and reported to the vendor.

Lab part 2: inspect the PCBs

Hold each main PCB up to the light and look it over on both sides:

1. Edges: no cracks, no delamination (layers of the board peeling apart), no chunks missing. Small roughness where the board was snapped from its manufacturing panel is normal.
2. Surface: no deep scratches that cut through the traces (the thin copper lines under the coloured coating). Hairline scuffs in the coating alone are cosmetic.
3. Sockets and holes: peer at the through-holes (TRRS, reset, controller rows). They should be clean rings of metal, not torn or filled with debris.
4. Bend test, gently: the board should feel stiff. Any flex with a crackling sound means shipping damage; stop and contact the vendor.

Do the same quick pass on the controllers and OLEDs. Their components are tiny and pre-soldered; you are only looking for anything visibly knocked off or crushed.

You are done when both PCBs, both controllers, and both OLEDs have passed a visual check under good light.

The one concept this chapter exists for: reversible PCBs

Here is the thing that trips up more first-time Lily58 builders than any soldering mistake, so we are going to take it slowly.

Open the kit and you will find that the two main PCBs are identical. Not mirror images. Identical, same shape, same holes, same printing. But a split keyboard needs a left half and a right half, and those are mirror images of each other. How can two identical boards become mirrored halves?

By flipping one of them over. That is the entire trick. A board that is the left half when face A points up becomes the right half when you turn it over so face B points up. Designing one board that works both ways is cheaper than designing two, so that is what the Lily58 (and most hobbyist split keyboards) does. This design is called a reversible PCB.

        The same physical board, used two ways:

        LEFT half                      RIGHT half
     (face A toward you)           (face B toward you)

      ___________                       ___________
     /  q w e r  |                     |  u i o p  \
    |  a s d f   |     same board,     |   j k l ;  |
    |  z x c v   |    flipped over     |   m , . /  |
     \___thumb___|                     |___thumb___/

     Face B is now the                Face A is now the
     BACK of this half                BACK of this half

The consequence you must burn in: every pad exists on both sides of the board. Each diode position has pads on face A and matching pads on face B. Each socket outline is printed on both faces. The board cannot know which half you have decided it is. Only you know, and you tell it by soldering components onto one specific side. Solder them to the wrong side and the board is electrically fine but physically inside out: the sockets end up where the switches should be, and everything must come off again.

So which side do the components go on? The rule, and the convention this book uses from here to the end:

Components go on the BACK. Switches go on the FRONT.

The front of each half is the side that faces you when you type: the top plate and the switches live there. The back is the side that faces the desk: the diodes, hotswap sockets, TRRS jack, reset switch, controller, and OLED headers all mount there, hidden between the PCB and the bottom plate. When you flip a finished half over, you should see all the electronics; when you look at it as you type, you should see only switches.

The labeling ritual (do this now, not later)

Decide, right now, which physical board is your left half and which is your right. There is no wrong choice, the boards are identical; the decision only becomes real when you commit solder. Then:

1. Lay a board down and orient it as the left half (thumb cluster at the bottom right of the board, keys arcing like your left hand). The side now facing up at you is its front. Flip it over.
2. Tear off a piece of masking tape, write "LEFT BACK, PARTS GO HERE" on it, and stick it to the face now showing.
3. Repeat with the other board as the right half: orient it, flip it, label the exposed face "RIGHT BACK, PARTS GO HERE".
4. From this moment, before every soldering stage in Chapter 10, you glance at the tape and confirm you are working on a labeled face. Every component in this build goes on a taped side. If you are about to solder something to a face with no tape on it, stop; something has gone wrong.

Masking tape survives soldering heat at a polite distance and peels off cleanly at the end. Two labels and thirty seconds now retire the single most common Lily58 build error.

You are done when both boards wear a tape label on their back face and you can say out loud, for each board, which half it is and which side gets parts.

The build order, and why it is not negotiable

Chapter 10 works through the components in this sequence:

1. Diodes (58 tiny ones, the flattest parts)
2. Hotswap sockets (58, low-profile)
3. TRRS jacks and reset switches (small through-hole parts)
4. OLED jumpers and 4-pin headers
5. Controller headers or sockets
6. Controllers
7. OLED screens
8. Test with tweezers before any assembly (that step lives in Chapter 12: you flash the firmware first, then short each switch position with metal tweezers and watch letters appear)

Two principles generate this order, and knowing them means you can recover if your kit's guide differs slightly.

Shortest to tallest. While you solder, the board lies component-side up, and to solder a joint well you want the part pressed flat against the board. A flat board resting on the desk does that for free. But once tall parts are mounted, the board rocks on them like a table with one long leg, and every shorter part you add afterward is a wrestling match. Diodes are about a millimetre tall; the controller on its headers is over a centimetre. Do the millimetre parts while the board still lies flat.

Hardest to undo goes last. A misplaced diode is a ten-second fix with the techniques from Chapter 8. A direct-soldered controller is 24 joints on a part you cannot afford to cook, the hardest desoldering job in the hobby. So the controller goes on last among the soldered parts, after everything under it is confirmed, and the test comes before the case closes so that any rework happens with everything still accessible.

That last point deserves its own sentence, because it is the difference between a smooth build and a frustrating one: you will test the electronics before you assemble the case. Screwing the plates on and then discovering a dead column means unscrewing everything again. Chapter 11 and Chapter 12 are deliberately interleaved for this reason, and Chapter 11 tells you exactly when to jump ahead.

Workspace, time, and your own battery

Set the bench up the way Chapter 6 described: iron and stand on your dominant side, brass-wool tip cleaner in reach, flux pen, solder, flush cutters, tweezers, and the safety glasses on your face whenever anything gets clipped. Good light matters more than any gadget here; the parts in stage 1 are the size of a grain of rice. A window open or a small fan pulling the flux smoke away from your face, as always.

Now the honest schedule. A first Lily58 build is 4 to 8 hours of bench time, and you should plan it across a weekend, not a single heroic sitting. The build is 116 diode joints, 116 socket joints, and change; none of them are hard, but they are repetitive, and soldering quality tracks your freshness almost perfectly. The first bad joint of a session is usually a sign the session should end. Natural break points: after each diode half, after each socket half, before the controllers. Stand up, drink water, come back with fresh eyes. The keyboard does not care if it gets finished Sunday instead of Saturday.

One calm paragraph about static electricity (ESD, electrostatic discharge). Chips can in principle be damaged by the little zap you sometimes feel touching a doorknob. Keyboard parts are on the forgiving end of the spectrum, and hobbyists build these boards on kitchen tables every day without incident, so no special equipment is needed. Just adopt two habits: touch something grounded (a metal lamp base, a plugged-in computer case, a radiator) before handling the controllers or OLEDs, and do not build while shuffling your socks across carpet on a dry winter day. That is the whole ESD policy.

Read the official guide too

Your kit either includes a build guide or links to one, and the original Lily58 guide lives in the kata0510 Lily58 repository on GitHub. Read it once before Chapter 10, even though it is terse and this book is not. This book explains why and teaches technique; the kit's guide is the authority on kit-specific facts: exactly which jumper pads your PCB revision uses, which way its silkscreen says the controller faces, what its plate stack order is. Where this book and your kit's guide disagree on a detail like that, the kit's guide and the silkscreen printed on your actual PCB win. Boards get revised; books cannot chase every revision.

Takeaways

• Inventory everything against the checklist before soldering anything; report shortages now, while the vendor can fix them painlessly.
• The two Lily58 PCBs are identical reversible boards; flipping one makes it the mirror half, so every board has pads on both sides and only your choice of side makes it a left or a right.
• The convention: components on the back, switches on the front. Tape labels ("LEFT BACK", "RIGHT BACK") make the convention physical. Check the tape before every stage.
• Build shortest to tallest, hardest-to-undo last: diodes, sockets, TRRS and reset, OLED jumpers and headers, controller headers, controllers, OLEDs, then an electrical test before the case goes together.
• Budget 4 to 8 hours across a weekend, take breaks before you need them, touch something grounded before handling the chips, and let the kit's own guide overrule this book on kit-specific details.

👉 Boards labeled, parts counted, bench lit. Time to make some joints. On to Soldering the boards.

Soldering the boards

This is the long lab, the chapter the whole book has been climbing toward. Everything you practiced in Chapter 7 gets used for real, in six stages, in the order Chapter 9 justified: diodes, sockets, TRRS and reset, OLED jumpers and headers, controllers, screens. Each stage below tells you what the part does, how it must be oriented, the steps, and an inspection gate. Do not skip the gates; they are cheap now and expensive later.

Two standing rules for the whole chapter:

• Before every stage, read the tape. Every component in this chapter goes on a face labeled "LEFT BACK" or "RIGHT BACK". Soldering to the unlabeled side is the classic Lily58 error, and it is committed by smart, careful people who were sure they did not need to check. Check.
• Work one half at a time through each stage (all left diodes, then all right diodes), so a mistake teaches you before you repeat it 58 times.

Total bench time, first build: roughly 4 to 6 hours for this chapter alone. The per-stage estimates below assume a beginner going carefully.

Stage 1: diodes (58 of them, about 60 to 90 minutes)

What they do: each key has one diode, a one-way valve for electricity that lets the controller tell 58 keys apart using only a handful of pins, and lets it see several keys held at once without ghost presses. Chapter 3 explained the matrix they make possible.

Orientation: diodes are the only tiny part in this build that has a direction, and every single one must point the same way. The SMD diode body carries a painted line across one end (the cathode, the "out" end of the valve). The PCB silkscreen marks the matching direction at each diode position. Line up the diode's painted line with the silkscreen's marker, every time, all 58 times. On the Lily58 all the diodes on a half point the same way, which makes checking easy: any diode that looks rotated compared to its neighbours is wrong.

Don't be confused. The painted line on the diode and the marking on the silkscreen are two different things that must agree. The line on the tiny black body is part of the component, put there by the diode factory, and it always marks the cathode. The marker printed in white on the PCB is part of the board, and it shows which way the designer needs the cathode to face at that spot. Your job is to make the component's line sit on the board's line side. Take a photo of your first correctly placed diode and compare every later one against it.

Most current Lily58 kits ship SMD (surface-mount) diodes, type 1N4148W: black grains of rice with a metal tab at each end, sitting on top of pads rather than through holes. The tack-and-reheat technique:

1. Confirm the tape label. Melt a small blob of solder onto one pad of the first diode position (this is "tinning" the pad), then lift the iron.
2. Pick up a diode with tweezers. Check the painted line against the silkscreen marker. Hold it in place on its pads.
3. Touch the iron to the tinned pad so the solder re-melts, slide the diode's end into the molten blob, remove the iron, and hold the diode still for a second while the joint sets. The diode is now tacked down.
4. Look at it side-on: both ends flat on their pads, not tombstoned (one end lifted in the air). Nudge and reheat if needed.
5. Solder the other end normally: iron to pad and tab, feed a little solder, remove.
6. Return to the first end and give it a proper joint: touch the iron, add a whisker of solder if the tack was thin.
7. After every row of about ten, stop and audit: all lines pointing the same way, no tombstones, joints shiny and concave.

If your kit has through-hole diodes instead (small glass or black cylinders with long wire legs, type 1N4148): the direction mark is a band printed around the cathode end of the body. Bend both legs down at 90 degrees using a lead-bending jig or the edge of a ruler so they match the hole spacing, insert with the band toward the silkscreen's cathode marking (often a square pad or the bar of the printed diode symbol; your board's silkscreen is the authority), solder both legs from the back, and snip the excess with flush cutters, safety glasses on. Save two or three of the clipped legs in your spares bag; they make perfect bodge wires (little repair jumpers) if a trace ever needs fixing during troubleshooting.

You are done when all 58 diodes are mounted on taped faces, every painted line agrees with its silkscreen marker, nothing is tombstoned, and a fingertip dragged gently across each row snags on nothing loose.

Stand up. Stretch. This was the fiddliest stage, and it is behind you.

Stage 2: hotswap sockets (58, about 60 to 90 minutes)

What they do: a hotswap socket is a little plastic-and-metal receptacle that grips a switch's pins, so switches push in and pull out without any soldering (Chapter 3). You solder the socket once; the switch is forever replaceable.

Orientation: the socket drops into its silkscreen outline on the back of the PCB, and it only matches the outline one way. Its two metal contact leaves land on the two big pads. If a socket does not sit into the outline naturally, it is rotated; never force it.

The critical quality bar in this stage is flatness. The socket's plastic body must sit flush against the PCB, because the switch pins that arrive from the other side in Chapter 11 are only so long. A socket soldered at a tilt, propped up on a blob of solder, will not grip its switch.

1. Confirm the tape label. Tin one pad of the first socket position, generously; socket pads are big and drink more solder than diode pads.
2. Place the socket into its outline. Press down on its plastic body with tweezers (the body gets hot; tweezers, not fingertip) and reheat the tinned pad until the socket sinks flat against the board. Hold it down while the solder sets.
3. Check side-on: the body flush to the PCB all around, no rocking.
4. Solder the second pad: iron heats pad and contact leaf together, feed solder until it wets both and forms a smooth fillet.
5. Revisit the first pad and make it a full joint too.
6. Tug test every socket: grip the plastic body with tweezers and pull firmly away from the board. A good socket does not move at all. These joints take real mechanical force every time you insert a switch, so a merely-decorative joint will fail in service.

You are done when all 58 sockets sit flush, every one passes the tug test, and both pads of each show a proper wetted fillet, not a ball resting on top.

This is the longest stretch of repetitive work in the build. If your joints are getting worse instead of better, that is fatigue, not failure; break here and come back.

Stage 3: TRRS jack and reset switch, one of each per half (about 20 minutes)

What they do: the TRRS jack is the headphone-style socket where the cable that links the two halves plugs in; the reset switch is the button you press to put the controller into bootloader mode for flashing (Chapter 3, and it earns its keep in Chapter 12).

Both are through-hole parts and neither has a tricky orientation: their pin patterns are asymmetric, so they only fit their holes one way. The enemy here is seating, especially for the TRRS jack. A jack soldered at a slight tilt looks fine on the bench and then fights the cable forever.

1. Confirm the tape label. Insert the TRRS jack from the back so its pins poke through toward the front. Hold it flush with a strip of masking tape over its body.
2. Flip the board, solder one pin only, flip back, and inspect: body flat against the PCB, connector opening square with the board edge? If not, reheat that one pin while pressing the jack home.
3. Happy with the seating, solder the remaining pins.
4. Repeat the same tape, one pin, check, finish sequence for the reset switch. Its little legs sometimes need a gentle inward squeeze to enter the holes; that is normal.
5. Do the other half.

You are done when both jacks and both reset buttons sit flush and straight, and the reset button gives a crisp click when pressed.

Stage 4: OLED jumpers and headers (about 20 minutes)

What this is: the Lily58 routes the OLED screen's signals through solder jumpers, pairs of tiny bare pads sitting almost touching, which you connect by bridging them with solder. Until they are bridged, the OLED connector is electrically dead; forgetting the jumpers is the classic "my screens never worked" mistake, filed in Chapter 13.

Where exactly the jumper pads sit, how many there are, and which side of the board they are on varies with PCB revision, so this is one of the moments to open your kit's build guide and match its photo against your board. Typically they are four pairs near the controller area. Bridge only the jumpers your guide shows; other bare pads on the board are for options you are not using.

The bridging technique, which deliberately breaks the "solder is not glue, use the minimum" rule from Chapter 6:

1. Confirm you are looking at the pads your guide identifies. Add flux from the flux pen across the pad pair.
2. Load a slightly fat blob of solder onto the iron tip and press it across both pads at once. Drag gently. Surface tension pulls the blob into a bridge joining the pair.
3. If the solder balls up on one pad and refuses to span, add more flux and try again; flux, not more solder, is usually the fix.
4. Bridge all the pairs your guide shows, then solder the 4-pin header into the OLED connector holes: short pin side into the board from the back, plastic collar flush, tack one pin, check it is standing straight (a leaning header makes a leaning screen), then finish the other three.

You are done when every jumper pair your kit's guide shows is bridged with a smooth connected blob, no bridge strays onto any third pad, and the 4-pin headers stand perpendicular on both halves.

Stage 5: controllers (the decision stage, 30 to 60 minutes)

What it does: the controller is the small computer that scans the switch matrix and speaks USB (Chapter 3). It connects to the Lily58 through two rows of 12 pins, and you have a genuine decision about how: solder it in permanently, or socket it.

Don't be confused. Ordinary header pins and Mill-Max pins solve the same problem in different ways and are not interchangeable. Header pins are square-ish posts on a plastic strip, soldered to both the board and the controller: permanent. Mill-Max parts are a matched pair, machined round socket strips that solder to the PCB and slim round pins that solder to the controller, and the controller then plugs in and pulls out like a cartridge. Header pins do not fit Mill-Max sockets properly; buy and use the pair together.

Path A: direct solder with header pins (cheaper, ships with most kits, permanent). The soldering is easy; the danger is entirely in orientation, because this is the least reversible step of the build. Get it backwards or upside down and you face 24 joints of the hardest desoldering in the hobby. On the Lily58 most guides mount the controller with its component side down, facing the PCB, so you see its bare back on the finished board. But do not take that, or anything, on trust here:

1. Find the controller footprint on the back of the PCB. The silkscreen marks how the controller sits: which end faces which way, and where the labeled pads go. Match the pin labels on your controller against the markings on the board, and check the whole arrangement against your kit's build guide photos. Only when board, controller, and guide all agree do you pick up the iron.
2. Insert the two 12-pin header strips into the PCB from the back, long pins up. A trick for perfect alignment: seat the controller loosely on top of the pins before soldering anything, so the headers cannot lean.
3. Solder one pin of each strip to the PCB, re-check everything is flush and the controller still fits, then solder the rest of the strip pins to the PCB.
4. With the controller seated in its final orientation, solder all 24 pins to the controller itself. Snip any excess pin length, glasses on.

Path B: Mill-Max sockets and pins (recommended; roughly 10 to 20 dollars extra per keyboard). Controllers are the most likely part to die or be upgraded, and a socketed one swaps out in ten seconds. The whole game is keeping the pins perfectly straight, and the trick is to use the parts as jigs for each other:

1. Solder the two Mill-Max socket strips into the PCB exactly as you would headers: insert from the back, tack one pin, verify flush and upright, finish.
2. Now the pins. Never solder a pin that is sitting crooked; it will be crooked forever. Either (a) push the pins into the socket strips first, rest the controller on top so every pin enters its hole, then solder the pins to the controller while the sockets hold them perfectly aligned, or (b) stand the pins in a spare strip used purely as a jig and do the same. Some pins ship on a plastic carrier bar that serves as the jig; snap it off after soldering.
3. Solder all 24 pins to the controller, let everything cool completely, then pull the controller straight up and out. Straight up: levering at an angle bends pins.

      Mill-Max stack, side view (controller shown lifted):

      [ controller PCB ]
         |  |  |  |      <- pins, soldered to the controller
         v  v  v  v
        [socket strip]   <- soldered to the keyboard PCB
      ===================
        keyboard PCB

A note on the USB port: on ATmega32u4 boards with a micro-USB connector, the port is the board's famous weak point; it is held on by small surface pads and snaps off under cable leverage. Handle the cable by pushing and pulling straight, never by yanking sideways, and consider a dab of epoxy along the connector's sides (not inside it) as reinforcement. RP2040 boards with USB-C are much sturdier here.

You are done when both controllers are mounted in the orientation your board's silkscreen and kit guide agree on, all 24 pins per controller are soldered at both levels (board and controller), and, if socketed, each controller can be removed and reinserted smoothly.

Stage 6: the OLEDs (10 minutes)

The screens ride on the 4-pin headers from stage 4. If you want them removable (worth it: they are fragile and occasionally worth replacing), solder female header sockets to the PCB in stage 4 instead and give each OLED male pins, so it plugs in like a tiny controller. Otherwise solder each OLED directly onto its header pins: seat it parallel to the main board, tack one pin, adjust until it sits level, finish the other three. The OLED's 4 pads are labeled and only line up with the header one way; match the labels on the screen module to the labels by the header on the PCB.

You are done when both screens sit level and firm on their headers.

The final inspection ritual (20 minutes, not optional)

Before anything gets assembled or plugged in, put both halves through this sequence. Every minute here saves ten in Chapter 13.

1. Raking light pass. Hold each board under a lamp at a shallow angle and sweep it slowly. Raking light throws shadows off solder bridges, lifted diode ends, and unsoldered pins that look fine face-on.
2. Phone-camera macro pass. Photograph each region close up and zoom in. The camera magnifies better than your eyes and the photos double as before-assembly records.
3. Diode direction audit. One more full sweep: 58 painted lines, all agreeing with their silkscreen markers.
4. Continuity spot checks. Multimeter to diode mode (the symbol that looks like an arrow against a bar). In this mode the meter passes a tiny current and reads out if it flows. Probe across a few diodes: with the probes one way you should get a reading (a few hundred millivolts) or a beep, and with the probes swapped, nothing. The direction that conducts is the direction the diode points. Also touch one probe to a hotswap socket contact and hunt for its connected diode pad; a beep says the joint and trace are sound. Spot-check a dozen positions across both boards, not all 58.
5. Flux cleanup. Scrub the brown flux residue off with isopropyl alcohol on a lint-free wipe or an old toothbrush, and let the boards dry. Clean boards make every later inspection easier, and some flux residues turn conductive with humidity.

You are done when both boards are clean, photographed, and have passed all five passes with anything suspicious reworked using Chapter 8.

Takeaways

• Read the tape label before every stage; wrong-side soldering is the error to fear, and it is entirely preventable.
• Diodes: painted line to silkscreen marker, all 58 pointing the same way, audited every ten.
• Sockets must sit flush and survive a tug test; TRRS jacks get taped, one-pin tacked, and checked before finishing.
• Bridge the OLED jumpers your kit's guide shows, on the side it shows.
• The controller stage is the least reversible: board silkscreen plus kit guide decide orientation, and Mill-Max sockets buy you a replaceable controller for a few dollars.
• Finish with raking light, macro photos, diode-mode spot checks, and a flux scrub. Rework now, while everything is reachable.

👉 Two clean, fully soldered boards, inspected and photographed. Now they become a physical object you can rest your hands on: Assembly: plates, switches, and keycaps.

Assembly: plates, switches, and keycaps

No iron in this chapter. Today the two soldered boards from Chapter 10 become a keyboard-shaped object: plates, switches, screws, feet, keycaps. It is the most satisfying afternoon of the build, and it starts with a step that is not assembly at all.

Before anything else: test the electronics now

Here is the ping-pong this book warned you about, stated as plainly as possible. Stop. Go to Chapter 12. Do its flashing section now, for both halves. Then do its tweezer test. Then come back here to this paragraph.

The reasoning: flashing the firmware needs nothing but the bare boards and a USB cable, and once a board is flashed you can test every one of the 58 key positions by touching metal tweezers across the two contacts inside each hotswap socket. Each touch closes the circuit exactly as a switch would, and a letter appears in any text editor. Five minutes with tweezers proves every diode, every socket joint, every trace, and the controller, before the case is screwed shut around them. Skip this and discover a dead column after assembly, and your reward is unscrewing everything you are about to lovingly screw together. Builders who have done both orders do not debate this one.

If the tweezer test found dead spots, detour through Chapter 13 and fix them now, while every joint is still exposed. Rejoin here with two fully passing boards.

You are done when both halves are flashed and every one of the 58 positions produced a character under the tweezers.

Lab part 1: OLED covers and standoffs (10 minutes)

Most kits include a small acrylic or FR4 cover that floats above each OLED on short standoffs, protecting the glass from your thumbs. A standoff is a small metal tube threaded at both ends: a screw enters each end, and the tube holds two layers apart at a fixed height.

1. If your acrylic parts wear a brown or blue protective film, peel it now. The film is easy to mistake for a scratched, cloudy finish; underneath is clear acrylic.
2. Screw the OLED standoffs to the main PCB at the holes flanking the screen, then the cover onto the standoffs. Fingertip tight only.
3. Exact stack order and standoff lengths vary by kit; when in doubt, the kit's guide photos settle it.

You are done when each screen sits under a firm cover that does not touch the glass.

Lab part 2: the top plate and the first four switches (20 minutes)

The top plate is the rigid layer with switch-shaped cutouts. Each switch clips into the plate, and its two metal pins continue down into the hotswap socket on the PCB below. Plate and PCB have to come together as a sandwich, and switches are what hold the sandwich together, so the order is: rest the plate loosely over the front of the PCB, then install switches through both layers at once.

Start with only the four corner switches of one half. They act as alignment pins for everything else, and doing four slowly teaches your hands the feel before you do fifty-four more.

1. Look at the bottom of a switch: two metal pins plus plastic posts. The pins must be dead straight. A bent pin looks folded flat against the switch base, or kinked like a knee, instead of standing perpendicular. Straighten any bent pin with tweezers or small pliers before it goes anywhere near the board; it bends back once or twice without breaking.
2. Hold the plate over the PCB at one corner position. Orient the switch the way Chapter 3 showed (pins toward the socket contacts; it only reaches the socket one way around).
3. Support the socket from behind with a fingertip on the back of the PCB, directly under the switch position. All the insertion force should land on your finger, not on the socket's two solder joints.
4. Press the switch straight down through the plate cutout until the plate clips click and you feel the pins slide home into the socket. It is a firm, positive push, not a violent one.
5. Inspect: switch body flush against the plate, and on the back of the PCB, no pin visibly crumpled beside the socket instead of inside it.
6. Repeat for the other three corners, then check the whole plate sits parallel to the PCB, an even gap all around.

You are done when four corner switches are seated flush, the plate is held square, and (since you flashed first) all four produce their letter when pressed with the board plugged in.

Lab part 3: populate the rest (30 to 45 minutes per half)

Now the remaining switches, same technique, one at a time: check the pins, support the socket from behind, press straight down, feel the click. Do not rush the pin check; a bent pin folds silently under the switch, the key feels perfectly normal and clicky, and it types nothing. Finding that after keycaps are on is an avoidable sadness.

The efficient rhythm, since your boards are flashed: keep the half plugged in with a keyboard tester open (Chapter 12 names a couple of free web testers, or any text editor works) and tap each switch right after seating it. Each tap paints a key on the screen. Insert, tap, confirm, next. By the time the last switch clicks in, the entire half is verified.

When a switch will not click in: the clinic

• It stops a few millimetres proud of the plate and pushing harder feels wrong. Trust that feeling and pull the switch back out (straight up, wiggling gently). Nine times out of ten a pin has folded under. Straighten it, try again.
• The switch seats but the key is dead. Pull it and look: a bent pin, or a pin that missed the socket opening and slid beside the plastic body. Straighten, re-aim, support the socket, press again. If the pin is straight and it is still dead, check the back: the insertion force may have pushed the socket off its pads, which means one reflow with the iron (Chapter 8) and a reminder about supporting from behind.
• No switch in one area goes in nicely. The plate is misaligned by half a cutout. Back out the nearby switches, re-square the plate against the corner switches, try again.

You are done when all 58 switches sit flush with the plate and all 58 type their character.

Lab part 4: bottom plate, screws, and feet (15 minutes)

1. Screw the M2 standoffs to the main PCB at the case holes (your kit's guide shows which holes and which length standoff; count them out first).
2. Lay the bottom plate on and drive the M2 screws into the standoffs. Snug, then stop. The plates are FR4 or acrylic; FR4 strips its screw holes when muscled, and acrylic simply cracks, instantly and audibly. Tighten each screw until it seats, plus the smallest fraction more, and work in a criss-cross pattern so the plate pulls down evenly.
3. Stick the rubber bumpons (adhesive feet) onto the bottom plate: one near each corner of each half at minimum. They stop the halves skating around the desk and give the screws clearance so they do not scratch it.

You are done when both halves are closed, nothing rattles when shaken gently, and each half sits flat without rocking.

Lab part 5: keycaps (15 pleasant minutes)

Keycap sizing is measured in units: 1u is one standard key width. The Lily58 is friendly here: on most sets, every position takes a 1u cap except the innermost thumb key on each half, which takes a 1.5u. Check your kit and keycap set, but if you sort your caps into "two 1.5u" and "everything else", you are nearly done thinking.

Two 1u caps are special: the ones with a small ridge or dimple on top, the homing bumps. On a normal keyboard they live on F and J, where your index fingers rest. Same idea here: they go on the home-row index positions, one per half, F on the left and J on the right in a QWERTY layout, so your hands can find home without looking. Which physical key that is depends on the keymap you flashed; with the default QWERTY layout it is the second column from the inside, home row, on each half.

Press each cap straight down onto its switch stem until it seats. No twisting: the cross-shaped stem is plastic and twisting rounds it out. If a cap goes on crooked, pull it straight off and reseat it.

You are done when every switch wears a cap, the two 1.5u caps are on the thumbs, and your index fingers find the bumps without looking.

Lab part 6: cables, and the one rule you never break

Two cables remain. The TRRS cable links the halves, carrying power and the signals that let one controller report the other's keys. The USB cable goes from one half to the computer.

Don't be confused. A TRRS cable and a TRS cable look identical from arm's length, and both plug into the Lily58's jacks without complaint. Count the black insulating rings on the metal plug: TRRS (tip, ring, ring, sleeve) has three rings dividing it into four contacts; TRS has two rings and only three contacts. The Lily58 uses all four, so a TRS cable, the kind on ordinary headphone and aux leads, leaves one signal disconnected and gives you a half-working keyboard with baffling symptoms. Use the cable from the kit, or buy one explicitly sold as TRRS (a 4-pole 3.5 mm audio cable is the same thing). By default in the Lily58 firmware, the left half is the master: plug USB into the left, and the right talks to it over TRRS. (Whether both halves need flashing, and how to make the right half the USB side instead, is Chapter 12's business.)

Now the sacred rule, and it deserves its explanation:

Never plug in or unplug the TRRS cable while USB is connected. Unplug USB first, every time.

The reason is mechanical. A TRRS plug is a metal cylinder divided into four contact bands, and as you slide it in or out, each band drags across every contact inside the jack on its way to its own. For a moment, the power band touches the ground contact, the data band touches the power contact, and so on: brief short circuits, made with live current if USB is powering the board. Most of the time nothing happens. Sometimes the controller or a component dies on the spot, and it is a completely unnecessary way to lose a board you just built. Cold cables only: connect TRRS, then USB; disconnect USB, then TRRS.

First power-up

Position the halves shoulder-width, connect the TRRS cable, take one breath, and plug the USB cable into the left half.

If you did the pre-assembly flash and test, you already know it works, and that robs nothing from this moment. The OLEDs light. You open an editor, put your fingers on the bumps, and type your name on a keyboard that did not exist last week, on solder joints your own hands made. Every builder does some version of typing "hello" and grinning at it. Take the photo; you earned it.

Type a slow sentence touching every key you can think of. If a straggler key plays dead now after passing the tweezer test, it is almost certainly a bent switch pin (the clinic above), not your soldering.

Takeaways

• Flash and tweezer-test before assembly; Chapter 12 first, then this chapter. The ping-pong is deliberate and it saves disassembly.
• Switches: check the pins, support the socket from behind, press straight down, and test each key as you go. Corners first to square the plate.
• M2 screws snug, never cranked; acrylic cracks and FR4 strips.
• Caps are all 1u except the two 1.5u thumbs; homing bumps go under your index fingers on the home row.
• TRRS is only ever plugged or unplugged with USB out. No exceptions.
• Left half takes the USB cable by default.

👉 The hardware is complete: a real, solid, clicking object. What makes it a keyboard, and makes it yours (layers, keymaps, the OLED display), is the firmware. On to Chapter 12, which you have already visited once and now get to finish.

Firmware: making the keys type

Everything you soldered in Chapter 10 is, right now, an inert sculpture. The switches close circuits, the diodes point the right way, the controller sits in its socket, and none of it does anything, because nobody has told the controller what its job is. That is what firmware does: it is a small program that lives permanently on the controller and runs the moment power arrives over the USB cable.

The job it runs is simple to describe. Many times per second, the firmware scans the matrix: it powers each row in turn and checks each column to see which switches are closed (you met the matrix and its diodes in Chapter 1). When it finds a pressed key, it looks that position up in a table called the keymap ("row 2, column 3 means the letter D"), and reports the result to your computer over USB using a standard language called HID (Human Interface Device). HID is the same protocol every keyboard and mouse on earth speaks, which is why your hand-built board needs no drivers: the computer just sees "a keyboard."

So "flashing firmware," the step this chapter walks you through, means copying that program onto the controller. You will do it twice, once per half, and it takes about two minutes per half once you have the file. Getting the right file is most of the chapter.

The lay of the land: QMK, Vial, VIA, ZMK

Four names come up constantly in this hobby, and they overlap in confusing ways. Here is the honest map.

QMK (Quantum Mechanical Keyboard) is the standard firmware for wired custom keyboards. It is free, open source, and supports hundreds of boards, including ours: the Lily58 is a supported keyboard in the official QMK repository, so you never have to write firmware, only configure it. Everything else in this list is either built on QMK or defined by how it differs from QMK.

Vial is a fork of QMK (a modified copy that evolves alongside it) with one killer feature: once a Vial-enabled firmware is on your board, you can remap any key live, from a page in your web browser at vial.rocks, with no reflashing. Press the key on screen, pick its new meaning, done, and the change is saved on the keyboard itself. For a beginner this is the friendliest wired path by a wide margin, when a prebuilt Vial firmware exists for your specific controller. For the Lily58 with common RP2040 controllers, it usually does; check get.vial.today and your kit vendor's documentation.

VIA is the same idea as Vial (live remapping through a graphical tool) but a separate, older ecosystem with its own app at usevia.app. Some prebuilt firmware supports VIA, some supports Vial, some supports neither. They are not compatible with each other. If your vendor hands you a "VIA firmware," use the VIA app with it; the experience is very similar.

ZMK is a different firmware entirely, built for wireless keyboards. If you chose the nice!nano wireless route back in Chapter 2, ZMK is your world: you configure it by editing files in a GitHub repository, and GitHub's servers build the firmware for you automatically (a system called GitHub Actions), then you download the result. It works well, but it is a different book's worth of material, and Typeractive's documentation (see the references) teaches it better than a detour here could. This chapter assumes the wired build.

Don't be confused. QMK, VIA, and Vial are not three rival firmwares. QMK is the firmware. VIA and Vial are both "a way to remap a QMK-based firmware live from a graphical app," and each needs a firmware built with its support turned on. Think of QMK as the engine, and VIA or Vial as two different dashboards you can order the car with. ZMK is the genuinely separate thing: a whole different engine, for wireless boards only.

The beginner path: no toolchain, no tears

You can install QMK's full development environment on your computer, and one day you might want to. On day one, do not. There are two easier routes, and both produce a perfectly good firmware file.

Route 1: a prebuilt Vial firmware. If your kit vendor or the Vial project publishes a ready-made Lily58 Vial firmware for your controller, download it, flash it (next section), and you are done forever with flashing: all future remapping happens live at vial.rocks. This is the path we recommend when it exists. The catch is the words "for your controller": a firmware built for an ATmega32u4 Pro Micro will not run on an RP2040 board and vice versa, so match the file to what you actually socketed.

Route 2: QMK Configurator. This is QMK's official point-and-click firmware builder at config.qmk.fm. It runs in your browser, holds your hand, and compiles the firmware on QMK's servers so you install nothing. Here is the whole procedure:

1. Open config.qmk.fm. In the Keyboard dropdown, type lily58 and select lily58/rev1.
2. If the site asks about the controller or offers a converter option, pick the one matching your board (for RP2040 drop-in boards like the Elite-Pi or Frood, QMK calls this a "converter" such as elite_pi; the Configurator exposes it near the keyboard selection).
3. Click Load default keymap. The screen fills with a picture of the Lily58 with the standard layout on it.
4. To change a key: click the key on the picture, then click its new assignment from the big palette of key codes below. Repeat as you like, or change nothing on your first pass.
5. Give the keymap a name in the Keymap Name box (your own name works fine), then press Compile. A progress pot boils for a minute.
6. Press the Firmware download button. You get one file: a .uf2 file for RP2040 boards or a .hex file for ATmega32u4 boards.

That file is your firmware. On to putting it on the board.

Flashing, route A: RP2040 boards (the easy one)

This is why Chapter 2 steered you toward an RP2040 controller. Every RP2040 board has a built-in bootloader, a tiny factory-installed program whose only job is to accept new firmware, and it presents itself as a plain USB drive. The whole flash is a drag and drop:

1. Plug the half you are flashing into the computer by USB. Only that half; leave the TRRS cable disconnected while flashing.
2. Put the board into bootloader mode: hold the BOOT button while plugging in (or while tapping reset), or double-tap the reset button quickly. Your kit's controller docs say which; most accept both.
3. A drive named RPI-RP2 appears on your computer, exactly like a USB stick.
4. Drag the .uf2 file onto that drive.
5. The drive vanishes by itself after a second or two. That is success: the board copied the firmware and rebooted into it.

No software to install, no drivers, nothing to type. Repeat for the other half with the same file.

Flashing, route B: ATmega32u4 Pro Micro (the classic one)

The classic Pro Micro has an older bootloader called Caterina, and it does not show up as a drive. You need a small helper program: QMK Toolbox, free from the QMK project (search "QMK Toolbox" on GitHub; Windows and macOS builds are provided).

1. Open QMK Toolbox and use Open to select your .hex firmware file.
2. Plug in the half you are flashing, alone.
3. Double-tap the reset button (or short the RST and GND pins with tweezers if your board has no button). The Caterina bootloader wakes up for about eight seconds, and Toolbox prints a yellow "device connected" line.
4. Within that window, click Flash. Text scrolls, ending in a success message.

If you miss the eight-second window, nothing breaks; double-tap again and re-click. Repeat for the other half.

Don't be confused. Compiling and flashing are two different steps. Compiling turns your configuration (which keys do what) into a firmware file; the Configurator did that on QMK's servers. Flashing copies that file onto the controller. You compile once per keymap change; you flash once per half. And on Vial or VIA firmware, remapping later needs neither: the app changes the keymap in place.

Two halves, one keyboard: master, slave, and handedness

Both halves get the same firmware file. At runtime, the half with the USB cable becomes the master: it talks to the computer, and it asks the other half (the slave) over the TRRS cable which of its keys are pressed. Newer documentation sometimes says "central" and "peripheral" for the same roles.

The firmware also needs each half to know whether it is the left or the right half, because the matrix is mirrored. The Lily58's default firmware uses the simplest rule: the half with the USB cable plugged in is the left half. So the common default setup is: USB into the left half, TRRS cable across to the right, and everything just works. If you would rather plug USB into the right half, QMK supports storing handedness permanently in EEPROM, a small scrap of memory on the controller that survives power-off. QMK ships special one-time firmware and a documented procedure for this (search the QMK docs for "setting handedness"); flash the handedness setting once, then flash your real firmware, and from then on either half is happy to take the cable. It is a nice upgrade, not a day-one requirement.

One rule worth repeating from Chapter 11: never plug or unplug the TRRS cable while USB power is connected. The TRRS plug shorts adjacent contacts as it slides in, and doing that on a powered board can damage a controller. Unplug USB first, always.

The tweezer test: prove it types before the switches go in

This is the payoff moment, and it belongs in Chapter 11's pre-assembly test, before you close anything up. With firmware flashed on both halves, USB into the left half, TRRS between them:

1. Open a keyboard tester in your browser. Any of the free online testers works (see the references); even a blank text document does the job, though a tester shows modifier and function keys too.
2. Take your metal tweezers and touch both contacts of one hotswap socket at the same time, bridging them. You are doing exactly what a switch does: closing the circuit.
3. A letter appears on screen. That single letter proves the socket, the diode, the matrix trace, the controller, the firmware, and the USB link, all at once.
4. Walk every socket on both halves, watching a character appear for each. Keys on the thumb clusters and the outer columns produce modifiers and layer keys, which the tester lights up rather than typing.

Any socket that stays silent gets marked with a sticky note and handled by Chapter 13's dead-key procedure, which is far easier now than after the switches are in.

Keymaps and layers, gently

A keyboard with 58 keys replaces one with 104. The trick is layers: the keymap is not one table but a small stack of them, and holding a special key switches which table is live. It is the same idea as the Shift key, which you have used your whole life: hold it and every key means something else.

The Lily58's default keymap has three layers you will actually use:

• Base layer: letters, numbers across the top row, Enter, common punctuation. Where your fingers live.
• Lower (hold the left thumb's layer key): symbols and the function keys, F1 through F12.
• Raise (hold the right thumb's layer key): arrows, brackets, and the punctuation that did not fit.

Hold the thumb key, tap the key you want, release. After a week your thumbs do it without asking you. The default keymap is deliberately conservative and close to a normal keyboard; live on it for at least a week before changing anything, so you learn what actually annoys you rather than what you guessed would.

When you do want a change, it is the Configurator loop from earlier: load your keymap, click the key, click its new meaning, compile, download, flash both halves. Or, on Vial firmware, open vial.rocks and click; the board updates instantly. For readers who like seeing what happens underneath, a keymap in QMK's source is literally a grid of key names in a text file, one entry per physical key per layer. Nothing mystical.

For the curious: the full QMK toolchain

If you outgrow the Configurator (you will know, because you will want a feature its interface does not expose, like home-row modifiers or custom OLED code), the next step is installing QMK on your own machine. In brief, so you know its shape: you install Python, run python3 -m pip install qmk, then qmk setup, which downloads the whole QMK source tree and checks your system. From then on, compiling is one command:

$ qmk compile -kb lily58 -km default
Ψ Compiling keymap with gmake ...
...
 * The firmware size is fine - 22528/28672 (6144 bytes free)

That output is illustrative, not from a real run; the exact lines vary with your setup and controller. Your own keymaps live in a folder you edit with any text editor, and the QMK documentation at docs.qmk.fm is genuinely good. There is no rush: the Configurator covers everything a first-year keyboard needs.

If you have OLEDs

If you soldered the optional SSD1306 screens back in Chapter 10, the default Lily58 firmware already drives them: the master half typically shows the current layer name and what you are typing, and the slave half shows the Lily58 logo. If a screen stays dark, check Chapter 13 before suspecting the screen itself. Customizing what the OLEDs display (animations, word counters, tiny pets that walk faster as you type) is a beloved rabbit hole that requires the full toolchain and a little C code; the QMK documentation's OLED driver page is the trailhead when you are ready.

Takeaways

• Firmware is the program on the controller that scans the switch matrix and speaks USB HID to your computer. Flashing means copying it on.
• QMK is the standard for wired boards and supports the Lily58 out of the box. Vial and VIA add live remapping on top of it. ZMK is for wireless builds only.
• Day-one path: a prebuilt Vial firmware if one exists for your controller, otherwise QMK Configurator at config.qmk.fm. No toolchain install needed.
• RP2040 flashing is drag and drop onto the RPI-RP2 drive. ATmega32u4 flashing uses QMK Toolbox and a .hex file, inside the eight-second bootloader window.
• Both halves get the same file. USB side is master; default handedness assumes USB into the left half. Never hot-plug the TRRS cable.
• The tweezer test proves every socket types before a single switch goes in. Do it.
• Layers are the Shift-key idea generalized. Live on the default keymap for a week before customizing.

👉 Something will not work on the first try. That is not pessimism, it is statistics, and it is fine: Chapter 13 turns every symptom into an ordered checklist.

Troubleshooting the finished board

Here is the most reassuring fact in this book: nearly every problem a freshly built Lily58 can have is either a solder joint or a bent pin. Not a fried chip, not a ruined board, not a mystery. A joint or a pin. Both cost nothing to fix, and because you socketed the controller in Chapter 10, even the worst realistic case (a genuinely dead controller) costs one replacement board and thirty seconds of swapping, not a rebuild.

The other reassuring fact is that a keyboard fails in legible ways. One key, one row, one half, or everything: each pattern points to a different, specific place, because you know exactly how the signal travels. Switch, socket, diode, trace, controller pin, firmware, USB. A fault is just a break somewhere along that chain, and the symptom tells you which stretch of road to search.

So work like a repair tech: read the symptom, run the checks in the order given (they are ordered by likelihood and by effort), change one thing, retest. Do not shotgun five fixes at once, for the same reason the lemon-squeezer book gives about failed prints: if it works afterward, you will not know why, and you will not trust the board.

Keep the tools from Chapter 5 nearby: tweezers, the multimeter, the iron, and a browser tab with a keyboard tester open.

One dead key

The most common fault, and the one with the most satisfying fix rate.

1. Pull the switch and look at its pins. This is the cause about 90 percent of the time on a hotswap board: one of the switch's two metal legs folded flat under the housing instead of entering the socket. Use the switch puller, pull straight up, and look at the underside. A bent pin is obvious. Straighten it gently with tweezers or pliers (they survive one or two straightenings), then reinsert while supporting the socket from below, as in Chapter 11. This fixes most dead keys on the spot.
2. Tweezer-test the socket. Pins were straight? Bridge the empty socket's two contacts with tweezers, watching the tester. If a letter appears, the electronics are fine and the problem was switch seating (or, rarely, a dud switch: try a spare in that socket).
3. Tug and reflow the socket. No letter from the tweezers? Flip the board and push each of the socket's two solder pads gently with a fingernail or the tweezers. Any movement at all means a cracked or cold joint. Even without visible movement, the cheap fix is to reflow both joints: touch the iron with a whisper of fresh solder to each pad for a second, as in Chapter 8. Retest.
4. Check that key's diode. Still dead? Look at the diode belonging to that key. Is its orientation mark (the band or arrow) pointing the same way as its neighbours'? Are both its joints shiny and full, not grey and cratered? Reflow them, or if the orientation is wrong, desolder and turn it around (Chapter 8 again).
5. Trace continuity with the multimeter. The last resort, and a genuine skill-builder. The walkthrough below shows the whole procedure on a real example.

A continuity walkthrough, told as a story

Say the K key is dead. Tweezers on the socket give nothing, the joints look fine, the diode looks fine. Time to let the multimeter tell the truth, because eyes lie about joints and meters do not.

Set the meter to continuity mode (the beep symbol, from Chapter 5) with the board unplugged from USB. The signal path for one key has three legs, so test three stretches:

First, socket to diode. One probe on the socket contact that leads toward the diode (follow the visible trace, or just try both), the other probe on the diode's near leg. Beep: that stretch is good. On our imaginary K key, it beeps.

Second, through the diode itself. Continuity mode often reads a diode in one direction only, which is fine, that is what a diode is for. Many meters have a dedicated diode mode showing a voltage drop around 0.6 for a healthy diode. Probe both ways; conduction one way and not the other means healthy. Our K diode passes.

Third, diode to controller. One probe on the diode's far leg, the other touching each pin of the controller socket in turn until something beeps (patience; there are 24). On the K key, nothing beeps on any pin. There is the break: between the diode and the controller. And the most common break on that stretch is not the buried trace, which almost never fails, it is the joint at either end. A close look under bright light shows the row's controller-header pin has a dull, grey joint with a hairline ring around the pin: a classic cold joint from Chapter 6. Ten seconds of reflow, the meter beeps, the tweezer test types a K, and the switch goes back in. Total time: fifteen minutes, most of it learning.

A whole row or column dead

Several keys dead in a line is actually good news: one shared thing serves them all, so there is exactly one fault, not five.

1. Identify the shared line. Keys dead in a horizontal line share a row; a vertical line (on a columnar board like the Lily58, a finger's column) shares a column.
2. Reflow the controller header joint for that line. Each row and column arrives at exactly one controller pin, through one joint on the header you soldered in Chapter 10. One cold joint there silences the whole line. Since you probably do not yet know which pin it is, the pragmatic move is to reflow all 12 header joints on that half; it takes three minutes and cures the majority of row/column faults.
3. Find the exact pin, if you want to. The kit's schematic (a wiring diagram, usually a PDF in the kit's GitHub repository) lists which controller pin serves each row and column, and so does the Lily58's configuration file inside QMK's source (a file that literally lists pin names next to the words "rows" and "cols"). You do not need to read either fluently: search the page for "row" and match up the pin names printed on the controller board. Then continuity-test from any dead key's diode to that specific pin, as in the walkthrough.
4. Check for a bridge. If instead of dead keys you get wrong or doubled keys along a line, look for a solder bridge between two adjacent header pins (Chapter 8 shows the wick fix).

An entire half dead

The half with USB works perfectly; the other half is a brick. The chain to suspect is everything between the two halves.

1. Reseat the TRRS cable, both ends, with USB unplugged. Push until it clicks fully home. A half-seated TRRS plug is embarrassingly common.
2. Check the cable is TRRS, not TRS. Count the rings on the plug's metal tip: three separator rings (four contacts) is TRRS and correct; two rings (three contacts) is TRS, an audio cable that looks identical and cannot carry the data line. This one cable mix-up may be the single most common "dead half" cause in the hobby.
3. Try another cable. Any four-pole 3.5 mm cable works. Cables fail internally with no visible damage.
4. Inspect and reflow the TRRS jack joints on both halves. The jack's pins are stubby and easy to have under-soldered, and the jack takes mechanical stress every time you plug in.
5. Confirm the dead half's firmware. Plug USB directly into the dead half, alone. If it types (as the wrong hand, which is expected), its electronics are fine and the fault is in the link or the jacks. If it does nothing even on USB, reflash it.
6. The hard question: was it hot-plugged? If the TRRS cable was plugged or unplugged while USB power was connected, and the half died at that moment, the controller may be damaged. This is the case the socket was bought for: swap in a spare controller (or the other half's, temporarily, after flashing) and see if the half revives.

Halves work alone, but not together

Each half types when it has the USB cable, but the far half is dead when connected by TRRS. This is the "entire half dead" chain minus the firmware step: it is the cable (TRS versus TRRS again, step 2 above), the jacks' solder joints, or, rarely, the handedness confusion covered under "wrong letters" below.

The computer does not see the keyboard at all

Nothing types, and the operating system shows no new device.

1. Suspect the USB cable first. Many USB-C and micro-USB cables that come with gadgets are charge-only: power wires, no data wires, and no marking to warn you. Swap in a cable you know carries data (one that has synced a phone, for example), and try a different USB port, directly on the computer rather than through a hub.
2. Check the bootloader responds. Double-tap reset on the USB half. On an RP2040 board, does the RPI-RP2 drive appear? If yes, the controller, its USB circuitry, and the cable are all fine, and the problem is the firmware: the file may be wrong for this controller or corrupted. Re-download and reflash, per Chapter 12. If the drive never appears with a known-good data cable, check the controller header joints, then suspect the controller board itself.
3. On ATmega32u4 boards, the equivalent check is whether QMK Toolbox reports a device connecting during the eight-second bootloader window.

Keys type the wrong letters

The board types, but a key gives a different character than expected.

1. Wrong keymap flashed? If the pattern of wrongness looks like an entirely different layout, you may have flashed a different keymap (or a different keyboard's firmware) than you thought. Reflash the file you intended, on both halves.
2. A stuck layer? If letters come out as symbols or numbers, a layer key may be held down by a misseated switch, or a one-shot layer got latched. Unplug, replug, and test with the thumb keys untouched.
3. Left and right swapped? If the left half types the right half's letters, the handedness is inverted: the firmware decided the wrong half is "left." With the default setup, just move the USB cable to the other half. To make your preferred side work permanently, use QMK's EEPROM handedness procedure from Chapter 12.
4. Operating system layout. If punctuation in particular is scrambled, check the OS is not set to a different language layout. The keyboard reports key positions; the OS decides what they print.

One key types multiple letters, or letters appear you never pressed

Ghosting on a diode-per-key board points at one culprit: a diode soldered backwards. A reversed diode lets current sneak the wrong way through the matrix, so pressing certain combinations conjures phantom presses at other positions. Find the key at the intersection of the phantoms, check its diode's orientation mark against its neighbours, and reverse it (Chapter 8). A solder bridge between adjacent pads produces similar mischief; inspect under bright light.

A key chatters (one press, double letters)

If a key sometimes registers twice per press, the switch contacts are bouncing more than the firmware's debounce (the short wait that filters contact bounce) expects.

1. Reseat or swap the switch. This is the hotswap payoff: pull the chattering switch, drop in a spare, done in a minute. Chattering is nearly always the individual switch, from a dust fleck or a manufacturing dud.
2. Raise the debounce in firmware if several switches chatter, via a QMK setting (search the QMK docs for "debounce"). This needs the full toolchain, so try the switch swap first.

The OLED stays blank

1. Check the jumpers. The Lily58's OLED needs solder jumpers bridged on the correct side of the board, done back in Chapter 10. If a screen never lived, this is the first suspect: confirm against the build guide that the bridged jumpers are on the same side as the components for that half.
2. Reflow the four header pins on both the display and the board. The OLED header is a common cold-joint site because its pins are short.
3. Is it enabled in firmware? The default Lily58 firmware drives the OLED, but some prebuilt or minimal firmwares ship with the display disabled. Flash a firmware known to include OLED support and retest before doing any more soldering.
4. Screens themselves do occasionally arrive dead; if you bought a spare, swap it as the last check.

When to ask for help, and how to ask well

If you have run a symptom's full checklist twice and the board still misbehaves, stop and ask. The communities are friendly and have seen everything: r/olkb (the home of QMK-adjacent DIY boards), r/ErgoMechKeyboards (splits specifically), and your kit vendor's Discord server, where people know your exact PCB revision.

A good help post gets good answers. Include:

• Sharp, well-lit photos of the actual joints in the suspect area, close enough to count pins. "It doesn't work" with no photo gets guesses; a photo often gets the answer in minutes, because experienced eyes spot a cold joint instantly.
• Exactly which firmware you flashed (file name, where it came from, which controller you have).
• The symptom in matrix terms: which keys, which half, one key or a line.
• What you already tried, so nobody repeats your first hour for you.

Takeaways

• Read the pattern first: one key, one line, one half, or nothing, and each pattern has its own short checklist. Run checks in order, change one thing, retest.
• One dead key is a bent switch pin until proven otherwise. Pull the switch and look before touching the iron.
• A dead row or column is one controller-header joint. A dead half is the TRRS chain. Wrong letters are firmware or handedness. Phantom letters are a backwards diode.
• The multimeter's continuity beep settles arguments your eyes cannot. Trace socket, diode, controller pin, and the silence shows you the break.
• Charge-only USB cables and TRS-instead-of-TRRS cables cause an outsized share of "my keyboard is dead" panic. Check cables before checking solder.
• Never plug or unplug TRRS under USB power, and remember the socketed controller means even the worst case is a cheap swap, not a rebuild.
• Ask for help with photos, firmware details, and what you tried.

👉 The board works. Now comes the part nobody warns you about enough: the two weeks where you type like it is your first day on earth, and everything after that, in Chapter 14.

Living with it: layouts, mods, and next builds

The keyboard on your desk works. Every key types, the OLEDs glow, and you built it. This chapter is about the part that starts now: actually typing on the thing, making it yours, and where this hobby goes if you let it.

The two-week dip

First, the warning from the introduction, now due in full: for the next little while, you will type worse than you have since childhood. Expect your speed to drop 30 to 50 percent on day one. Words you have typed ten thousand times will come out scrambled. You will reach for B with the wrong hand and hit nothing, because on a split board the B is only on the left, and your right index finger has apparently been poaching it for years without telling you.

This is not the keyboard being wrong. It is columnar stagger doing exactly what you bought it for. A normal keyboard's rows are offset diagonally (a leftover from typewriter lever mechanics), and your muscle memory learned those diagonals. The Lily58 puts each finger's keys in a straight column, which is where your fingers actually travel, and your hands need time to unlearn the diagonal reaches. The retraining is the point; the dip is the price.

A realistic timeline, from many people's experience including split-keyboard vendors' own guidance:

• Day 1 to 3: frustrating. Everything requires thought. This is the danger zone for giving up; do not judge the board here.
• Week 1: usable. You can work, slowly. The letters are back; the punctuation and the layer keys still need glances.
• Week 3 to 4: back to your old speed for most people.
• After that: past it, for many, because your fingers travel less and the layers put symbols closer than the top-right corner of a full keyboard ever was.

The practice plan that gets you through it:

1. 15 minutes a day of deliberate practice on a typing site. monkeytype.com for general speed work, keybr.com for methodical retraining (it adapts to your weakest letters). Fifteen focused minutes beats two resentful hours.
2. Keep the old keyboard within reach, but make yourself earn it. Deadlines are real; if you must ship something today, swap keyboards without guilt. But default to the Lily58 for everything else, because every hour on the old board pays back a little of your retraining.
3. Do not customize the keymap during the dip. You cannot yet tell "this layout choice is bad" from "my hands are still learning." Give the default keymap two weeks before changing anything, as Chapter 12 advised.

Making the layout yours

After the dip, annoyances surface, and each one is a keymap edit away from gone. The craft here is restraint: change one thing at a time, then live with it for a few days. A keymap edited in ten places at once is ten new things to learn simultaneously, and you are back in the dip.

Some changes almost everyone makes eventually:

• Caps Lock becomes something useful. Nobody misses it. Escape (beloved by Vim users) or Ctrl are the classic tenants of that prime real estate. On the Lily58 the equivalent spot is the home-row pinky key on the outer column.
• Ctrl somewhere comfortable. The bottom-corner Ctrl of a normal keyboard is a pinky-curling stretch. Popular alternatives: the outer thumb keys, or the outer home-row keys.
• Hold-versus-tap keys. QMK lets one key do two jobs: tap for Escape, hold for Ctrl, for example. This is a gateway to home-row mods, where holding A means Shift, holding S means Ctrl, and so on, right under your fingers. Honest assessment: home-row mods are powerful and beloved by the people they work for, and fiddly for everyone at first. Misfires (a held letter registering as a modifier, or the reverse) take real tuning to eliminate. Try them in month two, not week two, and know that abandoning them is a common and respectable outcome.
• The number-row question. "Where did my number muscle memory go?" is the most common complaint about small boards, and layers are the answer: a numpad-style block on the Lower layer, under your right hand, is faster than the top row ever was once learned. The Lily58 keeps a real number row anyway, so you can defer this decision forever. That is partly why Chapter 2 picked it.

Every one of these is a five-minute change in QMK Configurator or a live edit in Vial, per Chapter 12. Keep a copy of each keymap version you flash (the Configurator can export your layout as a small file); when an experiment fails, roll back instead of reconstructing.

Comfort mods: the desk around the keyboard

The split shape is half the ergonomic win. The other half is placement.

Halves at shoulder width. Put the halves far enough apart that your forearms point straight ahead rather than angling inward. Most people place them too close together at first; slide them apart until it feels almost too wide, and your shoulders will disagree with "too."

Tenting means tilting each half so the inner edge (thumb side) rises, letting your wrists rotate toward the natural handshake angle instead of lying pancake-flat. Options by budget:

• Nearly free: stick-on rubber feet of different heights, or a wedge of any stable material under the inner edge. Even 10 degrees is noticeable.
• 3D printed: printed tent legs and full tenting cases for the Lily58 are shared freely on model sites. If this appeals and you do not print, the sibling book in this series teaches 3D printing from zero and includes exactly the outsourcing knowledge to have someone else print a set for you.
• Commercial: adjustable tenting kits and tripod-mount cases exist in the CAD 40 to 100 range from split-keyboard vendors. Nice, not necessary.

Wrist rests matter more on a tented split than on a flat board. Two small rests (one per half) beat one long one. Anything with the right height works, from purpose-made foam or wood rests (CAD 20 to 50 the pair) to a rolled towel while you decide.

Negative tilt. If your desk and chair put the keyboard high, the back edge of each half tilting away from you (the opposite of the flip-out feet on old keyboards, which are ergonomically backwards) keeps wrists straight. Rubber feet under the near edge achieve it.

Hardware mods: the tinkering menu

None of these are needed. All of them are enjoyed.

Swapping switches is the hotswap payoff you paid for in Chapter 2. Curious whether tactiles suit you better than linears? Buy ten of a candidate switch (CAD 8 to 15), put them under one hand's home row for a week, and let your fingers vote before buying sixty. No iron involved.

Films and lube. Switch films are thin plastic shims that tighten a rattly switch housing; lubing means opening each switch and brushing a thin grease onto its sliding parts. Together they are the biggest sound-and-feel upgrade in the hobby, and the honest beginner advice is: not yet. Lubing sixty switches takes an evening or two, ruins switches when overdone, and matters most once you know what you are listening for. File it under "month three, if the itch strikes." Pre-lubed switches exist for a small premium and are the shortcut.

Sound dampening is cheap and immediate by contrast. A thin sheet of craft foam or shelf liner cut to fit between the PCB and whatever sits below it softens the hollow tap of an open-bottom board. The "tape mod" (a layer or two of painter's tape across the back of the PCB) deepens the sound for pennies. Both are reversible in minutes, which makes them perfect first mods.

Cables as jewelry. A coiled, colour-matched TRRS or USB cable transforms the desk's look. Etsy has many small makers, including Canadian ones (search "custom keyboard cable Canada" and check the seller's location to dodge cross-border shipping). Expect CAD 30 to 80 for handmade; a plain but decent cable from amazon.ca costs a fifth of that. Purely cosmetic, entirely legitimate.

The wireless conversion, honestly costed. The Lily58's PCB accepts nice!nano-compatible wireless controllers, so a conversion is possible: two controllers around CAD 80 to 90 the pair, plus two small LiPo batteries and possibly power switches, call it CAD 100 to 120 all-in. You also leave QMK for ZMK, which means relearning the firmware workflow from Chapter 12 in its GitHub-based dialect. Worth it if the cable across your desk genuinely bothers you or you travel with the board; not worth it as an upgrade for its own sake, because nothing about typing improves. The TRRS cable between the halves disappears too, which is the conversion's best argument.

The next builds ladder

Nobody builds one keyboard. Here is the ladder, named as horizons, not homework:

• A Corne (crkbd): the Lily58's smaller sibling, 42 keys, no number row. The classic second build: your soldering skills transfer exactly, and the missing rows force you to actually learn layers. Kits run cheaper than the Lily58 since there is less of everything.
• A Sofle: the Lily58's bigger sibling, with rotary encoders (twistable knobs, lovely for volume and scrolling). Teaches you encoder handling in QMK.
• A case for the Lily58 you already own: 3D printed or laser-cut, tented or not. The gateway between this hobby and the maker world next door.
• A handwired board: no PCB at all, just switches, diode legs, and wire, soldered point to point in whatever shape you dream up. Harder, slower, completely liberating, and the best possible education in the matrix you have been trusting since Chapter 1.
• Designing your own PCB: tools like Ergogen (which generates keyboard designs from a short description) and KiCad (free professional circuit-board design software) mean hobbyists routinely design and order custom PCBs for the cost of a nice dinner. People who started exactly where you are ship boards other people build. No rush.

Caring for it

• Cleaning: keycaps pull off and wash in soapy water (dry fully before refitting). Dust between switches yields to a soft brush or compressed air. A few times a year is plenty.
• Transporting: the halves travel well in a small zippered case or wrapped in a cloth bag each; the TRRS and USB cables coil alongside. Unplug TRRS before packing, and remember the no-hot-plug rule when you set up at the other end.
• The spares drawer: keep the leftovers from the build (spare diodes, sockets, a switch or three, the extra TRRS cable if you bought two) in one labelled bag with the kit's documentation. Two years from now, when a key dies mid-sentence, you will pull a spare switch, swap it in sixty seconds, and feel like a wizard.
• When something breaks: it is Chapter 13 again, forever. The board holds no new mysteries for you.

The skill you actually built

Close the loop on the introduction's promise. The keyboard was the excuse. What you actually acquired: you can make a solder joint and know by sight whether it is good, you can desolder a mistake without collateral damage, you can read a fault from its symptoms and chase it with a multimeter, and you own the tools. That set of skills applies to every gadget with a circuit board in it: the headphones with the crackling jack, the toy with the broken wire, the synth module, the drone. You are now the person who opens things up.

Takeaways

• The two-week dip is real, predictable, and temporary: 15 minutes a day of practice, old keyboard reachable for emergencies only, no keymap edits until your hands settle.
• Customize in single steps and live with each change. Layers, not contortions, are the answer to missing keys. Home-row mods are a month-two experiment, not a day-one requirement.
• Placement is free ergonomics: shoulder-width halves, tenting, wrist support. The expensive mods (lube, films) can wait; the cheap ones (foam, tape, feet) cannot hurt.
• Wireless conversion costs about CAD 100 to 120 and a new firmware ecosystem; do it for the missing cables, not for the typing.
• The next build finds everyone eventually. Corne, Sofle, a printed case, handwiring, your own PCB: pick your horizon when it calls.
• The durable purchase was the skill: solder, diagnose, fix. It outlives this keyboard and every keyboard after it.

👉 Two references remain before the book lets you go: a glossary of every term we taught, in one alphabetical place.

Glossary

Every term this book leaned on, in plain language, grouped by first letter so you can skim. Where a chapter teaches the term properly, the entry points there.

A

Anti-ghosting. A keyboard's ability to report every key you actually press, with no phantom extras, even in combinations. On boards like the Lily58 it comes from giving every switch its own diode (see Chapter 1).

ATmega32u4. The small chip at the heart of the classic Pro Micro controller. Reliable and long-serving, but slower and with far less memory than the RP2040, and its flashing procedure is fussier (see Chapter 12).

B

Bootloader. A tiny factory-installed program on the controller whose only job is to receive new firmware. You wake it with a double-tap of the reset button; on RP2040 boards it shows up on your computer as a USB drive named RPI-RP2.

Bridge (solder). A blob of solder accidentally connecting two pads or pins that should stay separate, causing shorts and phantom keys. Fixed with desoldering wick (see Chapter 8).

C

Choc switch. A low-profile switch format made by Kailh, flatter than the standard MX style, with its own incompatible sockets and keycaps. Some Lily58 PCB variants support Choc; this book builds the MX version (see Chapter 2).

Cold joint. A solder joint where the solder never properly bonded to the pad or pin, usually because the parts were not heated enough. It looks dull, grey, or grainy instead of shiny, and it fails electrically now or later (see Chapter 6).

Columnar stagger. Arranging each finger's keys in a straight vertical column, offset up or down to match that finger's length, instead of the diagonal offsets of a normal keyboard. The Lily58's defining shape, and the reason for the two-week adaptation dip (see Chapter 14).

Continuity. An unbroken electrical path between two points. A multimeter's continuity mode beeps when a path exists, which makes it the referee for "is this joint actually connected" (see Chapter 13).

Controller. The small computer board (Pro Micro, Elite-Pi, Frood, nice!nano) that runs the firmware, scans the matrix, and talks USB. Each half of the Lily58 has one, and this book sockets them so they can be swapped (see Chapter 3 and Chapter 10).

D

Debounce. The short wait (a few milliseconds) the firmware imposes after a key event, to filter out the rapid mechanical flutter of metal contacts closing. Too little debounce and keys chatter, registering twice per press (see Chapter 13).

De minimis. The value threshold below which an imported parcel enters Canada without duty. Relevant when ordering kits and parts from US and overseas shops (see Chapter 4).

Desoldering wick. Braided copper ribbon that soaks up molten solder like a sponge when pressed onto a joint with the iron. The tool for removing bridges and emptying joints (see Chapter 8).

Diode. A one-way valve for electric current. One sits behind every key so the controller can tell exactly which keys are pressed in any combination; soldered backwards, it causes phantom letters (see Chapter 1).

E

EEPROM. A scrap of memory on the controller that survives power-off. QMK uses it to remember settings such as which half of the split is the left one (see Chapter 12).

ESD. Electrostatic discharge: the static-shock zap that can silently damage chips. Handled with basic habits, like touching something grounded before handling the controller (see Chapter 9).

F

Fillet (solder). The smooth cone shape of solder rising from pad to pin on a good joint, like a tiny volcano or a Hershey's Kiss. The shape your eye learns to demand from every joint (see Chapter 6).

Firmware. The program stored on the controller that scans the matrix, applies the keymap, and speaks USB HID to the computer. QMK, Vial-flavoured QMK, and ZMK are the firmwares in this book's world (see Chapter 12).

Flux. A chemical that cleans oxide off metal surfaces at soldering temperature so the solder can bond. Some lives inside the solder wire (rosin core); more comes from a flux pen for rework (see Chapter 6).

FR4. The green (or black, or purple) fiberglass-and-resin material that circuit boards are made of. Sturdy, but not something to pry against carelessly.

G

Ghosting. Phantom keypresses: the computer receiving a key you never pressed, classically when three corners of a matrix rectangle are held and the fourth appears on its own. Per-key diodes eliminate it; a backwards diode reintroduces it (see Chapter 13).

H

HID (USB HID). Human Interface Device, the standard USB language for keyboards and mice. Because the firmware speaks HID, your hand-built board needs no drivers on any operating system (see Chapter 12).

Hotswap socket. A small metal-and-plastic clip soldered to the PCB that grips a switch's pins, so switches push in and pull out by hand with no soldering. You soldered 58 of them per this book; the payoff is swapping switches forever after (see Chapter 10).

K

Key matrix. The grid wiring scheme where switches share row wires and column wires, letting a controller with a couple dozen pins read 58 keys. The firmware scans it many times per second (see Chapter 1).

Keycap profile. The family of shapes and heights a keycap set is sculpted in. Cherry and OEM are sculpted (each row a different shape, like most store keyboards); SA is tall and dramatically sculpted; DSA and XDA are uniform (every key the same flat-topped shape), which suits columnar boards because any cap fits any position (see Chapter 4).

L

Layer. One complete keymap in a stack of them; holding a layer key switches which one is live, the way Shift has always switched letters to capitals. Small keyboards replace missing keys with layers (see Chapter 12).

Leaded / lead-free solder. The two families of solder wire. Leaded (typically 60/40 tin-lead) melts lower and flows more forgivingly; lead-free is what industry now uses and needs a slightly hotter iron. Either builds this keyboard fine; wash your hands after leaded (see Chapter 5).

LiPo. Lithium polymer, the small flat rechargeable battery used in wireless keyboard builds. Needs respectful handling: no punctures, no shorting the leads (see Chapter 2).

M

Master / slave. In a split keyboard, the half with the USB cable (master) talks to the computer and polls the other half (slave) over the TRRS cable. Newer documentation often says central / peripheral for the same roles (see Chapter 12).

Mill-Max. A brand of precision socket pins, used to socket a controller so low that low-profile builds still close. The generic word for the cheaper alternative is machine-pin or round-pin sockets (see Chapter 10).

MX stem. The plus-sign-shaped post on top of a standard mechanical switch that keycaps grip. "MX-compatible" on a keycap or switch means this de facto standard, named for the original Cherry MX switch.

N

N-key rollover. The ability to register any number of simultaneous keypresses correctly. A per-key-diode board running QMK has it naturally.

nice!nano. The most popular wireless Pro Micro-compatible controller: same footprint, plus Bluetooth and battery charging. Runs ZMK, not QMK (see Chapter 2).

O

OLED. The small monochrome screen (an SSD1306 module in the Lily58's case) that can show the current layer, a logo, or whatever the firmware draws. Optional, charming, occasionally blank until you check the jumpers (see Chapter 10 and Chapter 13).

Ortholinear. A key grid with straight columns and straight rows, no stagger at all (the Planck is the famous example). The Lily58 is columnar staggered, not ortholinear: its columns are straight but vertically offset per finger.

P

PBT / ABS. The two common keycap plastics. PBT is matte, textured, and resists developing shine; ABS is smoother, cheaper, and polishes shiny under fingers over months. Both type identically (see Chapter 4).

PCB. Printed circuit board: the fiberglass board with copper traces that carries every component and connects them. The Lily58 kit has one per half (see Chapter 3).

Perfboard. A generic practice circuit board covered in a grid of plated holes. What you solder your first hundred joints into before the real kit (see Chapter 7).

Plate. The rigid sheet (usually FR4 or metal) that switches clip into, sitting above the PCB and holding every switch straight and firm. On hotswap boards the plate is structural, not optional (see Chapter 11).

Pro Micro. The small ATmega32u4 controller board whose size and pin layout became the standard footprint for DIY keyboards. "Pro Micro-compatible" describes any controller with the same footprint, including the RP2040 drop-ins this book prefers (see Chapter 2).

Q

QMK. The open-source firmware that powers most wired custom keyboards, the Lily58 included. Configured rather than written: a keymap is a list of key names (see Chapter 12).

R

Reversible PCB. A circuit board designed so the identical board serves as either the left or the right half, depending on which side you solder the components onto. The Lily58 uses one, which is why "solder on the correct side" gets repeated so much (see Chapter 9).

Rosin core. Solder wire with flux built into its center, so every joint gets cleaned automatically as the solder melts. The only kind of solder wire to buy for electronics (see Chapter 5).

RP2040. The chip from the Raspberry Pi organization that powers modern Pro Micro-compatible controllers like the Elite-Pi and Frood. Fast, roomy, cheap, and flashable by drag and drop, which is why this book recommends it (see Chapter 12).

S

SMD / through-hole. The two ways components attach to a PCB. Through-hole parts have wire legs that pass through holes and are soldered on the far side; SMD (surface-mount device) parts sit flat on pads on one side. Hotswap sockets are SMD but with big friendly pads, which is why beginners manage them (see Chapter 6).

Split keyboard. A keyboard in two independent halves, one per hand, connected by a cable, so each half sits where the hand and shoulder want it (see Chapter 1).

Standoff. A small threaded metal or brass pillar that holds the plate at a fixed height above the PCB, screwed from both sides. The skeleton of the case sandwich (see Chapter 11).

Switch (linear / tactile / clicky). The mechanism under each key. Linear switches move smoothly with no feedback; tactile switches have a small bump you feel at the actuation point; clicky switches add an audible click to the bump. Feel is personal; hotswap lets you change your mind (see Chapter 1).

T

Tenting. Tilting each half of a split keyboard so the thumb side rises, rotating your wrists toward a natural handshake angle. Done with feet, wedges, printed legs, or commercial kits (see Chapter 14).

Tinning. Coating a surface with a thin layer of solder before making the real joint: you tin the iron's tip to keep it healthy, and you tin wires so they solder cleanly (see Chapter 6).

TRRS / TRS. Types of 3.5 mm audio-style plug, named for their contact segments: Tip, Ring, Ring, Sleeve. TRRS has four contacts (three separator rings) and is what connects the Lily58's halves; TRS has three contacts, looks nearly identical, and cannot carry the data line, which makes it a classic troubleshooting trap (see Chapter 13).

U

.uf2. The firmware file format RP2040 bootloaders accept. Flashing is dragging the .uf2 onto the RPI-RP2 drive; no tools required (see Chapter 12).

V

VIA. A graphical app (usevia.app) for remapping compatible QMK-based keyboards live, without reflashing. A separate ecosystem from Vial with the same goal (see Chapter 12).

Vial. A fork of QMK plus a browser app (vial.rocks) that remaps a Vial-enabled keyboard live. The beginner-friendliest way to own a wired custom board once the initial firmware is on (see Chapter 12).

W

Wetting. What molten solder does when it bonds properly: it flows out thin and hugs the metal, like water on clean glass, instead of beading up like water on a waxed car. Good wetting is the physical definition of a good joint (see Chapter 6).

Z

ZMK. The open-source firmware for wireless keyboards (nice!nano builds). Configured through a GitHub repository and compiled by GitHub's servers; a different world from QMK, covered here only as a signpost (see Chapter 12).

👉 Last stop: vendors, communities, and further reading, the curated list of everywhere this book has been pointing.

Vendors, communities, and further reading

Everything this book has pointed at, gathered in one annotated list. One caution before the links: URLs rot. Shops close, projects move, domains lapse. If a link here is dead, search the project or shop name; the community usually knows where it went.

The Lily58 itself

• Official Lily58 repository (github.com/kata0510/Lily58): the original design files, schematic, and the official build guide. The schematic PDF here is what Chapter 13 means by "the kit's schematic."
• Your kit vendor's build guide: whichever shop sold you the kit almost certainly publishes its own guide for its exact PCB revision. Read it alongside this book; where they disagree on a detail, the vendor knows their board.

Firmware

• QMK documentation (docs.qmk.fm): the reference for everything firmware. The "Newbs" guide and the pages on debounce, handedness, and the OLED driver are the ones this book leaned on.
• QMK Configurator (config.qmk.fm): the browser-based firmware builder from Chapter 12. No installation, no toolchain.
• QMK Toolbox (search "QMK Toolbox" on GitHub, under the qmk organization): the flashing helper for ATmega32u4 boards.
• Vial (get.vial.today): the live-remapping fork of QMK, its browser app, and its list of supported keyboards and prebuilt firmware.
• VIA (usevia.app): the other live-remapping app, for VIA-enabled firmware.
• ZMK documentation (zmk.dev): the wireless firmware. Only needed if you took or later take the nice!nano route.
• Typeractive documentation (typeractive.xyz, docs section): the clearest beginner-facing ZMK walkthroughs, written for their Corne kits but useful for any ZMK build.

Keyboard kit shops (ship to Canada)

• Boardsource (boardsource.xyz): US shop with Lily58 kits and their own controllers; clear product pages that state exactly what is included.
• Little Keyboards (littlekeyboards.com): US shop specializing in split kits, with good per-kit build notes.
• Keebio (keeb.io): US shop, long-running, known for split boards and reliable stock of parts like TRRS jacks and controllers.
• Custom KBD (customkbd.com): Australian shop with a wide split-kit catalogue; shipping to Canada is slower but the selection is deep.

Canadian shops

Ordering domestically dodges customs entirely, per Chapter 4.

• Clickety Split (clicketysplit.ca): Canadian and split-keyboard focused, the closest thing to a home-team shop for this exact book.
• Deskhero (deskhero.ca): Canadian storefront for switches, keycaps, and accessories.
• Apex Keyboards (apexkeyboards.ca): Canadian shop for switches, keycaps, and group buys.
• Ashkeebs (ashkeebs.com): Canadian shop carrying kits, switches, and parts, including split-board stock.

Tools, electronics, and parts

• Digi-Key Canada (digikey.ca): the giant electronics distributor; bills in CAD and clears customs for you. The place for diodes, sockets, and TRRS jacks by the exact part number.
• Mouser Canada (mouser.ca): the other giant distributor, same idea; whichever has stock wins.
• Lee's Electronics (Vancouver, leeselectronic.com): a real walk-in electronics shop; handy for solder, wick, and flux without shipping delays if you are local.
• Creatron (Toronto, creatroninc.com): Toronto's equivalent, with hobbyist boards and soldering supplies.
• amazon.ca: the tool bench from Chapter 5; irons, multimeters, safety glasses, and consumables with fast domestic shipping.
• AliExpress (aliexpress.com): the cheapest source for switches, keycaps, controllers, and even whole Lily58 kits, at the price of two-to-four-week shipping and variable quality control. Read reviews, order early.
• Etsy (etsy.ca): small makers for custom cables, cases, and wrist rests; filter by seller location to find Canadian makers and skip cross-border shipping.

Communities

• r/ErgoMechKeyboards: the split and ergonomic keyboard subreddit; the best single place to ask a Lily58 question with photos.
• r/olkb: the DIY and QMK-adjacent build subreddit; strong on firmware and matrix debugging.
• r/MechanicalKeyboards: the big general subreddit; more showcase than support, but the wiki and buying guides are useful.
• r/mkcanada: Canadian mechanical keyboard community; domestic buy/sell/trade and up-to-date chatter on which Canadian vendors have stock.
• keebtalk (keebtalk.com): a slower-paced forum with long-form build logs and deep switch discussion.
• Your kit vendor's Discord: linked from the vendor's site; the people most likely to recognize your exact PCB revision's quirks.

Learning to solder (beyond this book)

• Adafruit's Guide to Excellent Soldering (learn.adafruit.com, search the title): the classic illustrated joint-quality reference; their good-versus-bad joint photo gallery pairs perfectly with Chapter 6.
• EEVblog soldering tutorials (YouTube, search "EEVblog soldering tutorial"): a three-part video series by a veteran electronics engineer; watching solder flow in video fills the gap no book can.
• blog.splitkb.com: splitkb's learning articles on split keyboards, soldering, sockets, and layouts. Written for their own kits but excellent for any split build, the Lily58 included.

Testing and practice

• Browser keyboard testers: search "keyboard tester" for several free sites that light up each key as it registers; any of them serves the tweezer test in Chapter 12. Vial's app also includes a matrix tester that shows raw key positions, which is even better for split-board debugging.
• monkeytype.com: clean, configurable typing practice; the daily driver for the two-week dip in Chapter 14.
• keybr.com: adaptive typing lessons that target your weakest letters; the more methodical retraining tool.

Further down the rabbit hole

• QMK source repository (github.com/qmk/qmk_firmware): where the Lily58's default keymap actually lives, when you want to read one.
• Ergogen (ergogen.xyz): describes a keyboard in a short text file and generates the design; the modern entry into making your own board.
• KiCad (kicad.org): free, professional circuit-board design software, for the day the ladder in Chapter 14 reaches "design your own PCB."