Aiki reaches recursive self-interpretation
3 points by decuser
3 points by decuser
Aiki is a small experimental programming language implemented in Go. This update covers the work since the first public alpha, including grammar-derived tooling, language services, an independent Aiki-written interpreter, recursive self-interpretation, and profiler calibration.
I apologise if this is not the case, but the writing style feels like it was either llm-generated from notes or llm-written and then edited down... either way, it's quite hard to read :(
There could be be something interesting about Aiki, but if so the communication's lacking. This kind of session-dump stuff is really only meaningful to the person who generated it, because they've got the other half of the context in their head.
Hardly. It's serious and if serious is dismissed as llm slop, then so be it. Do you have a substantive point about the language or are you just trolling?
I'm not trolling, just trying to alert you to a failure mode of technical communication. If the post was in fact hand-written, then any failure of comprehension is on me.
Ha! Fair. The AI issue is a sensitive one. It's very difficult to distinguish between constitutive use vs erosive. The AI disclosure is very clear about the boundary, in the project. A post and two documents might be of particular interest:
The alpha announcement itself: https://decuser.github.io/posts/aiki-alpha-release/
This is Aiki: https://decuser.github.io/assets/pdf/aiki/this-is-aiki-a1.pdf
The language report: https://decuser.github.io/assets/pdf/aiki/report-aiki-a1.pdf
I'll be honest, I tried to put in the effort by reading your other blog post about the language and the Github page of the project, but still don't get the core idea. What's the sales pitch of the language?
To your pitch question...
Most languages accumulate implicit behavior that can't be observed from the language surface: hidden numeric coercion, shared mutable state across concurrent boundaries, syntax that exists in the parser but not in any declarable artifact. Aiki is an experiment in ruthlessly eliminating those gaps. The grammar is an executable EBNF that mechanically checks its own coverage. Arithmetic is exact rationals. There are no silent float semantics. Concurrency is isolated spawn with no shared mutation. The semantic profiler counts Aiki-level operations, not Go-level ones. The point isn't to be a production language. it's to find out what happens when you refuse to let the implementation hide anything from the language surface.
It's not a toy language. It's a research language. The point is that the ebnfx drives the language, it's built on a very constrained set of types and it's inspectable at the semantic boundary. If you're looking for the next killer language this isn't it :).