One of the best-kept secrets in Nordic tech is that the core technology inside the Chrome browser was built by an elite team of engineers in Aarhus, Denmark.

In 2006, Google’s senior leadership wanted to build a much more powerful browser so we would all run software in the cloud from the browser, thereby breaking Microsoft’s then-monopoly on operating systems. To make it possible, the virtual machine running JavaScript in the browser would have to be orders of magnitude more powerful than the one inside existing browsers, so they set out to find the world’s leading experts in virtual machines. They found Lars Bak and Kasper Lund, who had previously built Java virtual machine technology at Sun Microsystems.

Lars and Kasper wanted to stay in Aarhus, so Google set up an office there for them, and together, they built a distributed team of more than 70 engineers. The duo aptly named their technology V8: the powerful engine underneath the Chrome.

Larry, Sergey, Sundar, and Lars at the Chrome launch

Two billion active users later, Chrome and V8 have changed computing forever. Today only few software vendors would dream of asking users to install a separate program to start using their service: everything runs in the cloud through the browser — indeed, this draft was typed and edited in Google Docs from Chrome. It’s almost an afterthought that Node.js, a leading server-side run-time environment, and MongoDB, a leading database and itself a listed billion-dollar company, was also built on top of V8.

After V8, the team built Dart, a cross-platform, client-side language that is being adopted by many cutting edge development teams, and was the foundation for Flutter, a fast-growing language for mobile apps. But still, Kasper and Lars always had this IoT idea kicking around in their heads.

What happened to the Internet of Things?

The promise of IoT is that all devices around us will be smart; the idea that our home appliances, industrial machines, and buildings will be connected, and able to interact, share data, and to have complex logic, just like regular computers.

This future hasn’t yet come about because writing software for IoT is really hard. While modern software development is driven by continuous delivery, iterations, and experiments, IoT is another monster. Here are four reasons why:

Due to power consumption, the typical IoT chip is too resource-constrained to run Linux. Therefore people either write code directly on the device (what’s called bare metal) or on very thin task schedulers, neither of which provide the abstraction or support that software engineers get on other platforms. Software is chip-specific, which means that unless you want to build and maintain separate codebases, you’re locked into whatever chip manufacturer you used for your first batch of devices. Once you’ve got your hardware and you’ve written your software, you’ll find that updating the device is really hard: the only way to do it is to flash the entire thing, which means that you delete all the software on the device, reinstall it, and then pray that it goes back online. If it doesn’t, for example, if there’s a bug somewhere in your code, then you have a dead device. Managing multiple devices is complicated: in modern software development, a common strategy is to roll out new versions gradually to more and more users. There’s no way to do that for IoT devices.

Because it’s so hard and so risky, the general approach is to have as little logic on the device as possible, and simply send raw data to the cloud to do calculations. Even more depressing, people normally write and install all code before shipping the device, and then never touch it again.

It needs to be toit

In early 2018 Kasper and Lars decided that the “iPhone Moment” for IoT was now. So they started Toitware, the general-purpose computing platform for IoT devices that the world has needed for two decades.

This is a full, general-purpose computer. It costs $1, runs on a AAA battery, and with Toitware, writing software for it is as easy as developing web apps.

Because of the resource constraints on these chips, an IoT computing platform needs to be tight in order to function — hence Toitware.

Toitware lets you build software for IoT that runs inside a virtual machine on your IoT device, similar to how JavaScript runs inside V8. This has the benefit that the code is contained from the rest of the software: if your code crashes, the device, and any other code, keeps running. It also lets you run multiple applications on the same device: apps for your appliances.

Toitware also makes over-the-air updates a bliss. It even makes sure that all data transfers to and from the device are 100% secure — something that’s generally not at all the case for IoT.

Combined, these features mean that IoT software engineers can comfortably update devices in production when they want, opening the door for continuous delivery of software in IoT.

In addition, the team had the clear opinion that the syntax of writing IoT software had to be simpler than C, the low-level language currently used for IoT. To do that, they have developed a new programming language: Toit. It’s so similar to Python that a Python developer can learn it in a few hours, but it has some subtle differences that make it more appropriate for constrained IoT devices — including being 30x faster than Python.

And finally, Toitware abstracts away the underlying chip architecture, and lets you use the same codebase across different chips — just like you can on servers and in browsers today.

Just like what MS-DOS did with PCs in the 80s and what Android has done with smartphones the last decade, the team’s grand vision is to drive standardization across IoT hardware, driving down prices and fostering an ecosystem of software libraries, which will propel IoT innovation and growth.