The Next Generation of High-Powered Microcontrollers

When you start working with physical computing the first thing pretty much everybody does is to blink an LED on, and off, again. When things were harder, this was a rite of passage. Just to get to the stage where you could turn an LED on, and then off again, could take a week or more of hard work. The arrival of the Arduino changed all that, relegating it to a simple parlour trick, a “Hello World” of hardware.

These days things are different, and while we’re reaching the end of Moore’s Law, we haven’t quite got there yet. Over the last few years we’ve seen a bewildering explosion in the number of microcontroller and single board computers. People have experimented with form factors and processors, and pretty much every board now comes with radios, sometimes lots of radios.

Despite this proliferation, at least for now, the maker market for computing hardware sits on top of three, somewhat unequally balanced, legs. In one corner, despite all the recent legal troubles, is the now venerable Arduino and a large number of compatibles and spin-offs, in the other is Raspberry Pi. The third leg, perhaps more arguably, consists of boards based around the ESP8266 and ESP32. Not a single company this time, but a community. Because what these three pillars of the community share is just that, community. About and around them are active, vibrant, communities.

Over the years I’ve been excitedly told about the next Arduino or Raspberry Pi killer more times than I can recall. I’ve now even been pointed at an ESP8266 killer once or twice. One may come along, but nothing has ever come of it to date. It’s not because the boards I’m shown are bad boards, or that they aren’t price competitive, although sometimes they just aren’t, but because it’s hard to build large communities, and there has to be a reason for an existing community to move on. It appears that “good enough” is sometimes all that’s needed.

However, it is very clear that the current state of the board market is in transition. Just as the way we’re using computers is changing, the way we build hardware is changing with it. Because of that, manufacturers aren’t entirely sure how people are going to use their product. Like our other computers, microcontroller boards have become communication tools. It’s just that, at least for the most part, they’re talking to each other, rather than to us.

At the moment, we’re seeing both a collapse in the number of form factors, and what feels like a sea-change in the languages and methodology to program the boards we’re using. After the many experiments we’ve seen over the last half decade, there is now little question that the Raspberry Pi has become the defacto standard form factor in the single board computer market. While in the micro-controller market things are a little bit more complicated, with Arduino in the process of abandoning their “classic” form factor that has for some years been the standard in favour of something more modern, the community seems to be adopting Adafruit’s own Feather as the next standard. Spanning both the Arduino community, and the community that has grown up around the two new Espressif chips, the Feather form factor has brought multiple chipsets, and snap on attachments known as “FeatherWings,” under a single roof which makes a lot of sense.

The Adafruit Feather.

Because, perhaps the most interesting thing going on in the micro-controller market right now has little to do with the hardware, it is hardware agnostic. Instead it’s all about how we build, rather than what we build with.

When it arrived, the Arduino was a massive disruption to the existing microcontroller ecosystem. However the disruption it brought was only partially to do with the hardware, and far more to do with the development environment that came with it. The success of the board spawned any number of clones and counterfeits. However, it was the existence of derivatives that was by far more interesting. People experimented with features, but reassuringly the boards themselves could be used inside the familiar Arduino development environment. Arguably it might well have been the addition of “official” third-party board support, that drove some of the adoption of the ESP8266 in the early days.

However things have moved on, while the Arduino development environment was a revolution when it was introduced, and scathingly criticised for making things “too easy,”  it now seems dated. While the online Arduino Create environment—destined to replace the traditional desktop application—has come a long way since it came out of beta a couple of years ago, it’s still at its heart the same Arduino-like experience (and closed to non-Arduino boards). For a new generation of developers, used to Javascript and Python, that’s a problem.

A whole generation of programmers have now grown up with the web, where Javascript is the defacto language. Alongside them is another, even larger, group who have made Python the defacto language of science, engineering, data analysis, and most recently machine learning. The idea that you need to learn C to program hardware seems antiquated. Almost as antiquated as the idea that you should learn assembler, an idea the Arduino itself was pivotal in killing off in turn.

While the growth of high-level languages on microcontrollers has been slow, I started talking about Javascript on microcontrollers and a possible “third community” well before the ESP-based boards became that community. Over the last year or two we’ve what I can only describe as a watershed moment in the microcontroller world, interpreted languages like Javascript and Python have become the new normal.

“Seasoned Embedded C developers may not be convinced, but it’s not about them. It’s about opening up microcontroller development to the millions of JavaScript developers out there.”—Gordon Williams, Director, Espruino

Evidence of this can be seen in the community that has formed around the ESP-based chipsets. While the chip’s Arduino compatibility is a selling point, the community-built Lua development environment is actually far more widely used.

