Open Source IDE for FPGAs as QtCreator Learns Verilog

Classic battles: PC vs Mac, Emacs vs Vi, Tastes Great vs Less Filling, and certainly one that we debate around the Hackaday watercooler: command line or IDE? There’s something to be said for using good old command line tools, and even if you like to configure your favorite editor to be nearly an IDE, at least it is one you are familiar with and presumably leverage over several different uses.

Most commercial FPGA tools come with a heavy-weight IDE. The open source tools for Lattice (IceStorm) typically is driven by the command line or a makefile. Until now. [Rochus-Keller] released VerilogCreator which is a plugin for QtCreator.

We were impressed because as IDEs go, QtCreator is both useful and lightweight, two things that don’t go together for many similar tools. [FPGAwars] has had an IDE based on Atom (apio-ide) although it hasn’t been updated in nearly a year. IceStudio sees more updates, of course, but it isn’t so much an IDE as a GUI-based code builder.

[Rochus-Keller] says there’s more to come. However, even at this early stage the IDE does syntax coloring, tooltips, inline messages, and can analyze source code allowing you to cross-reference symbols as you’d expect. There are configurations for Icarus to do simulations or you can use Verilator or Yosys — the synthesizer behind IceStorm. It appears it can also interact with Tcl-based workflows like those used by most FPGA vendor IDEs.

There’s quite a bit still on the to-do list, so we are excited to see where this is going. QtCreator isn’t hard to learn and it doesn’t’ feel as bloated as some of the big IDEs like Eclipse. If you want a quick introduction to QtCreator, we did that already. If you want to draw boxes instead of writing Verilog directly, try IceStudio.

10 thoughts on “Open Source IDE for FPGAs as QtCreator Learns Verilog

  1. Woooo! TCL!

    I had to pick it up recently to drive a couple of tools, and now it’s become my go-to general utility language. I really like how comprehensive the built-in libraries (like file and it’s subcommands) are, strategically taking care of things like proper path joining which can be trivial to solve “good enough” (just concatenate with a slash!) but complicated to do “properly” (like handling the case where a 2nd or 3rd part to be joined starts with a ‘/’ or ‘~’).

    I also kind of like how the entire syntax can be broken down into a very small set of very simple rules. Those curly braces in an if statement, kind of like C? They have meaning! They’re actually a special kind of quote that doesn’t substitute!

    Unfortunately, this does lead to a lot of nested brackets (mostly square ones) all over the place and a few interesting quirks (looking at you, exec!) but overall, I find it pretty intuitive and pleasing from an artistic standpoint, if that means anything. Because everything follows simple rules, I found it took less syntactical memorization to be come fluent too, which is a plus.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.