| Episodes | 268 |
| Mentions | 595 |
| Cited here | 81 |
| First — last | #1 — #727 |
| Top guests | Michael Ossmann, Michael Gielda, Nadya Peek |
| Related | arduino · open source software · kicad · kickstarter · raspberry pi |
Open-source hardware is hardware whose design files — the schematic, printed circuit board layout and bill of materials — are published under licence terms that permit anyone to study, modify, manufacture and sell the design, with commercial use being a required freedom rather than an optional one.[6][55] A release constitutes a complete manufacturing package, going beyond a patent, which discloses an invention without handing over the files needed to build it.[6] By the early 2010s roughly a dozen companies had passed one million dollars a year in revenue selling open-source hobbyist boards and kits, with SparkFun above ten million dollars a year and Adafruit near one million from a two-person operation.[1] Because the design itself may be copied lawfully, the trademark on the product name is typically the only exclusive right an originator retains, which makes trademark disputes existential for open hardware companies.[6][242]
Definition and licensing
The open source hardware definition existed before any dedicated licence, so early projects borrowed software licences such as the GPL, whose enforceability against hardware remains untested; the open source hardware licence was drafted specifically to cover hardware-specific matters a software licence does not address, and its text was reviewed by lawyers for suitability to hardware in a way an engineer improvising terms cannot verify.[40][51] Before such standard instruments existed, an engineer wanting to publish a design on defined terms had to write the terms personally or pay a lawyer several thousand dollars to draft them; off-the-shelf licences replaced that cost with a choice among pre-drafted, court-defensible instruments.[4]
The definition requires that the licence permit commercial use: attribution and share-alike terms qualify, while the non-commercial variant of Creative Commons does not, so a design released with a non-commercial clause cannot be called open source hardware even when every design file is public.[6][40] A non-commercial licence publishes the same technical information as a permissive one; the difference is only that the copyright holder reserves the right to sell the product, so the internals are documented while competing manufacture is barred.[6] On the strict reading, any licence carrying a non-commercial flag is not open, because openness is defined by what the recipient may do with the result rather than by how much information was published.[123] Creative Commons attribution share-alike, which does qualify, imposes two obligations on a recipient: credit the originator, and release derivative work under the same terms.[125]
Creative Commons is a poor structural fit for hardware because a physical design is not fully covered by copyright and raises patent questions as well; the TAPR open hardware licence and the later CERN open hardware licence were written to address hardware specifically, and the CERN instrument converted the existing definition’s statement of principles into a lawyer-reviewed legal framework intended to be enforceable.[51][123] Very few open hardware licences have been tested in court, however, and the typical developer has neither the money nor the inclination to engage lawyers, so a licence functions largely as a declared expectation rather than an enforced contract.[61]
A patent is already a public disclosure, so a patent pledge changes nothing about what can be read; what it changes is enforcement, amounting to a commitment by the holder not to sue those who practise the invention.[203] Publication is also a defensive strategy against later patents: an idea that has been published enters the prior-art record, so anyone subsequently filing on the same idea can be challenged.[10] In the United States there is no legal mechanism for placing a work into the public domain by declaration, so a designer intending that result must apply the most permissive licence available, which is why nominally public-domain hardware releases carry licence text.[202] The recurring question for a release is not whether to publish but how far down the stack to go: a PDF schematic, the native schematic and PCB files, the bill of materials, supplier information, or a full turnkey package that lets anyone manufacture the product without further work.[534]
Marks and certification
Neither the term open source hardware nor the original gear logo is legally controlled, so a product that fails the definition can carry both; the certification mark introduced later by the Open Source Hardware Association is the only element with enforceable control over its use.[269][316] Because the gear logo is applied by anyone who releases anything, from a full file set down to a schematic PDF, it conveys nothing about how open a product actually is; one proposed remedy was to append Creative-Commons-style letters indicating which layers — schematic, PCB, firmware, mechanical CAD — had been released and whether the licence carried a non-commercial clause.[316] One workable practice for a vendor with a mixed line is that of Robert Feranec’s OpenRex project, which applies the gear logo only to the fully open, commercially licensed board and leaves it off a module released for non-commercial use.[316] The DIN SPEC documents give open source hardware a formal standards footing: one part sets out an operational definition broken into objective criteria for judging compliance, and another defines a community-based certification procedure against it.[500]
History
Publishing complete construction articles in hobbyist electronics magazines was the pre-Internet form of open hardware; what the open source hardware movement added was not the practice of publishing but a formal licensing framework around it.[14] In 1981 IBM published the PC expansion bus and the BIOS listing while retaining copyright on the BIOS, letting third parties build cards and machines around it; that published bus became the ISA standard, following the earlier Altair and S-100 buses.[158] Arduino was licensed with the intent that others could build on the work before the term open source hardware existed, so the licence choice preceded the definition later formalised by the movement; its development environment was derived from Processing, with Java replaced by C++, and the boards were manufactured locally in Ivrea, Italy, where the surrounding electronics industry made short-run fabrication and assembly reachable by car.[726] Paparazzi UAV, begun in 2003 at ENAC in France, is the origin point of the open-source UAV autopilot lineage from which later open autopilot electronics descend.[356]
MakerBot was founded on a fully open 3D printer, and outside contributors working on the open platform improved the build platform and software that the company had shipped; after venture-capital funding the company closed part of the design of the Replicator 2, concluding it could not continue as a fully open company and grow.[114][127] A Chinese company subsequently took the original files, made cosmetic changes and sold the printer more cheaply than the originator.[114] MakerBot had sold about twenty-two thousand printers in its four-year history at low margin when Stratasys acquired it for roughly four hundred million dollars in stock; because most of the technology was published, the acquisition was for the brand and the community, the assets that openness does not transfer to a copier.[151]
HackRF was funded under DARPA’s Cyber Fast Track programme on an explicit proposal to prototype a software-defined radio, build five hundred units, give them away and publish everything the project produced as open source.[177] The buildlog.net 2.x laser was an early comprehensive open-source laser cutter, developed and documented publicly at a time when a commercial machine cost eighteen to twenty thousand dollars, and roughly four hundred kits were sold from it.[438] Early third-party ESP8266 development ran on a virtual machine leaked from an Espressif partner containing the compiler toolchain; the vendor embraced the resulting outside work rather than issuing takedowns, and later parts shipped with usable tooling from the start.[637] Comparable wireless microcontrollers existed at the time, but only one gave outsiders a documented way to run their own code on it, and that access rather than any silicon advantage accounts for the difference in outcome between the vendors.[637]
Design tooling
In the early open hardware period the de facto schematic and layout package was Eagle, which was free at entry level but proprietary with a closed file format; the only fully open EDA alternatives were gEDA and KiCad.[12] Eagle’s free tier restricted board size and layer count, and lifting those limits required the paid version at roughly six to eight hundred dollars, which meant a released design could exceed what a recipient could legally open.[12] One position on tooling purity holds that a design is not truly open unless it can be edited with open tools, but a documented, open file format is a workable substitute because it lets the design cross into other tools.[12] Eagle held the low-end EDA position for years because the open hardware movement standardised on it, and KiCad displaced it from that position once it reached comparable capability without a subscription.[441]
On the Ubertooth One project, the four-layer board exceeded Eagle’s free tier, and Michael Ossmann moved the design to KiCad on the reasoning that an open design is not usable if modifying it requires the recipient to buy a proprietary licence.[161] Similarly, Adam Wolf’s kit designs kept their firmware within the code-size limits of the free PIC compiler — using all but the last four words of memory — because a several-hundred-dollar optimising compiler would have made the published firmware unbuildable by users.[167] For a small board of twenty or thirty parts the native file format matters little in practice, because anyone wanting to rebuild it can re-lay the design from the schematic in a few hours; the format argument bites hardest on large designs.[49] Cloud-hosted part-library tools have shipped with defaults that publish the symbols and footprints a user creates, so an organisation using one must decide in advance how much its footprint and symbol work discloses about the parts it designs with.[131] A venture-backed EDA company aiming to be acquired must resemble the incumbents to be an attractive target, whereas an open-source EDA project carries no such constraint and is free to try designs the commercial vendors cannot.[286]
Collaboration limits
Hardware has roughly seven layers where software has one — schematic, board layout, bill of materials, assembly instructions, documentation and mechanical CAD — each needing its own collaboration mechanism, licence answer and preferred file format, and version-control tools that diff ASCII cleanly cannot show a meaningful difference between two board files.[105] Forking a hardware design is straightforward but reintegration is not: changes made to a PCB in a derivative cannot be merged back into the parent the way a code branch can, so hardware forks tend to diverge permanently.[154] Open hardware has produced nothing on the collaborative scale of the Linux kernel, because a single circuit board does not partition among contributors: past three or four designers on one board the work splinters rather than accumulating.[49] Splitting a design task between two people is in fact slower than leaving it with one, because interface overhead exceeds the gain; the crossover where division starts to pay is around five engineers of comparable ability, the team size at which products no individual could design become possible.[336]
Distributed hardware collaboration is bounded by physical shipping rather than tooling: a change committed to a software repository is visible to a collaborator in seconds, whereas a hardware revision must be prototyped, shipped and re-instrumented, giving iteration cycles measured in weeks, and each collaborator needs an equipped bench and comparable assembly skill.[336] Altium implemented multi-user concurrent PCB co-design, which is difficult to build and was largely unused, indicating that the constraint on collaborative board design is how the work partitions rather than whether the tool permits simultaneous editing.[336] The hardware community is roughly one thousandth the size of the software community, so in a given hardware speciality there may be no outside contributor at all, and the entry friction is far higher than pasting a script tag into a page.[650] Choosing an unusual processor compounds this: Joe Grand attributed the low rate of community contributions to the JTAGulator to its Propeller microcontroller rather than to the project itself.[575]
Clones, trademarks and enforcement
Nothing in an open hardware licence prevents a third party from sending the published files to a contract manufacturer and undercutting the originator; the constraint on this behaviour is commercial and social rather than legal.[26] Publishing the files also removes hardware’s natural protection, the six to twelve months a competitor needs to develop an equivalent product, leaving only an unwritten rule against competing directly with the originator.[87] For a commodity board built from published Eagle files, the observed interval between product release and a competing clone reaching the market was under seven days, which is why some designers withhold their native design files.[105] The working norm distinguishes derivation from duplication: producing a modified or improved version is expected, while taking the files unchanged, contributing nothing back and displacing the originator is legal but treated as a breach of custom.[40] In the absence of enforceable exclusivity, reputation is the operative sanction in open hardware trade: a company that clones a competitor’s published design outright loses standing with the customers and suppliers it shares with the originator.[189] The Tangibot crowdfunding campaign tested the boundary directly, proposing to take the MakerBot design unchanged to a Chinese manufacturer under a different name while adding no modification; the campaign was legally entitled to do so under the licence and did not reach its funding target.[113]
Practical enforcement against unlicensed copies usually runs through the marketplace rather than the copier: the originator asks the retailer or platform to stop carrying items that violate the licence terms, and litigation is not an available remedy at the scale of most open hardware because the value of a small kit is far below the cost of pursuing an infringer.[41] An unattributed clone also imposes a hidden support cost on the original designer, because buyers of the copy bring their problems to the original project’s support forum; the designer’s defence is to state publicly that units not bought from the project are not supported.[41] Trademark separation serves this same function: permitting others to manufacture a published design while withholding the originator’s name and logo stops buyers of third-party units from arriving at the original designer for support of hardware they did not build.[242] Arduino’s commercial position rests on this mechanism: clones of the board are lawful, but only the company may use the name, so a compatible board must be identifiable as not being a genuine unit.[43] An exclusive manufacturing agreement is a structural hazard for an open hardware company, because with such an agreement in place the design owner cannot move production elsewhere when the relationship breaks down, even though the design itself is public.[242]
Capital and business structure
The overwhelming majority of users of an open hardware product buy the finished, supported board and never open the design files, so a project reaches wide use only when someone manufactures and supports a polished product at a good price; sustained supply requires an organisation with full-time staff and working capital rather than individuals working evenings.[22] Open hardware cannot run on donated effort alone in the way an open software project can, because boards must be purchased before they can be sold.[242] Entering medium-volume hardware typically requires two to ten million dollars of capital, which normally comes from venture investors who expect protectable intellectual property, so openness and the funding route needed to reach that volume pull against each other.[113] Taking venture funding transfers the decision on whether a product stays open away from the founder, whose remaining choices are to accept the direction or leave; this is the usual mechanism behind an open product being closed, and it is the mechanism identified in MakerBot’s case.[208][114] Licence terms are also sometimes changed to satisfy a funder rather than for engineering reasons: Ian Daniher’s instrument company moved to a non-commercial licence while negotiating funding to place its devices in schools.[87] Refusing investment remains a live option where costs permit: Stephen Hawes, designer of an open pick-and-place machine, turned down an investor rather than take the product closed source, having reached a cost base low enough to work full time on modest crowdfunded income.[686]
The durable business model for open source hardware is compiling it: software compiles for nothing, whereas turning published files into a working machine costs money and time, so selling the built article is where the value sits.[686] The exposure a design faces from being published depends on its niche: a tool bought for production work is bought by people whose time is committed elsewhere, so publishing the files costs few sales, whereas a hobby product sold to people with time to build is more exposed.[686] Bunnie Huang structures his own products on this basis, treating the absence of monopoly as a forcing function: an open design can be monetised for a window long enough to fund the next generation, provided the business is built to keep moving rather than to be defended indefinitely.[336] For a complex product the practical value of openness is the ability to modify rather than to build from scratch, because an individual sourcing every part in unit quantities pays prices that make self-building uneconomic.[114] Competitive advantage can also be held in firmware and host software even when the hardware is fully published, so the whole stack need not be locked down to keep a defensible position.[87]
Selling hardware while the accompanying software is written and given away by volunteers creates a support mismatch: buyers who paid for the board treat the vendor as responsible for software defects and documentation they did not pay for and the vendor did not write.[105] Linux was released without warranty and with thin documentation, which created the opening for paid third-party support businesses such as Red Hat and IBM; the same gap exists around open hardware, where a vendor is well advised either to supply software support or to sell it as an option.[105] Crowd Supply operates as a curated product launch platform for open hardware in which crowdfunding is only the first stage, handling fulfilment, marketing and continued sale of stock after delivery; about ninety per cent of the products it carries are open in some form.[314]
Contract manufacturers oriented to open hardware will take runs far below conventional minimums, in the tens of units, which allows an untested design to be offered for sale without the designer carrying inventory risk; a viable division of labour keeps design, documentation, firmware and user support in-house and farms manufacturing, fulfilment and distribution to a partner running batches of one hundred to one thousand.[125] Many designs are worth building but not worth productising, and where the return does not justify production and ongoing support the design can be released as public domain with bare boards distributed at cost; Ian Lesnet’s operation moved from attribution share-alike to public-domain release on this reasoning, reserving only the trademark on the product name.[125] A workable split for a release is two bills of materials: a public one carrying descriptions and manufacturer part numbers, and a private one carrying vendors, negotiated prices and qualified alternates, since the sourcing work in the second represents most of the effort.[136] Raspberry Pi initially released schematics but not Gerbers, drawing the line where disclosure would have compromised the negotiated component pricing its vendor relationships depended on.[136] Openness can itself be leverage in component negotiation: on Andreas Olofsson’s Parallella project, the published board acted as a public reference design for every chip on it, and silicon vendors accepted pricing they would not have offered for an equivalent closed product, which made a ninety-nine dollar target reachable.[254]
Open hardware transparency stops at the design: profit margins, volumes, supplier identities, accounting, web-store operation and shipping arrangements stay private, because a business cannot function with those exposed.[61] Injection-moulded enclosure CAD is the layer manufacturers withhold most readily, and with reason: the value is in the fifty thousand dollars of tooling rather than the geometry, and no user is going to have moulds cut to modify the case.[269] Printing production enclosures does not scale either: a crowdfunded product that printed its own cases ended up running a room of printers continuously, a mistake in hindsight against injection moulding.[172] A development-tool vendor selling open hardware can move from idea to shipped board quickly because one engineer carries a project end to end, paperwork is minimal, and development boards of this kind do not require FCC testing.[157]
Reproducibility and engineering reuse
Openness in hardware is a sliding scale rather than a binary property, and a workable practical test is whether one other person in the world could build what was built: if they would need a supply agreement with a chip vendor, or a paid EDA licence to open the files, the design fails the test.[213] The Raspberry Pi does not meet the definition, because reproducing it would require a relationship with Broadcom for the application processor that an individual cannot obtain, whereas the silicon on an Allwinner-based competitor can be bought by a third party, which is what makes one design reproducible and the other not.[213][300] Replicability constrains design freedom in an open project: parts should ideally be chosen from a shared, obtainable base set, because a design built entirely from custom-specified parts cannot be reproduced by anyone else even when every file is published, and extensibility depends on users being able to buy the parts a design uses.[208]
A BeagleBoard successor moved its BGA packages from 0.4 mm to 0.8 mm ball pitch specifically so that users could fabricate their own boards, since finer pitch tightens solder-mask and etch tolerances and raises board cost, defeating the purpose of publishing the design.[67] Shared mechanical platforms repay their design cost only when interfaces are stable; while heatsinks, sockets and form factors change every year or two, an open laptop chassis cannot amortise, so a slowdown in Moore’s law favours open hardware.[84] Keeping open boards deliberately simple, on the order of twenty to twenty-five components, serves the commercial user as well as the beginner: Ken Burns’s boards are designed so a customer can lift the published circuit into their own product or adjust and manufacture it, which a complex design does not permit.[458] On Piotr Esden-Tempski’s 1Bitsy project, publishing the development board’s KiCad design files and footprint gives a direct path from prototype to product: the working sub-circuit can be pasted into the user’s own board rather than reimplemented.[356] Publishing tested carrier boards for a system-on-module is likewise a support strategy, because a customer respins a validated baseboard into their own form factor and reuses its circuitry.[517] An open instrument design serves two distinct downstream uses — add-on hardware built on the platform, such as the PortaPack for HackRF, and wholesale reuse of parts of the design inside another product — the second of which is only possible because the files are published.[214] For a consultant, publishing a design around a new interface functions as verifiable proof of competence and generates referrals from the platform vendor, which has more integration requests than capacity to serve them.[517]
A LoRaWAN sensor node was published as a full release — hardware design files, schematics, PCB, BOM and SDK together — with the explicit intent that it serve as a reference design from which users derive application-specific nodes; it used an STM32WL carrying a Semtech radio design licensed onto ST’s die, in a dual-core Cortex-M4 and M0+ variant, with a 2 V to 5.5 V input range accepting lithium cells or two or three alkaline cells in series.[557] The WildFire open sensor board carried an ATmega1284P with 128 KB of flash and 16 KB of RAM, a CC3000 Wi-Fi module, an SD card and an external watchdog timer, replacing an ATmega328-class node that had proved short of resources.[250] Tim Ansell’s practice is to state the constraints behind a published bill of materials cost, because a newcomer comparing their own six-hundred-dollar BOM against an undisclosed one has no way to see which constraints, subsidies or volumes produced the difference; the recurring waste in hardware is redesign from scratch, or private modification of a working design with nothing flowing back, and publishing removes the non-recurring engineering from the next board.[375] A large archive of open projects addressing the same problem is usable as engineering evidence: it shows which sensors recur, which circuits around them work, why those choices were made, and where the same dead ends are being hit repeatedly.[403] The first step on a project in an unfamiliar domain is a survey of what has already been published, including failed attempts, since a documented failure shows what to avoid and convergence across projects reveals the parameter ranges the application actually needs.[712]
Calling a published design a reference design invites the claim that it was validated for some purpose and creates liability exposure; Jason Kridner’s practice on BeagleBoard is to state that the design is not validated for any purpose whatsoever and to supply the documentation so the user can validate it themselves.[723] What laboratory instrument buyers pay for is validation for a specific scenario rather than circuit complexity, reinforced by the instrument having appeared in published papers, so an open equivalent must supply that validation evidence rather than merely the same electronics.[618] The users who realise concrete value from open hardware are professional ones: having the design details lets a company take control of its supply chain and continue a product independently of the board vendor, and building a product around a single-board computer that is not open makes the business wholly dependent on that board’s continued manufacture.[723][351]
Open silicon and programmable logic
An open IP effort has to cover two pillars at once — the blocks themselves and the tools and workflows used to build with them — because an open core is unusable to anyone who cannot afford the half-million-dollar tool licence needed to work with it.[519] Non-disclosure agreements are the concrete barrier that open process design kits remove: a training course cannot function if every participant must sign an NDA before touching the tools, so an open PDK is what makes chip design teachable at scale, a constraint Matthew Venn’s open tapeout courses are built around.[616] A process design kit is foundry intellectual property, so the first compromise for open chip design was to host open tools and an obfuscated foundry PDK together in the cloud, usable through the portal but not downloadable.[503] Once a PDK is genuinely open rather than merely hosted, the whole flow can be built and run locally from public repositories, allowing far more iteration; the first openly available nodes were 130 nm at GlobalFoundries, 180 nm at another fab and 130 nm from SkyWater.[503] Open tools plus sponsored shuttle runs remove the funding gate that used to sit before a chip existed: a designer can carry an idea to finished silicon first and approach investors with a completed pre-silicon result rather than a slide deck.[503] Working in open silicon inverts conventional ASIC practice — release early, publish openly and describe the design publicly before tapeout — because the aim is to seed an ecosystem in which designs build on one another.[501]
When one open-silicon shuttle service collapsed, its proprietary internal work would have been lost with it, while the open flow survived and was picked up elsewhere; three routes to open silicon subsequently existed, including IHP in Europe on a 130 nm process, a service in Singapore and a group working with SkyWater, and having several independent services running the same open flow supplies geographic choice and competitive pressure.[703]
The practical attraction of an open instruction set architecture such as RISC-V to an implementer is the absence of licensing exposure: an openly given specification removes the risk of litigation that accompanies implementing a proprietary ISA.[467] Open RISC-V soft cores such as VexRiscv are compact enough that a multi-core Linux-capable system on chip fits in an FPGA of around 35,000 lookup tables, so an open soft-core path does not require a large device.[547] Where a specification forces a large FPGA with hard processor cores there are effectively two vendors and the toolchain comes with them; nobody rewrites a toolchain against a deadline, so open flows remain unavailable at that end of the market, and vendor toolchains bundle free IP cores, making the equivalent open build roughly twice the work.[547] Publishing open FPGA boards is a deliberate strategy for isolating the remaining closed element: once the board, the IP and the software are open, the only proprietary piece left is the toolchain, which makes the obstruction visible instead of diffuse.[547] Putting a memory controller in an FPGA rather than using a fixed system-on-chip makes Rowhammer research tractable, because the researcher can modify access patterns directly; using that approach on a Kintex-7 board, new vulnerability classes were found in memories advertised as Rowhammer-protected.[547] The reverse engineering of an FPGA bitstream format and the open toolchain built on it were done largely in spare time by a handful of people with limited resources — Claire Wolf’s Project IceStorm work being the case in point — which implies a well-resourced organisation could do the same to any undocumented bitstream, and that documenting the format would remove the incentive.[374] Maintaining open footprints together with Blender models for every component used lets one library serve schematic capture and layout in KiCad, photorealistic visualisation, and thermal and EMC simulation, all with open tools.[691]
Caliptra is a shared open root of trust built around a RISC-V core and developed jointly by companies that compete elsewhere, on the reasoning that a hundred suppliers each shipping a different security block cannot be certified across the cloud providers that must accept them, whereas a single implementation can be certified once and reused; hardware has plenty of standards but very few open implementations of them, so each vendor implements the standard separately and every implementation must then be certified.[691] The security argument for an open root-of-trust chip is attestation: if the design is public, a party can in principle verify that the silicon is running the design it claims to run, which answers the question of whether a server operator has been compelled to tamper with its own hardware.[693]
Regulated and security applications
Open hardware in the biomedical domain runs into regulation rather than licensing: making or implying a diagnostic claim about a device brings it within a regulatory approval regime, so open instruments in this area must be framed and scoped to avoid diagnostic claims.[448] A university tympanometry screening device was developed as an open project with all designs published, firmware in Zephyr and a four-layer board captured in KiCad, with design constraints driven by cost and by removing the need for a trained audiologist to interpret the result; moving it out of the academic setting requires reconciling commercialisation with the intent to give the design away, and the same safety, quality and regulatory obligations apply as to any commercial device regardless of the licence.[711] A hardware implant is a malicious device installed on a system to grant software privilege and then withdraw; before the leaked intelligence catalogues of 2013, public knowledge of the category extended little further than games-console mod chips, and the NSA Playset project reimplemented catalogue devices cheaply using open source hardware.[346] An open quadruped robot built around 3D-printed structure and brushless actuators reached a build cost of thirteen hundred dollars, a two thousand dollar reduction on the previous version of the same design, with documentation and video released alongside.[712]