“If you factor software development time into the cost of your product (which you should), it’s going to be cheaper to use an interpreted language in a lot of cases.”—Gordon Williams, Director, Espruino

The emerging future communities we’re seeing being built are not around specific chipsets or even boards, but around languages. Real high level, widely used, languages like Python and Javascript. By cannibalising the existing Arduino community, and even the newer community formed around the ESP-based boards, the new microcontroller communities are hardware agnostic. They care far more about language support than that chipset the board is built around. You have to wonder if this new trend is something that is partially driving the success of the Feather form-factor, which is more-or-less chip agnostic.

The Adafruit Gemma M0 was the first board to run Circuit Python out of the box, with a host of others following including Metro M0 Express, Metro M4, Feather M0 Express and a soon to be released Feather M4. High-level language support is fundamentally disruptive to the the way we currently build hardware.


Traditionally developing firmware for hardware has taken infrastructure, sometimes a lot of infrastructure. Back before the Arduino came along, you needed to buy a—usually fairly expensive—development board from the manufacturer, install a proprietary development environment, write your firmware, and then finally buy individual chips and roll your own PCBs. The Arduino fixed that, but what it didn’t fix was the necessity to install software, drivers, and hack away in a language that, to most developers, is foreign.

Now when you plug it in a board running CircuitPython it will simply show up on your desktop as a external drive. Edit the code.py file on the drive, in whatever text editor you want to use, and changes to your code are run as soon as the file is done saving. No installation, no compilers, no proprietary development environments. You can write your code on Windows, macOS, linux, or even on a ChromeBook.  It doesn’t matter anymore, and that’s what makes it powerful.

Most people, and most makers, want to solve a problem. While, for some, the specifications of the board really matter, those people are by far the minority. In a move that mirrors the changes we saw in the desktop and laptop computer market, our microcontroller hardware has become “good enough” that we now don’t have to worry about the underlying technology.

Your solution to a problem could be powered by Python, Javascript, Arduino, or magic beans. It doesn’t matter. The important thing is whether it solves the problem better than other methods, more seamlessly, and without the need for the end user to understand whatever technology you’ve used. Or in the case of developers, without having to delve deeper into the infrastructure that you have to, writing code is a way to solve problems, not an end in itself.

If high level languages bring more accessibility to people that want to make use technology, we as hardware developers should welcome it, promote it, and above all don’t look down on the people using it.

Because there’s more disruption to come. The last year or so has seen a coming of age for the FPGA. Which, even more than microcontrollers, have suffered from an infrastructure and usability problem. Stuck in a ‘pre-Arduino’ age, the FPGA has languished while microcontrollers have become far more usable, and accessible to non-specialist developers.

Appearing somewhat lost after their legal troubles you have to wonder whether Arduino might manage to do it again and reinvent themselves, integrating  FPGAs into the standard Arduino toolchain and turn configuring an FPGA using Verilog into yet another “Hello World” of hardware. While their new Arduino MKR Vidor 4000 may do this, it has yet to been seen whether Arduino Create can make programming the FPGA easy. This move, though, actually appears to be moving Arduino away from its open source roots. There is no open source toolchain for the Intel Cyclone FPGA that they’ve used in their new board.

When it comes down to it, I actually think that the next generation of high powered micro-controllers will be defined, not by their hardware, but by their user experience. Programmed using an easily accessible, and widely known, high level language like Python, and perhaps configured under-the-hood using yet to be written tools that make using an FPGA as easy as today’s microcontrollers. The future of hardware is about accessibility.

That’s a big change for the traditional community to swallow, perhaps bigger than the move back in the day away from assembler, to programming chips in a “high level” language like C. But there are far more of “them,” than there are of “us.” Far more Python and Javascript programmers, than those of us familiar with low-level hardware. Far more people that care about solving a problem, than care about the technology that solves it.

Join 7,000+ makers on Adafruit’s Discord channels and be part of the community! http://adafru.it/discord

CircuitPython in 2018 – Python on Microcontrollers is here!

Have an amazing project to share? Join the SHOW-AND-TELL every Wednesday night at 7:30pm ET on Google+ Hangouts.

Join us every Wednesday night at 8pm ET for Ask an Engineer!

Follow Adafruit on Instagram for top secret new products, behinds the scenes and more https://www.instagram.com/adafruit/

Maker Business — American startups are having an increasingly smaller share of the market

Wearables — Switch the advantage

Electronics — Don’t float!

Biohacking — Optimizing the Warm Up

Python for Microcontrollers — CircuitPython 3.0.0 released!

