I Built My Dream Keyboard from Absolute Scratch

I'm an iOS developer who types all day, so I've owned a lot of keyboards in search of the perfect one. Yeah, I should probably get rid of some of these. A few

one. Yeah, I should probably get rid of some of these. A few

years in my programming career, I started getting really bad wrist pain, and split keyboards were a real revelation for me since they let you rest your wrist in a more comfortable position that really eliminated the wrist pain. And as a bonus, they give you a really nice place to sit your coffee or have a cat sit. But I've never loved any of the keyboards I've used. I've

cat sit. But I've never loved any of the keyboards I've used. I've

just never really meshed with how they're set up. And many of them have a cool techie look with exposed wires and controllers, but I wanted a simpler, sleeker look, almost as if Apple themselves built a split keyboard.

But I was scared. Is it even possible to build your own keyboard? It turns out in 2024,

keyboard? It turns out in 2024, it's not actually that hard. The first step is figuring out what you want in a keyboard.

If you're interested in the idea of a custom keyboard, it's probably because your existing keyboard has some issues. Try to identify those issues and how you'd want to address them.

For me, I have five goals that once reached, I think will make the perfect keyboard.

First, having something split is key for the three C's.

Coffee cats comfort.

Comfort is a big one. Typing all day can really catch up to you if you don't do it in an ergonomic way. Next, I want my keys ortholinear and column staggered.

way. Next, I want my keys ortholinear and column staggered.

Now what the heck is that?

So back when typewriters were a thing, they had these metal levers connecting each key to the brains of the typewriter. To allow the levers to reach each key without actually running into each other, they offset each row, which kind of made the layout diagonal. In the 2020s, we don't have

diagonal. In the 2020s, we don't have the same limitation, and it's easier for fingers to travel up and down than from side to side, so we can move the keys into a grid, which we call an ortholinear layout. But we can even go one step

layout. But we can even go one step further, and use all of the length of where our fingers rest, which is called column staggered.

I also want a balance between including all the keys I use, while also being a comfy size so I don't have to move my hands around a lot. Some ergonomic

keyboards accomplish this by putting the numbers and arrow keys on a second layer, like how the @ symbol and dollar sign are behind shift on a normal keyboard, but that's a bit much for me. I want

those keys readily accessible.

Next, for me it's gotta be wireless. I like a clean desk setup, and dealing with a bunch of wires running everywhere is no fun. And lastly, and maybe most important of all, is that I want a layout that feels at home with my MacBook.

I use my MacBook a lot, and having a keyboard layout that makes swapping between the two easy enough is ideal. For instance, a lot of keyboards have these really

is ideal. For instance, a lot of keyboards have these really cool thumb clusters, but when I switch to my MacBook, that's no longer there and it feels a bit disorienting, so I want a layout that kind of adapts to both. You immediately encounter an issue though. Typical

keyboards like a MacBook's have a lot more keys on the right side than the left, so when split, you kinda get a lopsided, extra wide layout. I want something smaller, since it means less hand

layout. I want something smaller, since it means less hand movement when you're actually typing. So, this is what I arrived at. It fits all my layout requirements in a sleek, comfy size. It does mean relocating a few keys to a secondary layer. If I hold down where the right command key normally is, I get my second layer with parentheses and square brackets. Right on the home row, actually, which is really handy for programming.

And to retain muscle memory, on the MacBooks, thanks to software called Karabiner, I moved and disabled some keys.

[Bill Wurtzian] And now we have keyboard continuity.

So, we have our layout, but how do we want the whole thing to look? Well, let's look at what we have to work

look? Well, let's look at what we have to work with. There's really only three simple parts that make up a

with. There's really only three simple parts that make up a keyboard. First, we have the controller. This is

keyboard. First, we have the controller. This is

the brains of the keyboard and knows about key presses and communicates it to our computer. I'll get some more into that in the next sections. But for now, we're using the nice!nano,

a cute controller that can work over Bluetooth. Next, we have the PCB. This seems really complex,

Bluetooth. Next, we have the PCB. This seems really complex, but it's basically just a hunk of plastic and copper with paths for electricity to flow through. So, you can communicate things like a key being pressed to our controller. It's so simple that you could just put literal

