Differentiate Yourself

If you have a project which was done a 100 times before you, then there is a high probability that this use case is very will supported by propriety tools. There might even be a wizards to implement the functionality you need to implement. But at the same time, this feature will not be the functionality that will differentiate your product from all the other products. So the feature you implemented will not add to the differentiation value of the product.

On the other hand, if the feature you are implementing is the essential differentiation because is solves a problem up to now no one was able to solve (maybe because it was too hard to solve), it is very likely that you propriety tool does not very well support you in designing the solution. It might be that it was even impossible to realize a solution because of the limitation of the propriety tools. Therefore researchers in the past had to build their own tools (like Gallileo the first telescope).

With open source, you can extend the tool to your needs. This is especially useful when you start your project and you do not yet have a clear understanding what features you will need from your tools.

You don’t get stuck. If you find out half way into the project that your propriety tool is not up to the task, you need to start over again.

To be competitive in the market requires that you offer products which are different from the products of your competitor. Your offering can be cheaper, can be more easily available, or can have features others do not provide.

An open source FPGA toolchain can help you in all three areas.

When you decide to design a product, you define a feature set your product will offer so that people are willing to pay for it. Then you need to implement this feature set with the tools available to to. With FPGAs this are the tools provided by the manufacturer of the chips.

You might not want to out-compete your competitor to be cheaper by just accepting a lower salary. You need to be able to design faster than your competitor, who is using the same tools as you. Which means that you need to be smarter or more experienced to gain an competitive advantage. Which might not always be the case.

You might want to out-compete your competitor by offering a innovative feature set in your product. As you are the first designer using the FPGa tool set for this new kind of feature, you  will probably discover a lot of bugs in the FPGA tool as noone else before you did use the tool in this new way. But this gives you the possibility to out-compete your competitor by inventing “tool-bug workarounds” and finishing your innovative product. Finding those bugs in the tools and inventing workaround takes a lot of time and cost a lot of money.

Your  experience gained in this process will become obsolete with the next version of the tools because the toolmaker will fix many of those bugs.

If you use an opensource toolchain, you are not bound by the feature set the commercial tool vendor is offering. you can break away from your competitor by extending the open source toolchain in a new creative way. This way you can design products which differ from your competitors products as you use different tools.

For sure, opensource toolchain do not support all the features commercial tools offer today. for for designing a intriguing products, it might be that you don’t need all those features, but only the already available once in the opens source tools and you add one really important feature to design the compelling product your clients are willing to pay for.

Google could have used Windows NT or Solaris to build its search clusters, but decided to use the inferior Linux, as it was a good enough fit, and offered the possibility to adapt it to the specific needs of google to build a large search cluster.

If you can use the open source FPGA toolchain with its limited feature set to build the product you imagine, but you would need to push the limits of the commercial toolchain to realize your innovative product, you are very likely better off using the open source toolchain, because you will not need to work around the bugs in the toolchain, but can hire a toolchain developer to fix and adopt the toolchain to your specific needs, which saves you a lot of time and money.

Therefore, if  using a open source FPGA toolchain can result in a cheaper, earlier and more useful product.

Our Motivation

The future will be heterogenous

CPU and GPU have their distinct advantages handling compute problems. It is clear that good solutions will include both of these hardware types. But it is required to have good integrated programming tools to make the most out of the software. These tools are available as open source.

It is clear that in the future, FPGAs will be added as a hardware capability to this mix. Propriety toolset are very hard to integrate with the ecosystem of software tools.

Having an open Source FPGA toolchain is a first step to a time where CPU, GPU and FPGA can be seamlessly programmed within one IDE.
We are opensource fans. There will be a time after the Neumann architecture. We consider FPGAs as a flexible powerfull tool which might be a path into the future of computing.  FPGAs might play a role in this challenge. But we currenlty do not have any tools to go down this path. icoBOARD with its toolchain is the first step on this journey.