Get the only spam-free daily newsletter about wearables, running a "maker business", electronic tips and more! Subscribe at AdafruitDaily.com !


  1. I found this article very insightful, as one who has been a part of (sometimes more actively than others) the Adafruit community since soon after they opened business, I definitely feel the supply and demand trend shifting towards what people know how to do, and thus feel comfortable doing.

    I’m 48 now and lived through the switch from Cobol/Pascal to Assembly to C to C++ to Javascript to Python now, and my big jump from C to Arduino to Python happened because of two factors more than anything else; The creator/supplier of the products (Adafruit being forefront in my mind) and the community that grew up around it. If Arduino was accused of making it “too easy” for we-the-people to learn how to command micro-controllers, then Adafruit should be proudly accused of being one of the most prolific evangelists of the maker movement. This comes from two elements in the case of Adafruit; Lady Ada and Phillip Torrone, who together created an amazing company founded on honor principles and devoted to encouraging and inspiring more women to join the technology world. Perhaps it is that mission that really drove them forward, along with inspired market instincts and a firm grasp on the latest social media technologies, Adafruit really has lead the way (for us in the USA at least) at building products that are easy to use, inexpensive, and massively supported.

    This does not intend to detract from any of the other fine maker companies out there, many of whom I also buy from like SparkFun, DFR Robot and Servo City to name a few. I do however bow my hat to Adafruit and it’s founders as what history will remember as the beginning of something new and powerful for our time. I’m not the only one who feels similarly either, as a huge community of devoted people has grown up around the company that makes Adafruit products some of the best-supported things you can buy. Using the latest communications technologies and a weekly show from the onset also was something brand-new, like Game of Thrones was to the fantasy movie world, Adafruit was providing something new, something more than other companies followed later on to varying degrees of success.

    Adaptation of the feather profile for micro-controller products makes sense in this context, as like it or not, everyone in the world watches what Adafruit creates now and tries their best to copy it in their own products. Perhaps Lady Ada and Adabot (coolest nickname bro) are too humble to fully rationalize the impact they are having on not just their own financial fortunes, but on the future of our world. History will bear this out I feel, but this article is a beautifully-written history and sensible outlook on where we were and how we got here.

    At the end of the day it is profound in pointing out that we are wasting a vast resource of learned knowledge if we don’t shift the technology towards what most of the world now knows and enjoys to code in. Python is not a huge leap from C either, its just the stubbornness of gray-muzzles like me that watch bewildered (or inspired) as a huge population of Python/Javascript-saavy coders literally changes the face of technology. For me it is wonderful to watch and exciting to be a part-of the community, and just another example of why it is impossible to predict where we will truly end-up on this grand technology rise of human-kind. We can fear it, resent it, or bend with the wind and change from old ways to embrace the new, and thus become a part of it. I know what my choice is, Adafruit products have already changed my life, and I look forward to seeing just how far Lady Ada and Adabot take us on this hugely-fun path of electronics products.

    (a.k.a. Voltie)

  2. For the last 12 years I have been prone to purchase every shiny new microcontroller that hits the market to kick the tires. Being an early adopter has left me with many pieces of hardware that failed the test of time; either they were too difficult to use; or the documentation was not there; or the support faded so no community growth. This article really resonated with me and the big questions I have been pondering about the future of microcontrollers. Good job!

  3. Great article! Starting out with PICs via the BASIC Stamp and seeing every derivation of form factor in between from SIMMStick to Arduino I’m really happy to see the industry settling on a reasonable hardware agnostic DIP package with a consistent community supported language / libraries. (even if it meant having to switch to a language with braces and semicolon line endings) Now if we can just get a better IDE than that Arduino piece of cruft. Admittedly, I have not tried Arduino Create but the online compiler concept doesn’t really interest me. Currently, Visual Studio with the Visual Micro plugin is about as good as it gets but Sublime Text with Stino is hot on its tail if they could only get more boards supported. It’s pretty hard to argue with the CircuitPython concept of “programming” the chip though! Cheers.

  4. Great article! Starting out with PICs via the BASIC Stamp and seeing every derivation of form factor in between from SIMMStick to Arduino I’m really happy to see the industry settling on a reasonable hardware agnostic DIP package with a consistent community supported language / libraries. (even if it meant having to switch to a language with braces and semicolon line endings) Now if we can just get a better IDE than that Arduino piece of cruft. Admittedly, I have not tried Arduino Create but the online compiler concept doesn’t really interest me. Currently, Visual Studio with the Visual Micro plugin is about as good as it gets but Sublime Text with Stino is hot on its tail if they could only get more boards supported. It’s pretty hard to argue with the CircuitPython concept of "programming" the chip though! Cheers.

Sorry, the comment form is closed at this time.