our controller. It's so simple that you could just put literal wires everywhere instead and make a hand-wired keyboard. But ultimately, the PCB makes things a bit easier and

keyboard. But ultimately, the PCB makes things a bit easier and neater. Then, you pop the last part, which is

neater. Then, you pop the last part, which is key switches, into your PCB, and it kind of dictates the layout of your board. Key switches are what you smush, which makes metal touch metal and indicates a key press through its bottom pins.

There are all sorts of different kinds for you to choose from, with different sounds and feels. I like quiet, low-profile ones, because they keep the keyboard thinner, which I find more comfortable to type on. The next two are optional. Keycaps go on your switch to make it more

are optional. Keycaps go on your switch to make it more comfortable to type on, but technically you don't need them. And an optional case can go around the electronics to make it a bit more durable and give it a more finished look overall. And, since we're doing a wireless split keyboard, we have to double everything. A left half and a right half, all with its

double everything. A left half and a right half, all with its own separate components. In our case, to achieve wireless functionality, the right half talks to the left half, and the left half does double duty communicating those as well as its own key presses, and it's the only side that actually talks to the computer. Okay, so far so good, but the main issue we encounter here is a

self-imposed one. I don't want to see the controller or any

self-imposed one. I don't want to see the controller or any exposed cables or any of that. But they have to go somewhere, so what do we do? I was looking at other keyboards I bought, when I saw one that just put it underneath the keyboard. Okay, that's perfect. We'll

just have to be a bit careful positioning it, so we can make sure that the pins aren't going through another component on the other side. And lastly, since I mentioned I wanted mine wireless, we

side. And lastly, since I mentioned I wanted mine wireless, we need somewhere for a battery, obviously.

And on each half too, since both halves are wireless. I figured

if we nuzzle it below the controller, we can create an elevated look that kind of harkens back to the original MacBook Air's thin wedge design. And as a bonus, it creates a small tenting angle that makes typing even more comfortable. Okay, so we have everything planned out in theory,

comfortable. Okay, so we have everything planned out in theory, but how do we bring it to life?

Step one, and in my opinion the coolest part of this whole thing, is a little piece of free software called Ergogen. It basically lets you type a little text file

called Ergogen. It basically lets you type a little text file to define what you want your layout to be, which you then get manufactured into a PCB. In the interest of keeping this video digestible, I'm just gonna give you a high level overview of how Ergogen works. But FlatFootFox,

Ben Vallack, and the Ergogen Discord are amazing learning resources that got me started. But let me know if you want me to make a long-form video guide myself. Also, don't worry, you do not need to be a

guide myself. Also, don't worry, you do not need to be a programmer for this. It might look a bit weird at first, but we're just describing the keyboard in text.

We start by going to ergogen.cache.works, and it begins by giving us a sample

ergogen.cache.works, and it begins by giving us a sample keyboard. It looks scary, but it's

keyboard. It looks scary, but it's just describing parts of the keyboard, and we can change those values in real time to change the keyboard. Let's do this to simplify the keyboard a bit. By

keyboard. Let's do this to simplify the keyboard a bit. By

removing the mirrored right side, removing the thumb cluster, removing any rotations, simplifying some formatting, and now we have a pretty simple keyboard to serve as our basis. I'm gonna modify it a bit for my tastes. Maybe add an extra outer

my tastes. Maybe add an extra outer column for the shift keys and whatnot, plus a number row, and a modifier row for stuff like the command key or Windows key. Maybe I'll just increase the stagger on the middle column a bit, since I like how that looks. We'll also mention here that it's called Ergogen, but you're not limited to normal ergo-style keyboards. You could create a more traditional keyboard layout too, and I'll paste one

quickly to show you that. I'll undo that though, since I kind of like the keyboard we had. Since

we're using Ergogen to create our PCB, we also want to define the shape or outline of our PCB, which is simple to do. We're just telling Ergogen to draw a rectangle everywhere a key is, and for the size, Ergogen has built-in variables called cx and cy for the width and height of the Choc key switches we'll be using. And we'll add two millimeters to the width and height of each key

to give the PCB a bit of breathing room. And then if you tap preview over here, we can see the layout.

Oh, and let's add a quick two millimeter fillet, which kind of rounds the edges nicely. Now we have a layout. The next part, and this can get a tiny bit confusing,

