Draft:Toit

• Comment: This draft excessively uses primary sources, which typically can't be used to establish notability. EatingCarBatteries _{(contributions, talk)} 08:24, 17 December 2025 (UTC)

---

Toit
Paradigm	Multi-paradigm
Developers	Lars Bak, Erik Corry, Anders Johnsen, Florian Loitsch, Kasper Lund
First appeared	2018
Stable release	v2.0.0-alpha.189 / October 28, 2025 (2025-10-28)
Typing discipline	Optional. (Added types are checked and used for optimizations.)
Memory management	Garbage collected
Platform	x86-64, Esp32
OS	Posix, Windows, FreeRTOS
License	LGPL
Filename extensions	.toit
Website	https://www.toitlang.org/
Influenced by
Java, Dart, Smalltalk, Python, Shell

Toit

Toit is an open-source, free, high-level, object-oriented programming language designed initially for ESP32 microcontrollers and Internet of Things (IoT) devices.

Design and Goals

The language was created to address limitations in existing high-level languages (e.g., Python, JavaScript) when used on resource-constrained embedded hardware. According to its creators, Toit code executes over 30 times faster on the Espressif ESP32 microcontroller, than MicroPython while still offering high-level abstractions and a memory-safe runtime.

Toit aims to provide a modern, Python-like developer experience while making it practical to run code on microcontrollers. It's developers intended to combine convenience, performance, and safety.

History

Founding

Toitware was founded in 2017 as "Toitware ApS", with the purpose of building a new programming language focused on IoT development. In 2019, the company secured DKK 23M ($3.5M) in seed capital, provided by Swedish venture capital company Creandum. Initial versions were strongly cloud oriented, and required cloud registration to get started.

Open Sourcing

In November 2021, Toitware ApS announced it would open source Toit to foster a larger community and accelerate its development.The open-sourcing of Toit coincided with the first alpha release of v2.

The cloud offering from Toitware ApS was ultimately discontinued, and development focus shifted toward a Supabase-based PostgreSQL fleet-management solution called "Artemis". Users run their own instances on the platform, with Artemis' code also being open-sourced.

In 2024, Toitware ApS ceased operating. As of 2025 the project source is being maintained by two of the original Toitware ApS employees, continuing to drive community and development.

Naming

Toit was named after the catchphrase of the character ‘Johann van der Smut’ in the movie Goldmember. In a comedic Dutch accent, the character repeatedly uses the expression "Toit like a tiger". This can be seen in the Toit logo, which was stylised after the feline nose.

Key Features

The Toit language has the following characteristics:

• High-level, object-oriented, memory-safe: Toit supports classes, methods and garbage-collected memory management.
• Declarative, and partially statically analyzable: Programs can be analyzed to catch errors prior to being run. If types (optional) are used, static analysis quality improves.
• Low noise indentation-based syntax: Similar to Python, Toit uses indentation for grouping. Common operations therefore use minimal symbols: characters are not required to indicate the end of statements (common to some languages, eg, the use of semicolons in Java). Symbols, such as parentheses, are not used for calls or if blocks (common to many languages, such as C++ and Rust).
• Standard libraries, support for control flow, collections, exceptions, etc.: Toit includes support for strings, lists, maps, classes, exception handling, and other standard programming language features.
• Support for microcontroller I/O and embedded peripherals: In the context of IoT/embedded usage, Toit provides access to GPIO, I2C, SPI and other hardware interfaces.
• Live reloading and rapid development workflow: Toit includes capabilities for deploying and iterating code on devices in-situ.

Syntax and Examples

Hello World

A minimal ‘Hello World’ program in Toit:

main:
  print "Hello, World!"

Functions, Methods & Parameters

Functions are declared by writing the name, followed by its parameters and a colon:

print-hello name:      // A function 'print-hello' with parameter 'name'.
  print "hello $name"  // Prints 'hello ' followed by the supplied name.

Calls use juxtaposition, like the shell, Caml or Smalltalk. Parameters follow the function name without parentheses or commas.

main:                   // Definition of the 'main' function.
  print-hello "Austin"  // Calls ‘print-hello’ with one argument.

Classes

Toit has classes, interfaces and mixins. Classes are declared with class. Constructors, fields, and methods are supported, as are inheritance, etc.

class Foo:
  some-method:
    print "in some-method"

class Bar extends Foo:
  constructor:
    print "in constructor"

  bar-method with params:
    print "in bar-method"

Implementation and Runtime

Toit programs are compiled to bytecode and executed by a purpose built, lightweight Virtual Machine (VM). The same VM is used when working on microcontrollers and on the desktop. On the desktop, Toit can also bundle the VM and the bytecode together, resulting in a self-contained executable.

Containers

On the ESP32, the Toit VM handles multiple programs at the same time. These are referred to as "containers" and run independently from each other. They don't share any memory and run in parallel. Containers can communicate with each other by using a built-in RPC mechanism.

Concurrency

Inside a container, programs do not run in parallel. Instead, Toit provides "tasks" - cooperative threads. Tasks can only be interrupted at specific locations: at yield statements, or in places where the task waits for the system or the hardware.

Ecosystem and Tooling

There are two ways to use Toit:

• For desktop systems: Toit installations use an executable called toit which can compile and run code, manage packages, etc.
• For embedded systems: A tool named 'Jaguar' (jag) enables developers to deploy, update, and manage Toit applications on embedded hardware.

Both tools are hosted and available publicly on GitHub and form part of the completed system download/install.

Position in embedded / IoT space

Toit is part of a broader trend of languages and runtimes designed to make embedded development safer, more productive, and more accessible without sacrificing too much in terms of performance. As noted by one commentator: compared to writing in C/C++ (the traditional choice for embedded systems) languages like Toit are intended to reduce complexity and improve development velocity, while still being efficient enough for many IoT use-cases.

At the same time, using a high-level managed runtime on resource-constrained hardware is a trade-off: while high level languages (such as Toit, and others) offer convenience and safety, performance comparisons may vary compared to highly optimized C/C++ code.

As of 2025, support is focused on ESP32-class microcontrollers.