
Ninepad choc
kqrla/keeberia
browser-based intuitive visual builder for custom macropads & keyboards with pixel-level control over parts, layout and functionality for the pcb, parametric case parts, keycaps and firmware.

browser-based intuitive visual builder for custom macropads & keyboards with pixel-level control over parts, layout and functionality for the pcb, parametric case parts, keycaps and firmware. basically canva for custom keyboard enthusiasts, handing over all control from the design to production, manufacturing and configuration w no software juggles
Streamdeck is an open-source printed circuit board by kqrla, from the kqrla/keeberia repository on GitHub. It is a 2-layer board of 89.8 × 92.5 mm with 27 parts on 23 nets, routed with 534 tracks and 13 vias.
It is built around the 1N4148W and M10. Its parts include 10 diodes, 10 switches and 1 IC. It belongs with the keyboards and input boards and the RP2040 boards of this library.
a visual, parametric way to design custom macropads, keyboards, and other little physical input devices without manually rebuilding the same stuff every single time»
keeberia is basically me trying to make the process of making a keyboard less annoying.
for context, i loooove keyboards, and i've made end-to-end macropad pcbs + cases before, and while making them is really fun, there is also a very specific point each type where i'm like "ugh. there's got to be a better way than this" because so much of the process is repetitive, which, my adhd be damned, feels like walking on legos to me. i mean, come on, we
none of these things are necessarily difficult individually. the annoying part is that the same information keeps having to be translated between different programs and rebuilt manually.
and keyboards are structured enough that a LOT of this could just be generated.
so... why not?
custom keyboard design currently involves a weird collection of tools that each know about one part of the device.
you might use:
and then somehow the person making the keyboard is responsible for making sure all of those things agree with each other.
but they don't necessarily know about each other.
so the human becomes the middleware.
which feels kind of silly when the relationships are often extremely predictable.
this is the part that really bothers me.
these are not random artistic decisions.
they're relationships.
and computers are very good at relationships.
keeberia is a design environment where you describe the device at a higher level and let the boring/repetitive parts get generated from that.
instead of starting with:
"place footprint + assign net + route trace + draw wall + cut hole + measure clearance"
you start with:
"i want a 4x4 macropad"
then:
and keeberia figures out how those decisions translate into the actual hardware.
keeberia is split into five major design flows.
they aren't meant to be five separate files or five completely separate programs.
they're five ways of looking at the same device.
layout
↓
components
↓
pcb
↓
case
↓
keys + knobsbut you can jump between them whenever you want.
the project is one object. the flows are just different views into it.
this is the "where does everything go" part.
you can start with something like:
or start blank and use a google-docs-style grid selector.
once you're in the editor, every space starts as a key.
□ □ □ □
□ □ □ □
□ □ □ □you can drag-select cells, merge them, split them, or right click them and do something like:
switch to →
key
encoder
knob
oled
eink
joystick
spacerso if i select two cells and turn them into an eink display, keeberia knows that those two cells are now one physical region.
this stage is deliberately not pcb design.
i just want to figure out the shape and arrangement of the device first.
now we figure out what everything actually is.
the layout might know that something is a key.
components tells keeberia:
this is where you choose things like:
the ui should feel very notion-ish here.
select one thing, or select 12 things, then change a property.
for example:
switch
[ cherry mx ]
[ choc v1 ]
[ choc v2 ]
[ gateron low profile ]then:
mounting
[ solder ]
[ hotswap ]then:
rgb
[ none ]
[ per-key ]
[ underglow ]and if i select every key, i should be able to change all of them at once.
the important part is that users don't have to know the footprint implementation just to choose a component.
if i choose an ec11, keeberia should know what an ec11 requires.
this is where the abstract design becomes an actual board.
the user should be able to control things like:
but i don't want the first experience to be:
"congratulations, here are 900 traces"
the repetitive pcb work should be generated from the component information.
keeberia already knows:
so it should be able to use that information to generate the pcb structure.
advanced users can still expose traces, vias, nets, etc.
i just don't want every person making a tiny macropad to have to manually deal with everything.
this is probably where the whole idea gets even more useful.
cases are so repetitive.
a lot of them are basically some variation of:
pcb
+
clearance
+
walls
+
mounting
+
cutoutsso instead of manually modeling the whole thing every time, keeberia should generate the geometry parametrically.
you choose things like:
and the case updates.
that's the whole point.
and then we get to the fun part.
this is basically:
«okay now make the thing look and feel how i actually want it to»
choose keycap profiles:
choose legends. choose knob styles. change knob diameter/height.
and see the actual finished device in the preview.
the preview is not just some little thumbnail in the corner.
i want the device to basically live in the middle of the application.
there should be a 2d and 3d view.
2d is useful for:
3d is useful for:
and then there can be an exploded view:
keycaps
↓
switches
↓
plate
↓
pcb
↓
caseso you can actually see how the thing goes together.
the preview should be powered by the same underlying project data as the generators, so it isn't just a pretty fake rendering.
keeberia should understand that these things are related.
if i change:
mx → chocthat can affect:
if i change:
3x3 → 4x3that can affect:
if i move an encoder:
i don't want to manually tell five different programs that i moved something.
that's what the project model is for.
autorouting is a two-rung ladder. rung one is circuitron's own a* router — fast, in-process, deterministic. when a board is too dense for it, the worker escalates to freerouting (open source, battle-tested push-and-shove) through a dsn/ses bridge: the board exports to specctra dsn at kicad's exact conventions, freerouting routes it headless, and the ses session imports back into the engine's own segment/via model — then judged by the same drc as the engine's routes. wire it up with FREEROUTING_BIN (jar or binary) and optional FREEROUTING_JAVA + FREEROUTING_TIMEOUT_MS; the rung is skipped cleanly when unset.
all rendering happens on the viewer's hardware. previews are client-side webgl/three.js computed from the same project model the generators consume — the server never touches a gpu.
keeberia isn't trying to reinvent every existing hardware tool.
it's more like a layer on top of them.
for pcb generation, the target is kicad-compatible output and eventually things like:
for cad:
for the browser preview:
the idea is basically:
my design
↓
keeberia project model
↓
pcb / cad / manufacturing / previewrather than manually keeping all of those things synchronized.
because this is a really good problem to attack with software.
the keyboard ecosystem is already incredibly modular.
you have:
people are already designing and buying all of these things.
there's a huge amount of customization happening.
and yet the actual design workflow still involves a lot of manual work.
that's kind of the opportunity.
the more i think about it, the less this is really a "keyboard tool."
a macropad is just one example of a customizable physical input device.
the same system could eventually work for:
the common thing is basically:
inputs
+
electronics
+
physical layout
+
enclosurewhich is exactly the kind of thing a parametric system can handle.
i want it to feel like:
"i have a weird little device idea"
and then i can just start making it.
then eventually hit:
export
and get the actual files needed to build the thing.
because if the computer can already figure out the boring, repetitive relationships between all of these parts, i would much rather let it do that and spend my time on the parts that are actually fun.
| Qty | Value | Footprint | References |
|---|---|---|---|
| 10 | 1N4148W | keeberia:D_SOD-123 | D1, D2, D3, D4, D5, D6, D7, D8, D9, D10 |
| 4 | M2 | keeberia:MountingHole_2.2mm_M2 | H1, H2, H3, H4 |
| 1 | M1 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW1 |
| 1 | M10 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW7 |
| 1 | M11 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW8 |
| 1 | M12 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW9 |
| 1 | M13 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW10 |
| 1 | M2 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW2 |
| 1 | M5 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW3 |
| 1 | M6 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW4 |
| 1 | M7 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW5 |
| 1 | M8 | keeberia:SW_Cherry_MX_Hotswap_1.00u_PCB | SW6 |
| 1 | MIX | keeberia:RotaryEncoder_Alps_EC11-Switched_Vertical | ENC1 |
| 1 | SSD1306 0.91in I2C | keeberia:Display_SSD1306_128x32_0.91in | OLED1 |
| 1 | Seeed XIAO RP2040 | keeberia:Module_Seeed_XIAO | U1 |