layout. The next part, and this can get a tiny bit confusing, is just to figure out how to communicate this layout to the controller, AKA the brains of the keyboard. So the way a controller

the keyboard. So the way a controller works is it has these little holes that you can send electricity to. So for instance, we could

electricity to. So for instance, we could hook up the A key switch to one of these holes, and the controller would know that whenever this hole gets electricity, the user wants to type the letter A.

Simple. Small problem though, even if we split the keyboard in half, which we're doing, each half would have more than 24 keys, so we'd run out of holes. The answer is simple in essence, but can be a tiny

of holes. The answer is simple in essence, but can be a tiny bit confusing the first time you hear it.

Ever play chess? Okay, I haven't really either, but you know the board and how it's like a grid? "Knight to E4" and all that stuff? Just like you describe

a grid? "Knight to E4" and all that stuff? Just like you describe the location of a chess piece, we're going to use a grid to describe each key's location. So

instead of wiring up each key individually, we wire up each side-to-side row and each top-to-bottom column, and then connect each of those to the controller. Then the controller will know if hole one and two have been signaled? Oh, that's this row and this column, which would

been signaled? Oh, that's this row and this column, which would be this key. For our keyboard, that only requires five rows and six columns, or a total of eleven holes, so we're golden. Now we

just have to tell Ergogen about these wiring plans. To do this, we define a PCB section in Ergogen. We want to tell it about its shape that we defined

Ergogen. We want to tell it about its shape that we defined previously, and then we want to also define what are called footprints. Remember, the whole goal of designing a PCB is to define electrical paths, so different components like the controller, key switches, battery, and whatnot are all able to talk to each other, and the footprints are just those components. When we tell Ergogen

those components. When we tell Ergogen about these components, Ergogen can do its magic and define a PCB with these electrical paths all set up for us. Here, I'll define two quick footprints to give you an idea. First, we'll define the key switch one. We'll say put a switch everywhere our key is. We

switch one. We'll say put a switch everywhere our key is. We

have to say what kind of footprint it is. We can either use built-in ones or community-made ones. Choc

is. We can either use built-in ones or community-made ones. Choc

key switches are built-in Ergogen, so we'll just say it's a Choc key switch. For the parameters, we'll say it's hot-swappable, so we can change it to a different key switch later on if we change our mind. And then we have a from and to field, which is a bit confusing, but basically just helps Ergogen to set up the key grid. Then, we want to define the footprint for our microcontroller.

key grid. Then, we want to define the footprint for our microcontroller.

Ergogen has a built-in footprint for the Pro Micro, which is used with wired keyboards, and it's close enough that we could just use that, but the pins are named different on our wireless nice!nano, so to keep

wireless nice!nano, so to keep that consistent, I use a community-made nice!nano footprint

available in the description.

For parameters, normally you orient your controller facing down so all the chips on it are protected, but since we're putting the controller on the back of the board, we actually have to flip the orientation to up. Then, we just need to specify where on the PCB we want the controller to be, which is important for us since we're putting it near other components, and we want to make sure that the holes on it don't go where

something else already is, and I found these coordinates worked well for that. So, if we're looking at the number row and inner column, we want the controller positioned 9mm under and 2mm to the left of that key. Now, we'll define which hole on our microcontroller we want each column and row to go to, like we talked about in the previous section. Take a

quick look at this nice!nano pin

diagram. You can see most holes, aka pins, are available for us to use, and are identified starting with a P for pin, then a number. When pairing our rows and columns to each of these pins, we can really choose whichever we want, as you can always change this around later if in the next step your choice has made the connections too spaghetti-like.

This web UI is super cool, but since the nice!nano footprint is a community-made one, we need to

the nice!nano footprint is a community-made one, we need to quickly install Ergogen locally on our computer to actually use that footprint. This is also pretty easy thankfully, and just starts with installing Node.js. Just install it from the Node.js website, and after that we just open our terminal or command prompt, and install Ergogen with "npm i -g ergogen".

With it installed, we want to create a folder somewhere on our computer with the name of our keyboard, and then create a new file using a text editor like Visual Studio Code, and paste in the same text we were using on the website. Then just save it as "config.yaml". Then, we create

