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.

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.

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)

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.

Because if not, that might explain the lack of marketing around it.

Nice syntax. It looks like how we'd design programming if C had never existed.

DNS blackhole the domain and run.

> 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

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.

Most importantly though (/s), is this toit as in "roof" in French, toit as in "to it", or otherwise?

"toit like a tiger"

https://youtu.be/gu31VyXlTzo

- 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 "--" seems so unnecessary though. Wouldn't "name=" be sufficient to signal a named parameter? Or maybe Toit has expressions that use "=".

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.

https://docs.toit.io/language/beginner/lists-and-functions/#...

The name argument is positional here.

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.)

Disclaimer: I had to use toit (floitsch is my brother), but it really is a nice language and development environment.

[Edit: typos..]

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 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.

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.

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 enthusiast 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 (the model that happens to be running right now on my desk!) 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).