>In February 2019, the company raised DKK 23 million (approximately US$3.5 million) in seed funding from Swedish venture capital firm Creandum.[4] Early versions required cloud registration to deploy code to devices.[5]
> The commercial cloud offering was later discontinued. Development of fleet-management tooling continued through an open-source project called Artemis, built on Supabase and PostgreSQL, which users self-host.[8]
> According to Denmark's Central Business Register, Toitware ApS ceased operating in 2024.[9] Development of the language continues as a community project on GitHub.
Seems unlikely to be a bait and switch at this point
There are systems programming languages since JOVIAL in 1958, enough of them to chose from if C had never existed, and what syntaxes would be favoured instead.
It's an interesting thought experiment, but honestly for all its flaws, C did have one large advantage regarding syntax: braces. Even if C had never been invented, at some point people would have noticed that Fortran/Pascal/Whatever style BEGIN ... END blocks are annoying and just a waste of tokens.
I rather like WebAssembly for this use-case. You don't necessarily need a new language, you need a Wasm runtime targeted at embedded devices, like WAMR [1], which even has a AOT compiled mode.
Toit is a language for writing scripts on your computer and applications on your ESP32. A readable syntax, an efficient runtime, and tools that work together.
Free and open source. Maintained by volunteers.
Think of it as a runtime + scheduler that you deploy programs to ESP32 devices. It gives you the ability to run multiple programs simultaneously (with isolation) and remote updates. The language compiles to bytecode; the developers have lots of experience writing VMs for constrained devices; see https://www.theregister.com/software/2004/07/27/forgotten-la... for something that predates V8 and Dart.
We looked at these when we started. The problem with them is that they weren't designed with constrained resources in mind and it shows. For example, objects are hash tables and method calls are thus expensive. An obligatory top level execution makes startup slow, ...
If you have a bigger machine you can optimize some of this (V8), but these optimizations typically need memory and/or a JIT. (And Python struggles to optimize even on stronger machines).
By starting from scratch (with what we learned from V8 and Dart) you can design something that feels similar but is much cleaner and faster to run.
This seems very interesting. It almost looks/feels like Pythonic Go.
There's already another syntax example in the thread, but I want to point out the weirdest syntax I've seen yet: positional arguments look like posix command arguments:
greet name/string="World" --greeting/string="Hello" -> string:
return "$greeting $name"
main:
print (greet) // Prints Hello World.
print (greet "Ada" --greeting="Hi") // Prints Hi Ada.
Feedback for the doc writers on this then, the phrase in my head of "the name of the named argument is greeting, name is not named" is a little awkward.
They should write this prominently on their website. It doesn’t radiate trustworthiness/substance/reputation. Also performance and resource requirements should be prominent when targets are MCUs.
I may be misremembering, but my recollection is that Dart was written off in large part because of Google. Distrust with them was already high as they were abusing their dominance with things like AMP, and people felt it was a bad idea to give them even more control over the web.
Yeah, but Lars Bak isn't exactly a nobody when it comes to computer science either. Although I guess Bak is more famous for the implementation of programming languages than their design.
Aside: funny how Dart and TS both have Danish creators.
TypeScript is however a plain JavaScript linter, you remove the type annotations and have JavaScript, which was a consequence of the learnings versus other JavaScript wannabe replacements.
Also why after namespaces and enums, the team never introduced any other feature that wasn't also part of JavaScript standardisation process, and has since then discouraged their use.
A fundamental choice you have to make with a new programming language is how compatible you want it to be with existing languages and their ecosystems. Hewing closely to another language allows you to reuse and build on top of all of the code already written in that language. But it also means that you can be forced to recapitulate features from that language that aren't great. Building a new language and ecosystem from scratch lets you make a clean break from those but at the very large expense of having to build a universe from scratch.
TypeScript took the former approach. All of the world's existing JavaScript code is TypeScript too. You can freely interoperate between TypeScript and JavaScript, keep using your existing JavaScript libraries, and incrementally migrate your JS codebase to TS one file at a time.
At the same time, TypeScript inherits much of the dumb stuff about JavaScript. No real integer type, funny scoping semantics (though strict mode mostly addresses this), extreme dynamism that is hard to fit into static types. The latter is particularly important. TypeScript's type system is deliberately not sound in order to be able to mostly statically type JavaScript while allowing many of the weird and complex design patterns from that language. That in turn means that even fully typed TypeScript programs don't get the fully performance benefits of static types. That's the main reason that the TypeScript compiler itself is no longer written in TypeScript: JS is simply too slow because of dynamic typing.
Dart took a much larger step away from JavaScript. It has its own object model and runtime semantics. With Dart 2.0, it has a fully sound static type system and in 2.12 we shipped sound handling of null. Because these static semantics are fully sound, the compiler can take advantage of types to generate smaller, faster code. Performance is complex, but Dart's runtime performance is in the same bucket as Java and C#, which is about as good as a GC language can get.
The cost is that migrating an existing web application to Dart is pretty much a rewrite. It was really hard for us to get any real traction until Flutter came out. With Flutter, users are already accepting that they are writing a new app for that framework, so the hop to a new language was more manageable.
I don't know how AI affects this calculus. AI can make it much faster to automatically migrate a program from one language to another. But I think it also makes human users more conservative about which language they use. Since they aren't writing as much of the code anyway, they may have less incentive to care about using a "better" language.
I agree completely that Hejlsberg is a star and very tough to compete with. I've always thought of programming languages more as offering different ways to solve problems and less about one trying to win at the expense of another. I don't want Dart to beat TypeScript, I just want Dart to be the best it can be for what it is.
Very happy to hear that! I don't work in embedded but really like the language design of Toit. Hope it'll get a second chance, it feels like it flew under the radar a bit when it came out.
After Dart, where we "had to" use familiar syntax (JavaScript), we experimented with less-noisy syntax for Toit. We removed everything that wasn't necessary first. Over time we added some parts (like `extends`, `implements`, ...) back, but we got used to the non-parens calls (similar to shell or Caml) and like it now. To me, every other language feels cluttered and noisy.
Wrt performance: depending on the program/benchmark Toit is sometimes 10x faster than MicroPython. For small loops that just do some arithmetic it's less noticeable, but real programs with method-calls benefit a lot from the static class definitions.
Even I (as a sort of grudging cynic) now find myself thinking in these terms:
Is this a language that an LLM can write well?
Especially a small LLM, given the scripting and friendly IoT focus, where it might be useful for a smaller model in a home assistant to be able to write in it.
A packageable scripting language with fewer footguns that has LLM-friendly features feels like it probably has a place in the world.
But my own experience so far suggests that smaller LLMs in particular do better with simpler languages with obvious flow of control and less cleverness like metaprogramming.
LLMs have not been trained on Toit code as much as they have on Python or JS. No question about that. Without the Toit skills (https://github.com/toitlang/ai-instructions) LLMs used to be really bad. (They might be better now, but I never bothered to remove the skill files). From that point of view, Toit isn't a good choice.
On the other hand, Toit provides containers and a fast refresh-cycle. Both are godsends for AI agents: the containers make it so that the agent doesn't accidentally bring down the whole system when there is a bug, and the refresh cycle makes iterating on programs much faster. (Something I find agents to be really good at).
Fwiw, there isn't any clever metaprogramming in Toit.
Thank you for your reply — I think it sounds like you're in a good place here.
I still definitely wish this wasn't something we had to care about still, but for a while at least I suspect it is.
I am a small/open-weights LLM proponent, really, so at some point I will test this a bit more, because I tend to use LLMs close to bare-metal where prompts and skills are concerned, due to limited context. (In general I think post-training of smaller coding-oriented models like Muse Glimmer and Qwen has made long system prompts and extensive skill files far less significantly important)
Muse Glimmer seems to have some knowledge of Toit without searching the web.
e.g. I asked it: "Could you write an embedded webserver that blinks the LED the number of times specified in a GET query string parameter?"
And what it wrote without access to documentation appears to be plausible (from what its human overlord can see from the documentation at least).
I have used toit in a lot of my projects. It is a really nice language and so much cleaner than all the alternatives I have tried (Arduino, Python, Lua).
The tools just work and I got used to the language really quickly.
I did hate that it was bytecode. It just felt wrong to run bytecode on an ESP32. OTOH it just works, and I have never noticed any performance problems.
My latest project is a controller for a slave-clock: https://gitlab.com/close2/nebenuhr-toit
(There is also a Garmin repository that allows me to control the clock using my Garmin watch.)
Full disclosure: I had to use toit (floitsch is my brother), but it really is a nice language and development environment.
I can tell you that he does not have a Dutch accent. And the guy that played a Dutch guy was talking German. Source: I'm Dutch and also understand German.
As a Dutch guy... I'll allow it, but only if y'all admit that the Danish language is at least as silly as Dutch is (must be something about being a flat country next to the North Sea)
I think "toy language" isn't really fair. Toit has been developed for 7 years, some of which with multiple engineers working on it full time. (The blog post says 4 years, but that's just for the v2.0.0 development).
Toit doesn't have a lot of users, but it is used in production (for example by Consibio) and is definitely developed for production environments.
Is there some kind of an advertising blurb for why you’d want to use Toit, especially for scripting? I think the only thing I saw was “a readable language”, but I’d probably consider Python more readable than it judging from the examples.
A few more bullet points to encourage readers to have a look at Toit:
- Faster than Python. Depending on the benchmark up to x10.
- Can be compiled to executables. Currently `-o` just takes an interpreter and attaches the bytecodes, but Kasper also started experimenting with native output.
- Cleaner base. Objects aren't just hashtables. This can be seen as a downside as well (making the language less flexible), but in my book it's a win.
The wikipedia page https://en.wikipedia.org/wiki/Toit is short but still gives a lot of context.
Just a joking side note: switch n to t in the URL and you get article for food in Estonian: https://et.wikipedia.org/wiki/Toit
>In February 2019, the company raised DKK 23 million (approximately US$3.5 million) in seed funding from Swedish venture capital firm Creandum.[4] Early versions required cloud registration to deploy code to devices.[5]
DNS blackhole the domain and run.
> The commercial cloud offering was later discontinued. Development of fleet-management tooling continued through an open-source project called Artemis, built on Supabase and PostgreSQL, which users self-host.[8]
> According to Denmark's Central Business Register, Toitware ApS ceased operating in 2024.[9] Development of the language continues as a community project on GitHub.
Seems unlikely to be a bait and switch at this point
whoops, black and white thinking burns me once more.
Here's a beginner tutorial for the language: https://docs.toit.io/language/toitversus
Nice syntax. It looks like how we'd design programming if C had never existed.
There are systems programming languages since JOVIAL in 1958, enough of them to chose from if C had never existed, and what syntaxes would be favoured instead.
It's an interesting thought experiment, but honestly for all its flaws, C did have one large advantage regarding syntax: braces. Even if C had never been invented, at some point people would have noticed that Fortran/Pascal/Whatever style BEGIN ... END blocks are annoying and just a waste of tokens.
I rather like WebAssembly for this use-case. You don't necessarily need a new language, you need a Wasm runtime targeted at embedded devices, like WAMR [1], which even has a AOT compiled mode.
[1]: https://github.com/wasm-micro-runtime/wasm-micro-runtime
Even after reading that (and more of the homepage) I have no idea what this is.
Think of it as a runtime + scheduler that you deploy programs to ESP32 devices. It gives you the ability to run multiple programs simultaneously (with isolation) and remote updates. The language compiles to bytecode; the developers have lots of experience writing VMs for constrained devices; see https://www.theregister.com/software/2004/07/27/forgotten-la... for something that predates V8 and Dart.
You get almost all of that with the more common language options too (MicroPython, NodeMCU/Lua, Espruino/JS). What makes this custom language better?
We looked at these when we started. The problem with them is that they weren't designed with constrained resources in mind and it shows. For example, objects are hash tables and method calls are thus expensive. An obligatory top level execution makes startup slow, ...
If you have a bigger machine you can optimize some of this (V8), but these optimizations typically need memory and/or a JIT. (And Python struggles to optimize even on stronger machines).
By starting from scratch (with what we learned from V8 and Dart) you can design something that feels similar but is much cleaner and faster to run.
Tangent: what an appropriate username :)
This seems very interesting. It almost looks/feels like Pythonic Go.
There's already another syntax example in the thread, but I want to point out the weirdest syntax I've seen yet: positional arguments look like posix command arguments:
Arguments like --greeting are the named arguments:
https://docs.toit.io/language/beginner/lists-and-functions/#...
The name argument is positional here.
Feedback for the doc writers on this then, the phrase in my head of "the name of the named argument is greeting, name is not named" is a little awkward.
:)
It’s probably fine once you’re used to it, but I’m not sure that embedded development is the place to innovate on function call syntax.
Then again, nowadays, it’s not like you have to write code yourself.
The people behind Toit are the original people behind the V8 VM in Chrome. They know their stuff.
They should write this prominently on their website. It doesn’t radiate trustworthiness/substance/reputation. Also performance and resource requirements should be prominent when targets are MCUs.
Also co-founding Dart. They definitely know their stuff.
Dart should have enjoyed the popularity that TypeScript received. Tough to compete with Hejlsberg though.
I may be misremembering, but my recollection is that Dart was written off in large part because of Google. Distrust with them was already high as they were abusing their dominance with things like AMP, and people felt it was a bad idea to give them even more control over the web.
It also required Dartium, its Chrome based VM, and Chrome team eventually did not want to ship it any longer.
Yeah, but Lars Bak isn't exactly a nobody when it comes to computer science either. Although I guess Bak is more famous for the implementation of programming languages than their design.
Aside: funny how Dart and TS both have Danish creators.
https://en.wikipedia.org/wiki/Anders_Hejlsberg
https://en.wikipedia.org/wiki/Lars_Bak_(computer_programmer)
Google politics, Dart is only around thanks to AdWords team, and Flutter.
Jetpack Compose was created by Android team exactly as counter reaction to Flutter.
Go got lucky with their internal advocacy, and the push to rewrite Kubernetes from Java into Go.
Google isn't exactly known for great programming language design, contrary to runtime implementations.
TypeScript is however a plain JavaScript linter, you remove the type annotations and have JavaScript, which was a consequence of the learnings versus other JavaScript wannabe replacements.
Also why after namespaces and enums, the team never introduced any other feature that wasn't also part of JavaScript standardisation process, and has since then discouraged their use.
I work on Dart.
A fundamental choice you have to make with a new programming language is how compatible you want it to be with existing languages and their ecosystems. Hewing closely to another language allows you to reuse and build on top of all of the code already written in that language. But it also means that you can be forced to recapitulate features from that language that aren't great. Building a new language and ecosystem from scratch lets you make a clean break from those but at the very large expense of having to build a universe from scratch.
TypeScript took the former approach. All of the world's existing JavaScript code is TypeScript too. You can freely interoperate between TypeScript and JavaScript, keep using your existing JavaScript libraries, and incrementally migrate your JS codebase to TS one file at a time.
At the same time, TypeScript inherits much of the dumb stuff about JavaScript. No real integer type, funny scoping semantics (though strict mode mostly addresses this), extreme dynamism that is hard to fit into static types. The latter is particularly important. TypeScript's type system is deliberately not sound in order to be able to mostly statically type JavaScript while allowing many of the weird and complex design patterns from that language. That in turn means that even fully typed TypeScript programs don't get the fully performance benefits of static types. That's the main reason that the TypeScript compiler itself is no longer written in TypeScript: JS is simply too slow because of dynamic typing.
Dart took a much larger step away from JavaScript. It has its own object model and runtime semantics. With Dart 2.0, it has a fully sound static type system and in 2.12 we shipped sound handling of null. Because these static semantics are fully sound, the compiler can take advantage of types to generate smaller, faster code. Performance is complex, but Dart's runtime performance is in the same bucket as Java and C#, which is about as good as a GC language can get.
The cost is that migrating an existing web application to Dart is pretty much a rewrite. It was really hard for us to get any real traction until Flutter came out. With Flutter, users are already accepting that they are writing a new app for that framework, so the hop to a new language was more manageable.
I don't know how AI affects this calculus. AI can make it much faster to automatically migrate a program from one language to another. But I think it also makes human users more conservative about which language they use. Since they aren't writing as much of the code anyway, they may have less incentive to care about using a "better" language.
I agree completely that Hejlsberg is a star and very tough to compete with. I've always thought of programming languages more as offering different ways to solve problems and less about one trying to win at the expense of another. I don't want Dart to beat TypeScript, I just want Dart to be the best it can be for what it is.
Dart v1.0, they had nothing to do with Dart v2.0, and the change in language semantics was the main reason folks like Gilad Bracha left the team.
What did they not like about the change in language semantics?
Likely the focus on AOT and the sound, static type system to make that work well.
Those were it's creators, are they still involved after the company folded?
Because if not, that might explain the lack of marketing around it.
Kasper and I are still working on it.
Very happy to hear that! I don't work in embedded but really like the language design of Toit. Hope it'll get a second chance, it feels like it flew under the radar a bit when it came out.
How did you came up with this strange syntax? Why not use a Python like one which is already known?
How about performance compared to compiled MicroPython (viper)?
After Dart, where we "had to" use familiar syntax (JavaScript), we experimented with less-noisy syntax for Toit. We removed everything that wasn't necessary first. Over time we added some parts (like `extends`, `implements`, ...) back, but we got used to the non-parens calls (similar to shell or Caml) and like it now. To me, every other language feels cluttered and noisy.
Wrt performance: depending on the program/benchmark Toit is sometimes 10x faster than MicroPython. For small loops that just do some arithmetic it's less noticeable, but real programs with method-calls benefit a lot from the static class definitions.
Even I (as a sort of grudging cynic) now find myself thinking in these terms:
Is this a language that an LLM can write well?
Especially a small LLM, given the scripting and friendly IoT focus, where it might be useful for a smaller model in a home assistant to be able to write in it.
A packageable scripting language with fewer footguns that has LLM-friendly features feels like it probably has a place in the world.
But my own experience so far suggests that smaller LLMs in particular do better with simpler languages with obvious flow of control and less cleverness like metaprogramming.
It's a good point.
LLMs have not been trained on Toit code as much as they have on Python or JS. No question about that. Without the Toit skills (https://github.com/toitlang/ai-instructions) LLMs used to be really bad. (They might be better now, but I never bothered to remove the skill files). From that point of view, Toit isn't a good choice.
On the other hand, Toit provides containers and a fast refresh-cycle. Both are godsends for AI agents: the containers make it so that the agent doesn't accidentally bring down the whole system when there is a bug, and the refresh cycle makes iterating on programs much faster. (Something I find agents to be really good at).
Fwiw, there isn't any clever metaprogramming in Toit.
Thank you for your reply — I think it sounds like you're in a good place here.
I still definitely wish this wasn't something we had to care about still, but for a while at least I suspect it is.
I am a small/open-weights LLM proponent, really, so at some point I will test this a bit more, because I tend to use LLMs close to bare-metal where prompts and skills are concerned, due to limited context. (In general I think post-training of smaller coding-oriented models like Muse Glimmer and Qwen has made long system prompts and extensive skill files far less significantly important)
Muse Glimmer seems to have some knowledge of Toit without searching the web.
e.g. I asked it: "Could you write an embedded webserver that blinks the LED the number of times specified in a GET query string parameter?"
And what it wrote without access to documentation appears to be plausible (from what its human overlord can see from the documentation at least).
I wish any product new release announcement include a brief introduction about the product itself...
I have used toit in a lot of my projects. It is a really nice language and so much cleaner than all the alternatives I have tried (Arduino, Python, Lua).
The tools just work and I got used to the language really quickly.
I did hate that it was bytecode. It just felt wrong to run bytecode on an ESP32. OTOH it just works, and I have never noticed any performance problems.
My latest project is a controller for a slave-clock: https://gitlab.com/close2/nebenuhr-toit (There is also a Garmin repository that allows me to control the clock using my Garmin watch.)
Full disclosure: I had to use toit (floitsch is my brother), but it really is a nice language and development environment.
[Edit: typos..]
I just started working on a compile-to-native approach you might appreciate :)
So (obvious question) how hard was it working using one hand as your brother was forcing your other one?
You get surprisingly good at typing with one hand after a while. ;)
Looks interesting! I can't tell really from the docs the untended use case though. It says "scripts", but also " applications".
Most importantly though (/s), is this toit as in "roof" in French, toit as in "to it", or otherwise?
It's from Austin Powers.
"toit like a tiger"
https://youtu.be/gu31VyXlTzo
Ahaha! I'd been thinking it was pronounced as in French (a bit like "twah") when I should be saying it in Mike Myer's super authentic Dutch accent!
I can tell you that he does not have a Dutch accent. And the guy that played a Dutch guy was talking German. Source: I'm Dutch and also understand German.
now we're talking.
As a Dutch guy... I'll allow it, but only if y'all admit that the Danish language is at least as silly as Dutch is (must be something about being a flat country next to the North Sea)
Looks quite nice
Who is using this? The company originally behind it has shut down
No one, it's just a toy language
I think "toy language" isn't really fair. Toit has been developed for 7 years, some of which with multiple engineers working on it full time. (The blog post says 4 years, but that's just for the v2.0.0 development).
Toit doesn't have a lot of users, but it is used in production (for example by Consibio) and is definitely developed for production environments.
Oh, good—I've been looking for a Round one for years.
Is there some kind of an advertising blurb for why you’d want to use Toit, especially for scripting? I think the only thing I saw was “a readable language”, but I’d probably consider Python more readable than it judging from the examples.
Good luck running (micro)python on an ESP32.
Lua exists :)
A few more bullet points to encourage readers to have a look at Toit:
- Faster than Python. Depending on the benchmark up to x10.
- Can be compiled to executables. Currently `-o` just takes an interpreter and attaches the bytecodes, but Kasper also started experimenting with native output.
- Cleaner base. Objects aren't just hashtables. This can be seen as a downside as well (making the language less flexible), but in my book it's a win.
- The `--named=value` syntax is just a winner :)
> The `--named=value` syntax is just a winner
The "--" seems so unnecessary though. Wouldn't "name=" be sufficient to signal a named parameter? Or maybe Toit has expressions that use "=".
We probably could have made it work without the `--`. Coming from Posix, the `--` feels natural, and it also allows for code completion.
The last thing this planet needs a new programming language