website. Then just save it as "config.yaml". Then, we create another folder within that called "footprints", and drop in the community-made footprints we're using in there. Open the terminal to that folder by holding command

in there. Open the terminal to that folder by holding command as we drag it on a Mac, and then just type "ergogen ." to run Ergogen on the current folder. With that, we have the output file

folder. With that, we have the output file for our PCB, and we've covered the basics of Ergogen. Confession

time though, I sort of lied when I said Ergogen creates the electrical paths for you. It

does create a PCB in this beautiful free software called KiCad, and it tells KiCad what connections need to happen, but it doesn't quite do it for you. This is called a schematic.

It's actually a lot of fun, like one of those Connect the Dots games as a kid. You can see at the bottom how many connections you have left to make, and you breeze through them by clicking on one of the components, and connecting it to where KiCad says it needs to go to. We repeat this for all the parts in KiCad, from the key switches, to the battery connectors, to the on/off

switch, until KiCad says there's no parts left. Bam, now we have a wired up PCB, ready to be

parts left. Bam, now we have a wired up PCB, ready to be manufactured. Do the same thing for the right

manufactured. Do the same thing for the right half of your keyboard too, then export them from KiCad by choosing Plot, Generate the .gerber Drill Files to get made into the PCB, and then hit Plot. Then, compress our folder into a .zip file, and I'm going to upload it to a PCB manufacturer. For JLCPCB,

not sponsored by the way, just click Order, add your zip file for each half, choose "Lead Free", and then displace your order.

One funny note is that most PCB sites do a minimum order size of five, and you typically do a separate PCB for the left and right side, which means you'll get a comical ten PCBs in total. PCBs are cheap though, and most of the cost is in the actual shipping, so it's just a few extra boards to practice your soldering on. We don't NEED a case technically, but while waiting that week for the PCBs to

arrive, we can design a case to make our end result just a bit nicer. Fusion 360 is my tool of choice for this normally, because it's easy to get up and running, there's a ton of tutorials out there, and it's free for hobbyists like us. And instead of starting from absolute scratch, we'll

like us. And instead of starting from absolute scratch, we'll use Ergogen to create the complex 3D part with all the holes that the keys pop into. In addition

to our previous outline for the PCB, we need one for the keys, and for the Choc key switches, each cutout is 14mm by 14mm, then we subtract that from the other outline to get a new outline with a bunch of holes in it. Then we just create a new "cases" section that will use that outline, and extrude it, which is just saying give it a thickness of 1.2mm, which is a good thickness for a case. Then

we just copy it locally, run Ergogen again, and we have a… JSCAD file? Okay, well we want an STL file, so open the link in the description, drag and drop the file, and convert it into an STL file. We then take that and import

file. We then take that and import it into Fusion 360 and design our case around it. There's a lot of busy work to make the STL file work nicely in Fusion, but then we just build up the walls around it and you get most of the bases done. I spent some extra

done. I spent some extra time refining it by adding screw holes, a base plate, and making it into a wedge shape, and this is kind of what I ended up with in the end. Now we can take that part and 3D print it.

3D printers are pretty cheap nowadays to be honest, but if you don't have one, there's normally local businesses or libraries that will print things for a small fee, or you can have services like PCBWay 3D print it for you. Wow. Oh, great timing, our PCBs just arrived too.

That means… Uh oh. The next step requires the dreaded soldering. I remember

Uh oh. The next step requires the dreaded soldering. I remember

seeing my first keyboard guide and the person brought out a soldering iron and I just immediately noped out at how complex it felt, but I promise you, it's actually pretty easy. It looks fancy, but you're basically just using a metal version of a hot glue gun to stick parts together, with the added bonus that it lets electricity flow between the parts. And this is a great first soldering project. One catch though,

soldering project. One catch though, melted solder is a pretty terrible material to inhale, so let's be smart and take some safety precautions. First, solder with lead in it is easier to work

precautions. First, solder with lead in it is easier to work with, but I'd recommend lead-free solder. I've never

had any issue working with it, and there's no toxic lead. There

are still fumes though, especially from the flux normally present in solder, which helps the solder flow easier, so ensure you have proper ventilation. I solder by a window and have this cute little vacuum that sucks up fumes through a carbon filter and then a HEPA filter.

