Interpreters are out aswell, they're never going to match the speed of a compiled language (Roto & wasmtime are compiled to machine code via cranelift).

There are fast-ish languages, like Lua, but my experiments indicate that for iocaine's use-case, neither LuaJIT nor LuaU provide any gains (they usually measured below Lua 5.4!) - my scripts are short, and don't live long, JIT doesn't help much there, as far as I can tell.

I'm willing to add new languages to iocaine, if they match or exceed the speed of Lua, but that's already stretching it. The only reason I have Lua support in iocaine is because of #Fennel. I desperately wanted a lisp. Even if I won't be using it myself, I wanted iocaine to support one. Lua, and thus Fennel, are considerably slower than Roto, but they run at an acceptable speed nevertheless.

Most languages I tried were waaay slower than Lua.

From nothing to running iocaine + Caddy with ai.robots.txt's robots.json and a few metrics as a starting point.

Contains #Roto, #Lua, and #Fennel - and a few tests too, for each.

I'm currently writing #Fennel examples, and this is delightful. I even managed to make the decide function even more beautiful than it was!

(local ruleset [is-in-ai-robots-txt?

default])

(fn decide [request]

(accumulate [outcome nil

_ f (ipairs ruleset)

&until (not= outcome nil)]

(f request)))

This is perfection.

I'm on a bit of a roll lately, and have released #iocaine version 2.4.0 just a few moments ago.

This does not bring that many significant changes as 2.3.0 did, but it does introduce #Lua and #Fennel as languages you can script its decision making with, on top of #Roto, which was introduced in 2.2.0.

While these languages run slower than Roto, they're still very fast, and are not going to be a bottleneck - they do provide a more familiar language to write the decision making in!

Oh, and metrics can now be persisted across restarts.

And because I give funny names to my structs, the one dealing with #Fennel is called ElegantWeapons.

After that, I'll try to figure something about how to support #Fennel better, natively. The current idea is to have it exposed as another scripting language, built as a wrapper around the Lua engine, with some additional setup at init time:

• Load the fennel compiler from somewhere
• Update fennel.path
• Run fennel.install()

I could embed the fennel compiler, it is small enough, and releases aren't frequent. So that's an option. I don't want to pull it into the sources, though, so I'd need a way to do grab it during build or something. That's a bit problematic, however.

So the next best thing I could come up with is:

[server.request-handler]

path = "/path/to/some/fennel/code"

language = fennel

options = {

compiler = "/path/to/fennel.lua"

}