Innovation consists of co-evolution of all components of the full stack (chips, boards, algorithms, tools, applications). Having one company holding a monopoly over one of the lower part of the stack holds back this co-evolution.

Innovators require flexible tools

Without documented Intel 386, there would have been no GCC, and without GCC, there would have been no Linux, and without Linux, there would be no google and no Facebook. We want to enable people to play with FPGAs, as most people think that this class of devices do have great capability, but dont show it.

Innovators need the possibility to use the devices in a way originally not imagined by the makers of the propriety tools, or simply not a valid business case, like buidling a cluster out of 16 Intel 486 with an ethernet switch, which started the cluster supercomputer revolution. Having only Windows NT, this would have been simple impossible.

We want to enable creative people to realize the almost impossible.

What market do propriety FPGA tool manufacturers address?

Enable New Usercases

FPGA might be usefull in cases currently not imagined by the commercial toolmakers like generating the FPGA bitstream on an embedded processor or a mobile phone.

For enabling new use cases, the tools need to be flexible so that they can be adapted to the new needs and integrated with other components of the stack. Open Source has proven many times in the past that it is an enabler for creative usage of technology.

We are curious what will spread up from this.

Supporting Legacy Chips

Currently we do not support any legacy chips from any vendor. If you are a FPGA vendor and you want us to support any of your legacy chips, because supporting them in your current toolchain is a burden to you, please contact us. We would be happy to help.

Xilinx is no longer supporting its old design suite as it is focusing on its new Vivado design suite. But if you need to fix bugs in your old hardware designs like the Spartan3, you are stuck with a toolchain no longer supported by the toll vendor. The world moves on and your are left behind.

Within the next years, Xilinx ISE will probably no longer be installable on an up do date PC. So you will need to have an old PC around to support your Spartan 3-6 hardware.

Testing and Validation

For professional Verilog designers, in most cases currently open source synthesis tool and place&route tool are no alternative to the propriety solutions available.

But Yosys can be used to test for bugs in your design caused by bugs in the commercial toolchain.

Generate with your commerical tool from your Verilog design a RTL file, run your Verilog design through Yosys, and test the two for equalness also with Yosys. If the test is not positive, than there is something wrong.

This way we found about 18 bugs in commercial tools which generated faulty bitstreams.

Enable Safety

FPGAs are a very flexible and powerful tool to do safety research.

The main property of FPGA is their low latency. Communicaton lines within devices can be interfered and data transmitted over one line could be tampered. So one user used an FPGA to listen to the i2c communication between a micro-controller and a radio chip and rewrite certain messages sent from the micro-controller to the radio chip. This way the frequencies used by the device could be reprogrammed without the need to hack and reprogramming the control software on the micro-controller.

Explore some examples here:

Chip Whisperer

Daisho board

Enable Research

Flexible FPGA might be powerfull research tools for any field

Researchers are used to build their own tools to achieve new insights in areas noone has entered before because commercial tool just dont adress the need of researchers, just because the market is too small and too little money is to be made for the manufacturers. This holds true for FPGAs and its programming tools.

Therefore researchers and students of any field (like Cern) might want to adapt the FPGA toolchain to better meet their needs. Something impossible with propriety tools.

Making FPGAs more accessible for research on their programming tools

FPGA researchers can do research on FPGAs tools and add their research result to a complete toolchain and evaluate the result of their work on real hardware with real use cases.  Something which happens with

How about automatically generating from design parameters discrete electronic circuits and PCBs by writing Verilog code? done here

Making Architectural Research Easier

Groundbraking computer architectural innovations were done by van Neumann very long ago. Since then Moore law brought an abundant supply of computing power.

But as research papers like this  or this demonstrate, multiiple factors of speedups can be achieved if we no not just innovate on the Software side, but also on the compute architecture.

