# Cheapino: a 36 key split keyboard built to be cheap > Cheapino is an open hardware split keyboard with 36 keys, a reversible PCB, and a design goal that is stated in one line: probably one of the cheapest split keyboards you can build. The interesting engineering is the matrix, which is wired in a Japanese duplex arrangement so that one microcontroller is enough, and the documentation, which is a build manual rather than a marketing page. **tompi/cheapino** — An affordable split 36 keys keyboard - Repository: https://github.com/tompi/cheapino - Stars: 1,191 · Forks: 51 - Language: OpenSCAD - License: CC-BY-4.0 - Published: 2026-10-19 · Updated: 2026-10-19 · Language: en - Canonical page: https://hysenlabs.com/projects/tompi-cheapino ## A split keyboard with 36 keys and a price target Cheapino is described in one sentence as probably one of the cheapest split keyboards you can build, and the origin story is given just as plainly. It is the result of really enjoying building keyboards, but not wanting to spend that much money on it. That framing sets the expectations for the rest of the project. This is not a commercial keyboard with an open licence attached, it is a design that was pushed until the expensive parts were gone. The layout is a split board with 36 keys, which is a deliberately small number. 36 keys in total is a deliberately small number, and the cost saving begins with the key count, because every switch, socket and diode is one fewer part to buy. The case and plate designs are in the repository, and the primary language of the project is listed as OpenSCAD, which tells you where the parametric parts live. The case/ and plates/ directories are the printable side of the project, and project_libraries/ holds library files for the design tools. The releases are v1.0 from 2023-04-14 and v2.0 from 2024-03-23, and the last push to the repository was on 2026-09-25, so the design has been iterated on since the second version. ## One microcontroller, and why the matrix matters The electrical design is where the money was saved, and the README describes it in one sentence. The PCB is reversible, connected using RJ45, and utilizes a Japanese duplex matrix, so only one MCU is needed. A split keyboard normally has two halves, and each half normally has its own microcontroller, with a link between them. The matrix arrangement is what removes one of those. A Japanese duplex matrix wires the two halves' switches into a single matrix rather than treating them as two independent devices, so a single RP2040-Zero can read both sides. That is a saving of one microcontroller, one USB port and one piece of firmware plumbing, and it is the difference between a project that costs a certain amount and one that costs noticeably less. Reversible is the other cost lever, and it is a bigger one than it sounds. A one-sided board needs to be manufactured one way, and a reversible board can be used whichever way up it is fitted, which means the same board works for left and right hands, and a manufacturing error cannot be a dead board. For a one-off build that is mostly about not wasting a handful of boards, and for a small production run it removes a constraint on the panel design. RJ45 is an unusual choice for a keyboard and a good one. The cable is cheap, it is a known connector, and the two halves of a split keyboard are usually a few centimetres apart on a desk, so a short network cable is both sturdy and easy to source. ## Hotswap is the upgrade you can skip The README is explicit about where the money goes. For hotswap, a case is recommended, and the pictured case is shown. But soldering the switches is of course the cheapest option. That is a small sentence that changes the project. A hotswap build needs a socket for every switch, and a hotswap PCB is more expensive than one that takes soldered switches, and the sockets themselves cost money per switch across 36 of them. Soldered switches mean a plate that is simpler, a case that is simpler, and a build that can be repaired with a soldering iron rather than a switch puller. The case is therefore the place where the price difference lives, and the plates_and_cases document exists to collect what the author knows about the options. There is a separate plates/ directory in the repository and a document about the plate and case solutions, which is the sort of page a small hardware project gets when the author starts hearing the same question from every builder. The trade is that a soldered build is harder to change. Hotswap exists so you can swap a switch without desoldering, and for a first build where you do not yet know whether you like a 36 key layout, that is worth something. For a builder who has built a keyboard before and knows what they want, the cheaper path is the right one. ## The documentation is the project Cheapino is mostly a set of documents, and the README is a table of contents for them. The ordering guide is doc/orderingguide.md, and it is what the README points to first for anyone asking whether they want one. It covers what you need and how to buy it, which is the single most useful page in any open hardware project, because the difference between a good design and an unbuildable one is usually the parts list. The build guide v2, doc/buildguide_v2.md, has more details and pictures of how to actually build it, and the fact that it is versioned separately from the design tells you that the board and the instructions moved together. Then there is doc/troubleshooting.md for when your Cheapino does not work, doc/firmware.md for how to build and customize keyboard firmware, doc/plates_and_cases.md for the printable parts, doc/tips.md for the author's own tricks, and doc/gallery.md for build pictures, which is the document a lot of visitors will land on. The troubleshooting guide is the one that tells you about the project's maturity. A project with a maintained troubleshooting document has been through enough failed builds to know what goes wrong, and that knowledge is exactly what a design document is supposed to carry. ## Firmware: Vial out of the box, QMK for everything else The firmware story is short and gives you a choice. The Cheapino has Vial support, or you can build your own QMK to customize everything. And even the onboard RP2040-Zero LED is controllable by QMK. That last clause is the interesting one, because it is the kind of detail that separates a design someone iterated on from a design someone published once. The RP2040-Zero is the microcontroller board, and it carries a status LED that is normally outside the firmware's control. Making it addressable means the keyboard can show state, change layer indication, or do something as small as confirming a keypress, and it means the LED does not sit there being wrong. QMK is the open source firmware for keyboards, and the choice between the two routes is about how much time you want to spend. Vial is the configuration route, so you remap keys and layers without writing firmware source. Building your own QMK means editing the firmware source, which is where everything is possible and where the afternoon goes. The firmware guide covers how to build and customise it, and for most builders starting with Vial and moving to QMK when they want something the configurator cannot express is the sensible order. ## Licence, versions and the state of the design The licence is the part of this project that deserves a careful reading, and it is unusual for hardware. The work is licensed under a Creative Commons Attribution licence, and the file is LICENSE.txt. That is the licence used for design work, documentation and drawings, and it is the normal choice for a hardware design that people are expected to copy, print and build. It is not a software licence, and the design files are not code, so the attribution requirement is about crediting the design when you share files or photographs of what you built. The version history is short. v1.0 came in April 2023 and v2.0 in March 2024, with the repository last pushed to on 2026-09-25. So the current design is the second version, the documentation has been maintained since then, and the community of builders is still producing pictures. That combination, a licence that lets you build it, a documented parts list, a build guide with pictures and a troubleshooting page, is what makes an open hardware project actually buildable. The engineering is the matrix and the reversible board, but the reason other people can build it is the set of documents in doc/ and the printable parts in the repository. ## Conclusion Cheapino fits a builder who wants a split layout, has a soldering iron and a 3D printer, and is prepared to read a build guide before ordering anything. It does not fit someone who wants a finished product with a warranty, or a builder who cannot source a PCB, and it does not suit a typing style that needs more than 36 keys. Verify three things before you order: what the ordering guide lists as the parts and where to buy them, since the whole design rests on that document rather than on a bill of materials in the repository, whether your plate and case choice suits the hotswap sockets you plan to use, because the case is the part that changes the price, and which firmware route you are taking between Vial and QMK, since the guide treats them as alternatives with different amounts of work. ## FAQ ### What is Cheapino and how many keys does it have? Cheapino is an open hardware split keyboard with 36 keys, described as probably one of the cheapest split keyboards you can build. The goal came from the author really enjoying building keyboards but not wanting to spend that much money on it, and the releases are v1.0 from 2023 and v2.0 from 2024. ### Why does Cheapino need only one microcontroller? Because the PCB uses a Japanese duplex matrix, which wires the two halves into one matrix rather than treating them as two independent devices, so a single MCU such as the RP2040-Zero reads both sides. The PCB is also reversible, and the halves are connected with RJ45. ### Do I need a case and hotswap sockets to build a Cheapino? A case is recommended for hotswap, and the README notes that soldering the switches is of course the cheapest option. The case and the plate are where the cost difference lives, and the plates_and_cases document collects the options the author knows about. ### What firmware can I use with a Cheapino? The keyboard has Vial support, so you can remap and configure it graphically, or you can build your own QMK to customize everything, which also lets you control the onboard RP2040-Zero LED. The firmware guide covers how to build and customise it. ### Under what licence is the Cheapino design released? Under a Creative Commons Attribution licence, with the full text in the LICENSE.txt file at the root of the repository. The README states the work is licensed under a Creative Commons Attribution license, which is the usual choice for a design that people are expected to copy and build. ## Sources - [Issues](https://github.com/tompi/cheapino/issues) - [License: CC-BY-4.0](https://github.com/tompi/cheapino/blob/master/LICENSE) - [README](https://github.com/tompi/cheapino/blob/master/README.md) - [Releases](https://github.com/tompi/cheapino/releases) - [tompi/cheapino on GitHub](https://github.com/tompi/cheapino) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/tompi-cheapino