Toit v2.0.0

18 days ago (toit.io)

The wikipedia page https://en.wikipedia.org/wiki/Toit is short but still gives a lot of context.

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

      1 reply →

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.

  add a/int b/int -> int:
    return a + b
  
  main:
    print (add 2 3)  // Prints 5.

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

      1 reply →

   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.

The people behind Toit are the original people behind the V8 VM in Chrome. They know their stuff.

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.

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 wish any product new release announcement include a brief introduction about the product itself...

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

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.

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?

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 `--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 "=".

      1 reply →

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.