It makes sense to tailor the hardware ciruits of the computing device to the problem (like neuronal) itself.  Solving a class of problems by simulating a new type of computing cuircuitry on a traditional computer is several 10000 times slower than solving the problem on a von Neumann machine itself.

Even emulating a new architecture on a FPGA is 100 times slower then an implementation as an ASIC.

As implementing an ASIC is prohibitive expensive for a research institution, this leads to the problem that most arhcitectural research is of theoretical nature, as it can not afford to try out on real world data and demonstrate its advantages. Here the “demo or die” .

With making FPGA programming tools freely available with sourcecode, we hope to speed up the innovation in hardware defining languages and verification so that it in the result will become a possible for a researcher to get a chip delivered to his lab for reasonable money implementing his invented compute architecture as an ASIC.

Help yourself

Open source is not about cheaper tools or easier to use tools. Open source makes projects possible which might be impossible with propriety tools.

LinkedIn found out that commercial switching equipment manufacturers did not provide what they needed. They found that:

  • Bugs in software that could not be addressed in a timely manner
  • Software features on switches that were not needed in our data center environment. Exacerbating the problem was that we also had to deal with any bugs related to those features.
  • Lack of Linux based platform for automation tools, e.g. Chef/Puppet/CFEngine
  • Out-of-date monitoring and logging software, i.e. less reliance on SNMP
  • High cost of scaling the software license and support.

What they wanted was:

  • Run our merchant silicon of choice on any hardware platform
  • Run some of the same infrastructure software and tools we use on our application servers on the switching platform, for example, telemetry, alerting, Kafka, logging, and security
  • Respond quickly to requirements and change
  • Advance DevOps operations such that switches are run like servers and share a single automation and operational platform
  • Limitless programmability options
  • Feature velocity
  • Faster, better innovation cycle
  • Greater control of hardware and software costs

This could not be provided by any propriety vendor.

So they had to build their switches themself. This was only possible because they could reuse on freely available open source software. In the future they might even use FPGAs and program them with open source FPGA tools .


Chip Developer Kits

You are the manufacturer or seller of a chip with a digital interface and you want to get your products into the hands of developers so they can experience how your chips work?

You can build a complete developerboard with a MCU and your chip or you could connect

your chip to an USB bus and let the developers connect it to their PC.

In both cases, the developers need to set up Software on their PC to play with your chip.

If you make your chip available as a PMOD module, you could make available a complete

Verilog development environment running on the RaspberryPi, and the devlopers can play with your chip without the requirement to install software in their PC.

The deveopers would not need to install or license those huge FPGA developer tools like Vivado

just to try our your chip.

Analog Devices is making available a lot of their chips as PMOD demo boards.

Linear devices is doing demo boards of their chips for FPGA boards

Get Your Hands Into FPGA, Fast and Easy

Professional tools from manufacturers adress professional engineers designing powerfull solutions like high frequency trading, video compression, or signal processing for massive radar arrays or particle detectors.


Therefore the tools to program FPGAs are sophisticated, powerfull, but also complex. This complexity stands in the way when beginners and tinkerers want to learn playfull the principles of FPGA programming.

As our tool targets small FPGAs and are open source, the tools can be much simpler and much easier to understand.

We consider Verilog as an intermediate language like PostScript. Postscript is a powerfull language, but most Postscript files are written by other softwarepackages interfacing to humans with a higher level of abstraction.


We expect that in the future new tools will enable users to define systems solving their own problems like the first spreadsheet software on an Apple II empowered non-programmers to do complex calculations.

Our icoBoard makes it easy for tinkereres to choose Interfaces from a large list of PMODs to quickly put together a hardware meeting their requirements and start coding without the need for much soldering.

Until Altera or Xilinx get as wise as Microchip, we depend on Lattice Chips.

“Microchip admits they have a problem, and they’d like to find a solution. Microchip knows they need to have open software to be the de facto choice of the hobbyists and students who go on to become engineers.” Link