A broken trackball often gets a remarkably binary future: improvised repair or complete replacement. Even when the failed part is simple, the owner may have no enclosure model, circuit design, firmware source or reliable specification for the component that just failed.
Ploopy takes the opposite route. For the Adept, the company publishes the mechanical and electronic production files, the shipping firmware and assembly documentation. Firmware is under GPLv3, while the electronic and mechanical hardware files use CERN OHL v2-S.1
The older Classic follows the same idea with mechanical files, PCBs and firmware in its repository.2
None of this makes the peripheral immortal; what changes is the maintenance question, which can move from “does the manufacturer still sell this part?” towards “what actually failed, and which layer can I reproduce or change?”
Open source means more than firmware on GitHub
A peripheral is a stack of dependencies: the shape touching the hand, bearings supporting the ball, optical sensor, switches, circuit boards, microcontroller and finally the software translating all of that into USB motion and clicks.
Opening only the last layer leaves plenty of black boxes underneath.
Ploopy publishes several layers of the same object: the Adept repository contains hardware files, firmware and documentation for fabrication and assembly,1 while the Classic repository explicitly includes mechanical files, PCBs and firmware.2
That continuity matters because an open enclosure with a closed circuit helps with a cracked shell but not a sensor failure, while a published PCB without firmware exposes the traces and still leaves behaviour opaque; free firmware inside a glued enclosure remains useful, but the physical object has not suddenly become maintainable.
Printable parts move the boundary of failure
The enclosure and structural pieces are designed around additive manufacturing, and Ploopy's Classic documentation for scratch builders directly lists the printed parts required, from the upper enclosure to buttons and internal supports.2 As a result, mechanical damage does not necessarily condemn the entire product shape.
A printed part can be revised while retaining the electronics around it, and somebody can adapt the geometry for a different hand or constraint while keeping the circuit and firmware unchanged, so mechanics and function stop arriving as one permanently sealed decision.
3D printing adds costs of its own. Printed surfaces do not look like injection-moulded shells, tolerances depend on the machine and material, and screws still work against plastic. Ploopy's Classic assembly documentation even warns that excessive tightening can damage the printed frame.3
Openness therefore leaves manufacturing skill very much alive. It simply leaves the option to remake the part rather than throwing away everything around it.
The sensor is still an industrial component
The Adept is a useful antidote to the idea that open hardware means making every atom at home.
Its assembly process includes soldering a PMW-3360 optical sensor to the PCB, installing its optic, assembling three small roller bearings and dowels, closing the printed enclosure and inserting the ball.3
Those are real supplied components: neither the sensor nor the microcontroller emerges from a filament spool, and the PCB still has to be fabricated and populated.
Maintainability comes less from total self-sufficiency than from removing secrecy between those parts, because the files describe how the pieces relate and leave a starting point for reproducing the elements that can reasonably be remade.
Ploopy sells kits for a good reason: publishing plans does not make the separate purchase of every screw, insert, bearing and electronic component enjoyable, and the Classic documentation itself notes that self-sourcing can be tricky because parts need to meet fairly precise specifications.2
This is where openness acquires a very ordinary cost: somebody still has to maintain the bill of materials.
QMK makes button behaviour part of the maintainable object
Firmware is the other unusually open layer.
Adept kits ship with QMK and VIA preloaded, and the firmware file shipped on devices is included in the repository.1 Recent Classic revisions also use QMK; Ploopy documents how the firmware can be compiled and reflashed.4
For a pointing device, this can change more than a few button assignments. Software controls scrolling behaviour, secondary functions, resolution and hardware-specific interactions.
A conventional manufacturer can improve those details while it maintains a proprietary configuration utility. QMK moves much of the behaviour into a software ecosystem that exists beyond the trackball vendor itself.
The advantage is not absolute: QMK evolves, configurations move and documentation ages, and an open issue in the Adept repository records how the removal of VIA keymaps from the main QMK repository made an older build procedure less direct.1 That failure is useful precisely because it is visible; an open dependency can break as its ecosystem changes, while black boxes have a less sociable habit of failing quietly.
Repairable does not mean easy
Ploopy mostly demonstrates that repairability has levels.
At the simplest level, the enclosure opens and a mechanical part can be replaced; further up the ladder, somebody can order or fabricate a PCB, change the firmware or eventually edit the mechanical design itself.
Each step asks for more time, tools and skill, which is why “repairable” should never be confused with “effortless”.
The Adept assembly procedure includes sensor soldering, optic installation, mechanical assembly, bearing preparation and final checks,3 so somebody who only wants a working pointing device may quite rationally buy an assembled product instead; openness does not need every owner to exercise every freedom to remain useful.
It also serves the second owner, the repairer, a small community maintaining a model years later, or the manufacturer itself when it reuses a known design base.
This is an important difference from the romantic version of DIY. The goal need not be turning every user into a weekend electronics technician. It may simply be ensuring that no essential layer becomes impossible to take over when somebody actually needs to.
Industrial finish remains an industrial advantage
There is still a reason Logitech or Kensington do not manufacture millions of peripherals on desktop printers.
Injection moulding produces consistent surfaces, short cycle times and repeatable geometry, while industrial production integrates sourcing, assembly, testing and quality control at a scale that an open low-volume project does not necessarily try to reproduce.
Ploopy accepts some of that roughness. Print lines remain visible, screws and inserts are understandable, and the product says more about how it was built.
That language may look less “finished”, yet in exchange the design never pretends that manufacturing disappeared.
The cost of openness is partly aesthetic and commercial: thicker printable parts, visible fasteners, serviceable assemblies and decisions that favour reproduction over a shell optimised only for mass production.
The real open product is continuity between layers
Publishing an STL or firmware alone is not enough; Ploopy is interesting because the mechanical files, electronics, software, licences and documentation describe the same object.12
That continuity cannot guarantee a particular component will still exist in twenty years or that an owner will know how to solder a replacement, but it offers something more modest and more useful: the peripheral does not have to become a mystery again when commercial support ends.
For an object as ordinary as a pointing device, that is already a different model of product lifetime.