But if it's warmer out, you can always just solder outside with a fan pointing at your device. Outside

of that soldering iron, which is just a cheap $20 USB-C Pinecil, some other helpful but not totally necessary accessories I love are a 3D printed stand for it, some steel wool to clean the tip, 0.6mm solder, tweezers, flux sometimes to help the solder flow, a solder-sucker for mistakes, and a little mat to catch some drips.

Oh, and my little vacuum. For the components that we're actually soldering, there's a few, but they're easy to get. We have these hot-swap sockets, which means that if we ever want a different kind of key switch, like a clicky one, we can just pop out our existing ones and pop in new ones like LEGO, versus soldering it directly to the board and then we'd be stuck with it forever.

Then we have diodes, which are kinda complex, but all you need to know is that diodes help the PCB to not get confused if you hit multiple keys at once, like Command-Shift-Z, for instance.

We also have hot-swap sockets for our controller, so we can pop it out easily if we want to use it on a different board, or if heaven forbid it dies or something.

We also have a reset switch for the keyboard, an on/off switch for the battery, and a battery plug. We could solder the battery directly to the board, but this continues our goal of easy repairability and swappability.

Oh, and I get all these components from Typeractive. Not

sponsored, but they're really great folks. Links to all parts are in the description.

As for the battery, I found a PS3 controller replacement battery is actually perfect, as it's readily available, cheap, 3.7 volts, the dimensions are ideal and should last our keyboard for over a year. This is a big ass battery too versus one of my other keyboards, at 1,800 versus 100 mAh. And, its 2mm connector is compatible with the common 2mm JST type that keyboards use. Thank you, Sony engineer from 2004.

We'll start by carefully taking the diodes out of their package, and since they're tiny, we'll solder them by putting down a dab of solder, and then heating their leg and pressing them in.

Then we can just solder the other side normally and repeat until we finish the whole board.

Wait, quick cookie break.

Okay, now let's solder in the hot-swap sockets for the key switches Then, we'll solder the controller sockets. I trim these first so they don't interfere with the other side of the board. And then, with a bit of flux, which helps the solder flow when you're in tight quarters, I drop them in and solder them from the back instead of the other side, again so there's nothing on that side that would interfere with

the keys. Don't worry, this is plenty strong. Then, we drop in

the keys. Don't worry, this is plenty strong. Then, we drop in the mill-max pins that connect the controller to the hot-swap sockets. Be careful here though, they can really go flying. And be sure to press them in until they click. And

go flying. And be sure to press them in until they click. And

then we solder them all.

Then just finish up with the reset switch, battery slider, and battery plug. Then we just need to do

battery plug. Then we just need to do the same for the other side. Oh, it's done? With that, the soldering is done, and there's just one final step we have to do on our computer. As I put the case together, I wanted to mention that if you've made it this far into the video, something tells me that you kind of enjoyed it. So only if you think I've earned it, maybe consider subscribing so I can

make more fun videos like this.

The final piece of the puzzle is just firmware, which just allows a device like a keyboard to talk to modern devices like our computers.

If you're doing a wired keyboard, QMK is the de facto choice, but for wireless ones like we're doing, ZMK is our go-to.

In ZMK, the firmware is actually called a shield. I can only assume because it sounds cool.

ZMK is awesome because we can even give our keyboard multiple device profiles, which just means we can hit a key combo to switch to a different device altogether, which can be really handy.

Setting it up isn't too bad at all, but on Windows, you'll need to first install Git, G-I-T, since it's only pre-installed on macOS and Linux.

We'll start by ensuring we have a GitHub account. It's free and what ZMK uses to actually build the firmware you put on your keyboard.

We'll create a new repository in GitHub by going to github.com/new.

And for the name, it's normally just whatever cool name you want to give your keyboard, with "zmk-config-" at the beginning.

And you can leave everything else as the defaults.

Then we'll open our terminal. You can do this on a Mac by opening Spotlight with Command + Space, or by typing Terminal. On Windows, you should be able to search for Command Prompt.

And if you use Linux, I'm sure you know how to open a terminal.

And then we just paste a bash command from the ZMK documentation.

Then we want to choose a keyboard template. This isn't super important, but let's choose Corne, since that's a popular split keyboard.

For our board, we're using a nice!nano V2, so I'll select that.

