We must design free hardware. But the question remains: how?

First, we must understand why we can’t make hardware free the same way we make software free. Hardware and software are fundamentally different. A program, even in compiled executable form, is a collection of data which can be interpreted as instruction for a computer. Like any other digital work, it can be copied and changed using a computer. A copy of a program has no inherent physical form or embodiment.

By contrast, hardware is a physical structure and its physicality is crucial. While the hardware’s design might be represented as data, in some cases even as a program, the design is not the hardware. A design for a CPU can’t execute a program. You won’t get very far trying to type on a design for a keyboard or display pixels on a design for a screen.

Furthermore, while you can use a computer to modify or copy the hardware design, a computer can’t convert the design into the physical structure it describes. That requires fabrication equipment. Levels of design

Software has levels of implementation; a package might include libraries, commands and scripts, for instance. But these levels don’t make a significant difference for software freedom because it is feasible to make all the levels free. Designing components of a program is the same sort of work as designing the code that combines them; likewise, building the components from source is the same sort of operation as building the combined program from source. To make the whole thing free simply requires continuing the work until we have done the whole job.

Therefore, we insist that a program be free at all levels. For a program to qualify as free, every line of the source code that composes it must be free, so that you can rebuild the program out of free source code alone.

Physical objects, by contrast, are often built out of components that are designed and built in a different kind of factory. For instance, a computer is made from chips, but designing (or fabricating) chips is very different from designing (or fabricating) the computer out of chips.

Thus, we need to distinguish levels in the design of a digital product (and maybe some other kinds of products). The circuit that connects the chips is one level; each chip’s design is another level. In an FPGA, the interconnection of primitive cells is one level, while the primitive cells themselves are another level. In the ideal future we will want the design be free at all levels. Under present circumstances, just making one level free is a significant advance.

However, if a design at one level combines free and nonfree parts — for example, a “free” HDL circuit that incorporates proprietary “soft cores” — we must conclude that the design as a whole is nonfree at that level. Likewise for nonfree “wizards” or “macros,” if they specify part of the interconnections of chips or programmably connected parts of chips. The free parts may be a step towards the future goal of a free design, but reaching that goal entails replacing the nonfree parts. They can never be admissible in the free world. Licenses and copyright for free hardware designs

You make a hardware design free by releasing it under a free license. We recommend using the GNU General Public License, version 3 or later. We designed GPL version 3 with a view to such use.

Copyleft on circuits, and on nondecorative object shapes, doesn’t go as far as one might suppose. The copyright on these designs only applies to the way the design is drawn or written. Copyleft is a way of using copyright law, so its effect carries only as far as copyright law carries.

For instance, a circuit, as a topology, cannot be copyrighted (and therefore cannot be copylefted). Definitions of circuits written in HDL can be copyrighted (and therefore copylefted), but the copyleft covers only the details of expression of the HDL code, not the circuit topology it generates. Likewise, a drawing or layout of a circuit can be copyrighted, so it can be copylefted, but this only covers the drawing or layout, not the circuit topology. Anyone can legally draw the same circuit topology in a different-looking way, or write a different HDL definition that produces the same circuit.

Copyright doesn’t cover physical circuits, so when people build instances of the circuit, the design’s license will have no legal effect on what they do with the devices they have built.

For drawings of objects, and 3-D printer models, copyright doesn’t cover making a different drawing of the same purely functional object shape. It also doesn’t cover the functional physical objects made from the drawing. As far as copyright is concerned, everyone is free to make them and use them (and that’s a freedom we need very much). In the US, copyright does not cover the functional aspects that the design describes, but does cover decorative aspects. When one object has decorative aspects and functional aspects, you get into tricky ground (*).

All this may be true in your country as well, or it may not. Before producing objects commercially or in quantity, you should consult a local lawyer. Copyright is not the only issue you need to be concerned with. You might be attacked using patents, most likely held by entities that had nothing to do with making the design you’re using, and there may be other legal issues as well.

Keep in mind that copyright law and patent law are totally different. It is a mistake to suppose that they have anything in common. This is why the term “intellectual property” is pure confusion and should be totally rejected.

  • An article by Public Knowledge gives useful information about this complexity for the US, though it uses the confused term “intellectual property” and the biased term “protection”. Promoting free hardware through repositories

The most effective way to push for published hardware designs to be free is through rules in the repositories where they are published. Repository operators should place the freedom of the people who will use the designs above the preferences of people who make the designs. This means requiring designs of useful objects to be free, as a condition for posting them.

For decorative objects, that argument does not apply, so we don’t have to insist they must be free. However, we should insist that they be sharable. Thus, a repository that handles both decorative object models and functional ones should have an appropriate license policy for each category. (For digital designs, I suggest that the repository insist on GNU GPL v3-or-later. For functional 3-D designs, the repository should ask the design’s author to choose one of four licenses: GNU GPL v3-or-later, CC-SA, CC-BY or CC-0. For decorative designs, it should allow any of the CC licenses, or GNU GPL v3-or-later.)

The repository should require all designs to be published as source code, and source code in secret formats usable only by proprietary design programs is not really adequate. For a 3-D model, the STL format is not the preferred format for changing the design and thus is not source code, so the repository should not accept it, except perhaps accompanying real source code.

There is no reason to choose one single format for the source code of hardware designs, but source formats that cannot yet be handled with free software should be accepted reluctantly at best.

We already have suitable licenses to make our hardware designs free. What we need is to recognize as a community that this is what we should do and to insist on free designs when we fabricate objects ourselves.

Copyright 2015 Richard Stallman. Released under Creative Commons Attribution No Derivatives 3.0 license.