Research Overview

Formal talk abstracts, blogs, and marketing representations for the Keikaku programming language.

Talks

Keikaku: Designing a Language Where Keywords Express Intent

Programming languages mostly agree on their control-flow vocabulary, which is portable but semantically neutral. This talk presents Keikaku, a dynamic interpreted language that treats surface vocabulary as a first-class design surface, organizing its keywords around a single planning theme (foresee, cycle, protocol, sequence, transmit, disrupt, anomaly) while keeping conventional semantics underneath. We show how a themed-but-regular vocabulary stays learnable, then dig into the parts that are not superficial: a coroutine-grade generator system with delegation, bidirectional transmit/receive communication, and exception injection via disrupt; an async/await layer built economically on the same suspendable generator frames; and a structured error model that frames exceptions as anticipated deviations. We close with the implementation (an ANTLR grammar over a C interpreter) and the cross-platform packaging (Arch, Debian, and Linux-to-Windows cross-compilation) that ship it as an installable language with a REPL. The talk is aimed at language designers and interpreter implementers.

Publications & Articles

Keikaku: a language where the keywords are the point

Most scripting languages share the same control-flow vocabulary: if, for, while, def, yield. Familiar, but neutral. Keikaku (計画, “plan”) takes the opposite bet: the surface vocabulary should express intent and carry a theme. So conditionals are foresee, loops are cycle, functions are protocol, generators are sequence, and errors are anticipated deviations you attempt and recover from.

The trick is that the theme is regular, and the semantics underneath are conventional, so once you learn the keyword map you can read any Keikaku program. And the features are not toys. The generator system is coroutine-grade: delegate for yield-from, transmit/receive for passing values both ways into a running generator, and disrupt to inject an exception into a suspended generator that an in-generator attempt/recover can catch and survive. The async layer (async protocol, await, resolve, defer, sleep) is built on that same suspendable-frame machinery.

Under the hood it’s an ANTLR grammar with a C interpreter, and it ships as an installable language: Arch via makepkg, Debian/Ubuntu/Kali via an install script, Windows cross-compiled from Linux to a .exe, or a universal CMake build. Run keikaku for a REPL or keikaku script.kei to run a file. MIT licensed.

Language Overview Blurb

Keikaku (計画) is a dynamic, interpreted programming language for expressive control flow and structured state management. It features a plan-themed keyword vocabulary, coroutine-grade generators (delegation, bidirectional communication, exception injection), async/await with promises and scheduling primitives, and an attempt/recover error model. Implemented with ANTLR and C, it runs as a REPL or executes .kei files, and installs on Arch, Debian/Ubuntu/Kali, and Windows, or builds universally with CMake. MIT licensed.