We'll say yes to taking the stock keymap, and a keymap is just us telling ZMK how we want our keys laid out on the keyboard.

So like, do we want the top left key to be a Tab key, a Q key, a Caps Lock key, that kind of thing.

Then it'll ask for our GitHub username, then the repo name, dash config dash whatever you named your keyboard. which is zmk We'll hit enter to confirm the GitHub repo, and then confirm that we want to continue.

Now ZMK has created a folder for us. We want to take the two Corne files and rename them to what we're naming our keyboard.

Then we'll move the board folder into the "config" folder, and move the two files we just renamed into "boards", and then "shields".

At this stage, we really just need to create some files that the ZMK documentation lists, depending on if your keyboard is split or not.

And then just copy paste into these files from the documentation, changing some things for a specific keyboard.

The standouts are the .dtsi file, where we're just telling ZMK we have two split keyboards that are six columns by five rows.

And then we tell it which pins on the controller we're using for our rows.

Let's take a quick aside for the pinout.

The nice!nano we used is a fancy Bluetooth version of an older Pro Micro controller.

The nice!nano and Pro Micro label their pins a bit differently, even though they're in the same places.

ZMK wants the Pro Micro labels.

So back in the Ergogen step, if you used a nice!nano footprint

like I did, you just have to translate them from nice!nano to

Pro Micro.

You can pause the video here and write them down if it helps.

For instance, you'd want to change "106" to "9".

Okay, now that we've filled all the column pins in, we just have to do the same for the rows.

For split keyboards, that's in the left and right .overlay

files, and the right should just be a reverse of the left.

The other standout file is the dot keymap file we mentioned earlier, where we can define what key goes where, as well as any extra layers we want to add.

For me, I like typing in Colemak, so I'll define a Colemak layout here, but you can obviously do QWERTY as well.

"kp" just means "key press", which we use for keys, and "mo" is "momentary layer", so it just activates a layer as long as we hold down that key, like Shift.

I want a layer for parentheses and brackets, like we talked about, which I'll define below, as well as some keys to switch between Bluetooth devices.

Also, you don't have to define the layout visually above as well, it's just kind of nice to do that so you can visualize it at a glance.

Filling in the rest of the files per the documentation is pretty easy, and then we're done!

We'll use Git to push all our stuff up to GitHub, by going to our folder in Terminal, and adding our changes by typing "git add -A".

And then we want to commit these changes with a message about what we changed, with "git commit -m", and finally push the changes up to GitHub with "git push".

If we go to the GitHub repository we created earlier, and click on "Actions", we can see the firmware being built in real time.

In a few minutes it should be done, and we can click to download it.

Then, just unzip it, and we'll get a file for the left and right side.

Ensure both halves of the keyboard are turned off, and then we'll flash these files onto our left and right sides one at a time.

Take the left side, and double-tap the reset button, and it'll mount to our computer like a flash drive.

Then we just drag and drop the left file.

It'll auto-eject once complete, then do the exact same thing for the right side.

Then we turn both keyboards on, and tap the reset button on both keyboards at the same time.

Now it's done!

We just have to connect it to our device over Bluetooth, and we're off to the races.

Your OS should be able to show you the current battery percentage and you'll have to charge the left half more than the right since it does double-time on the communication, but it'll be pretty infrequent that you'll need to charge a battery this size.

And with that, we have our own really sleek, fully-custom keyboard, built perfectly to our needs.

I'm calling it the "Caldera", because I've just always liked that word.

It's comfortable, portable, lasts ages, and fits in well with just about any desk setup.

I'm so happy with how this came out, and the process of building it was a ton of fun.

Using something you built from effectively scratch is such a cool feeling.

Typing also sounds really great after I lubricated the switches.

Take a listen.

I've also made all the parts for this keyboard fully available for free in the description below.

From the 3D printable case files, to the PCB design, to the Ergogen code, and it'd be super cool to know if you used them.

Or if you have any questions, feel free to leave them below, I'll try my best to answer all of them.

And I can already think of a bunch of things I'd want to improve with a version 2.

If you made it all the way to the end, again, something tells me that you kinda liked it.

So, honestly, again, only if I've earned it maybe subscribe, as I'd love to make some more videos on some other fun ideas I have.