kqrla/keeberia
browser-based intuitive visual builder for custom macropads & keyboards with pixel-level control over parts, layout and functionality for the pcb, parametric case parts, keycaps and firmware.

kqrla/keeberia
browser-based intuitive visual builder for custom macropads & keyboards with pixel-level control over parts, layout and functionality for the pcb, parametric case parts, keycaps and firmware.

kqrla/keeberia
browser-based intuitive visual builder for custom macropads & keyboards with pixel-level control over parts, layout and functionality for the pcb, parametric case parts, keycaps and firmware.

wangyeee/OpenHardware
Collections of hardware design related to my drone project.

NTNU-TDT4295/slamdunk
SLAMdunk is a project built to map out environments, using a custom built PCB shield meant for a Xilinx PYNQ-Z1.




baldengineer/addohms
Projects and files from AddOhms Tutorials

Acliad/Nifty-Numpad
Full sized numpad with an extra row and two extra columns of macro keys. It was created as a companion to my TKL keyboard for CAD design.

It measures 89.8 × 92.5 mm and has 2 copper layers, 1.6 mm thick.
27 parts, built around the 1N4148W and M10. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.
From the kqrla/keeberia repository on GitHub, at the commit this page was made from: the board is engines/circuitron/out/streamdeck.kicad_pcb. PCBKit opens the board in the browser, with nothing to install.
Its repository states no licence, so its author keeps all rights: ask kqrla before reusing the design.