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.