Cat's Eye Technologies: New Developments

Note, this feed dates back to 2019. For older news items, please see the Archived News Items article.

Some long-overdue updates to Burro

Burro is a brainfuck-inspired programming language where the set of programs form a group (the algebraic structure from group theory); in particular, for every program there exists another program which, when concatenated to the first program, annihilates it.

Version 2.0 revision 2003.0225 of the Burro distribution has been released. There have been no changes to the language, but several other significant updates have been made. Notably,

Eqthy, a formalized language for proofs in equational logic

Eqthy is a formalized language for proofs whose design attempts to reconcile simplicity of implementation on a machine with human usability. Each line gives an equation which is derived from the equation on the previous line, using only the rules of equational logic along with any previously defined rules of inference or proved theorems.

This, the first release of the Eqthy distribution (Eqthy 0.1), includes a description of the language, a proof checker called eqthy written in Python 3, and a number of example proofs (including a proof of the Socks and Shoes theorem in group theory, and a simple proof in Propositional Algebra).

relwrite, a tool for relating strings to strings

Last year, like most years since 2013, Cat's Eye Technologies planned to produce something for NaNoGenMo. The year 2022 was, actually, the first year I entered and failed to complete anything. The reasons for this were simple, and probably not uncommon: my plans were too ambitious, and were difficult to scale back to something modest enough to be completable in one month. So it goes.

What I did produce, along the way, is a tool called relwrite. Given a grammar and an input string, relwrite will find a set of output strings that relate to the input strings, either by parsing the input to obtain a nonterminal, or by generating a new string of terminals, at the user's choice.

One thing that makes this interesting is its generality. The input grammar doesn't have to be context-free; it can be literally anywhere in the Chomsky hierarchy.

And this poses complications. relwrite can be instructed to perform a naive breadth-first search for all the outputs that the input could rewrite to. But since that is an infeasibly large space to traverse, it supports a more sophisticated beam search algorithm, to aggressively trim down the set of possible parses (or generations), to allow it to find at least one of a desired length.

Release of Samovar 0.5

A new version of the Samovar distribution has been released. While there are no changes to the Samovar language, the reference implementation (samovar, written in Python) has some significant updates.

Notably, alongside the existing stochastic generator (which just performs random walks through the event-space in the hopes of connecting the initial state of the scene to a satisfactory final event of the scene) version 0.5 of samovar supports two additional generation strategies:

Some mildly humorous examples resulting from applying these two strategies to chapters of The League of Extraordinarily Dull Gentlemen are presented in this gist: "The League of Efficiently Dull Gentlemen".

Lariat: A Total ADT for Proper Lambda Terms

Y'know what? Over the years, I've designed lots of strange small programming languages, but I never implemented the lambda calculus. Until now.

And I only did it as a test case for an abstract data type representing lambda terms.

And I spent quite some time working on said abstract data type, trying to make something that works, in my opinion, nicely. The result being something that is total, in the sense that all operations are always defined, and that represents only proper lambda terms -- improperly bound variables cannot be introduced.

And I'm not even entirely sure anymore why I wanted to formulate said abstract data type for lambda terms. I believe it may have had something to do with macros.

Even though I dislike macros, and avoid them like the plague in my own code.

Well, that's how much sense my life makes.

Anyway, Lariat.

Philomath: Write proofs in ANSI C

Ever had an urge to write that natural deduction proof you're working on directly in a classic systems programming language like ANSI C? Well, look no further! Philomath is an LCF-style theorem prover for propositional logic in a natural deduction system, written in ANSI C. Values of type struct theorem represent proved statements, while functions that take struct theorems as arguments and return a new struct theorem value, implement rules of inference. Your proof-program includes the header file theorem.h, which only exposes the declaration of struct theorem, and not its definition; in this way, you can be confident (in ANSI C) that any struct theorem your proof-program produces indeed represents a theorem with a valid proof, and not just something you made up. In ANSI C. Smashing, no?

Feedmark 0.13 and Falderal 0.14 released

Two releases of two of Cat's Eye Technologies' formats (and associated tools) have been made.

The latest version of Feedmark, a structured subset of Feedmark designed to support curation and newsfeeds, is now version 0.13.

The latest version of Falderal, a format for writing literate test suites for programming languages, is now version 0.14 "Jean Baptiste Point DuSable Lake Shore Drive". (Falderal versions are named after notable locations in the Chicagoland area.)

Both of these formats have tools written in Python, and these packages are both available on the Python Package Index, at Feedmark and Falderal respectively.

Recent updates to the ZOWIE distribution

This year, a typo was found in the specification of our esoteric programming language ZOWIE -- a language where every instruction, including the structured "repeat" loop, is memory-mapped. (Thanks Sgeo!)

From this we decided it would be ideal if there was a second implementation of the language -- the idea being, with three reference materials (the spec and two reference implementations) one could use a "majority rules" approach to divine the canonical behaviour.

(Three cheers for coding theory! Hip hip, hooray! Hip hip, hooray! Hoop hoop, hirray!)

To this end, we wrote a ZOWIE interpreter in Haskell, to go along with the one written in Python.

We considered using this new Haskell implementation as the basis for the online installation of ZOWIE, replacing the current Skulpt-based installation with it. That hasn't happened yet, though; I'm torn between getting rid of the Skulpt one because Skulpt is kind of goony and non-standard, and keeping the Skulpt one because Skulpt is kind of goony and non-standard.

Tandem interpreter installed online

Tandem, our esoteric programming language where string-rewriting rules form a Kleene algebra, has finally had an HTML installation for it established on Cat's Eye Technologies' website. You can try it in your web browser right here.

The Grammatical Rollercoaster that is Dissociated Parse

For NaNoGenMo this year, Cat's Eye Technologies developed a variation on the Dissociated Press algorithm. Instead of working on a sequential list of words as it conventionally does, it was adapted to work on parse trees instead. The result was dubbed Dissociated Parse, and the 50K-word novel The Lion, the Witches, and the Weird Road was generated using it, which you can read online here.

Vinegar, a semi-concatenative language

Vinegar is a new esolang from Cat's Eye Technologies, released in mid-November. It is a "semi-concatenative" language where every operation can fail.

"Semi-concatenative" is supposed to mean that there isn't just the usual implicit "concatenate" program-composing operator, there's also a second program-composing operator, "alternate" (notated explicitly by |).

This second operator is intended to gracefully handle the case where a program operation has failed -- which any of them can.

Lanthorn: `letrec` as syntactic sugar

Lovely language Lanthorn launches.

Look lucidly at its lexical lycanthropy — a leakproof lifting of letrec to let in lieu of lopsided letterbox loads.

A loquacious lucubration in laminar labour for lugubrious laity? It's likely!

Release of Castile version 0.4

After a long time lying fallow, a new version (0.4) of the programming language Castile has been released.

Mainly, I was disappointed that the C-language-generating backend of the compiler was left incomplete. So I completed it. Testing structs for equality was also unimplemented in several backends. So I completed that part of it too.

The language itself has few changes, primarily the tightening of some rules regarding comparing structs.

But significantly, the language project has been re-focused. The language is not quite as unremarkable as its documentation previously made it sound. Castile is a simple language with union types. The union types let it do a number of tricks, like being safe from null pointers, implementing enums, and taking a "Parse, don't validate" approach when programming.

A better experience on mobile, and DAM 0.2

The website has never exactly been "mobile-first" in its design. But we've recently taken some steps so that the experience on mobile is less bad. In particular, the gewgaws are much more mobile-friendly now. Many of them scale themselves down properly to the size of your device's screen. Others, such as A Non-Random Walk and Art Restoration Simulator, now function on mobile, when before they did not.

Incidentally, version 0.2 of DAM, the Document Awesome Model, has been released. Range controls now expose a method to set their value programmatically, and the project has a slightly more developed build system.

Version 0.3 of ellsync released

ellsync is an opinionated poka-yoke for rsync, for the primary purpose of maintaining a backup system.

Version 0.3 has been released, which, along with some cleanup of the internals, provides two more measures for quality assurance.

First, after rsync has completed, the system's sync command is run. So ellsync does not finish until all of the changes have been written to disk.

Second, a --thorough option has been added. This runs rsync in a mode where it thoroughly checks for differences between files, even if the source file's timestamp has not changed. This can detect files which have become corrupted, and also repair the backup file, if the original file has not been corrupted as well.

Version 0.8 of Robin released

A new version of Cat's Eye Technologies' excessively principled Scheme-like programming language Robin has been released.

This is a fairly major release for Robin, as there is a change of terminology: what were previously called "macros" are now called by the more obscure, but more accurate term "fexprs".

In Robin, both macros and functions are defined in terms of fexprs.

Fexprs also no longer get passed a self argument; instead, to achieve recursion, a recursive fexpr must be written. This is analogous to a recursive function.

The Robin Tutorial has also been significantly fleshed out. It aims to be a good overview of the language for programmers who are already somewhat familiar with Lisp or Scheme.

Tandem, an experimental rewriting language

We've designed and released the first version of Tandem, an experimental rewriting language where the rewrite rules form a Kleene algebra. The object being rewritten by a Tandem program is a collection of labelled stacks — a finite mapping from strings to strings. The strings are always rewritten at the left edge, so they are effectively stacks.

Writing finite automata, push-down automata, Turing machines, and other automata is quite natural in Tandem, because transition rules such as "In state 4, if the next character in the input is g, consume it and push $ onto the stack and go to state 9" translate quite straightforwardly to rewrite rules such as

Q4 → 9 & Ig… → … & K… → $…

tagfarm, an ultra-lightweight categorization system for arbitrary files

We've designed an ultra-lightweight system for categorizing arbitrary files in a filesystem and christened it tagfarm.

tagfarm associates each file in a file tree with zero or more tags. Each tag is implemented as a directory containing symbolic links to the files that have that tag. And that, along with a little script to add, remove, and repair tags after the files themselves may have moved, is basically all it is - hence "ultra-lightweight".

Web-based interpreters for Emmental and Mascarpone

We've made new minor releases of our self-modifying programming languages Emmental and Mascarpone.

We've modernized the build systems in both of these language distributions, and in the process we've enabled web-based interpreters to be built for these languages, by compiling their Haskell reference implementations to JavaScript using the Haste compiler.

And we've put those web-based interpreters online at, here (Emmental) and here (Mascarpone).

We've also placed the contents of the Mascarpone distribution in the public domain, to match the Emmental distribution.

Version 0.7 of Robin released

A new version of Cat's Eye Technologies' "excessively principled" Scheme-like programming language Robin has been released.

The highlight of this release is that it is now allowed to define a symbol after it has already been defined, which is understood as providing multiple semantically equivalent definitions for the symbol. An implementation of Robin is allowed to (but not required to) try to disprove that the given definitions are semantically equivalent, and indeed the reference implementation has a way to run property tests (written using QuickCheck) on all such multiple definitions, trying to find cases where their behaviours differ.

Version 0.6 of Robin released

A new version of Cat's Eye Technologies' "excessively principled" Scheme-like programming language Robin has been released.

The highlight of this release is that exceptions and exception handlers have been removed from the language. Conventional exception handlers are in essence dynamically scoped, and thus break referential transparency, while lexical exception handlers have limited usefulness. Exceptions have therefore been replaced by "abort values", which are the wrong type for almost all operations, and in this manner bubble up to the top level of evaluation just as an exception would. Referential transparency has thus been restored to the language.

Falderal, Feedmark, NaNoGenMo 2019, and Cosmos Boulders

Tying up some loose ends of 2019 before we move on to 2020.

Firstly, our Markdown-based formats Falderal and Feedmark had some new minor releases.

But more importantly, their Python implementations are now available as Python packages: Falderal on PyPI and Feedmark on PyPI.

But wait, that's not all! They're also available as Docker images on Docker Hub: catseye/falderal and catseye/feedmark.

Secondly, at the tail end of 2019 Cat's Eye Technologies participated in NaNoGenMo 2019 (we just can't seem to stay away from it) resulting in three generated novels: Anne of Green Garbles, The Insidiously Rainbow-Wigged Dr. Fu-Manchu, and The Epic of Goog-a-MESH.

During the first of those novels arose the somewhat surprising (to me) result that the intersection of a Markov chain and a regular grammar is another Markov chain — one which obeys the rules of the regular grammar. You can read all about it in this write-up, which includes some snazzy state transition diagrams as well.

Finally, Cosmos Boulders is an arcade-style game written in JavaScript using reducers and immutable data structures. It's not particularly original, but it's written in a purely function style. We hope to write a second version using Nested Modal Transducers for comparison.

Our third esolang of 2019: Oxcart

Back in February, when we announced Wanda, we did say there would be other esolangs this year. They haven't been the ones I thought they'd be, back then, but they're pretty squarely esolangs, I think. And this is the third one!

We present Oxcart, a purely concatenative language (in the sense of Equipage) which is based on composing functions written in continuation-passing style. Instead of functions which take states to states, the symbols of the language represent functions which take an extra argument, a continuation, that represents the future of the computation.

It's also installed online, so you can run Oxcart programs without leaving your web browser.

Carriage, Erratic Turtle Graphics, and DAM

Since 2012, our first "purely concatenative" language, Carriage, existed only in the form of an article on the esowiki.

It now has a real reference distribution, and it's also installed online, alongside its successors Equipage and Wagon, so you can run Carriage programs without leaving your web browser.

Elsewhere, we've also installed a gewgaw we concocted a little while ago (though not as long ago as Carriage), which we call Erratic Turtle Graphics.

It's possibly also worth mentioning that this gewgaws, and several other of our recent online installations, use a tiny Javascript library that we released this year, called DAM, to build their user interfaces. It replaces yoob.js's "element factory" library, and it's what we're switching to as we phase out yoob.js.

PL-{GOTO}, Robin, Equipage, and Wagon installations

As we mentioned in a previous news item, the Haste compiler allows us to easily create web-based installations for things implemented in Haskell.

And some things we've had a penchant for implementing in Haskell are programming languages of all stripes — experimental, esoteric, and didactic.

So, four more programming languages have come online; you can write programs in them and run them right in your web browser. It isn't a fantastic development environment, of course, but you can get a taste for what the language is like, without having to download or install anything.

Thus we present online installations for four languages we implemented in Haskell:

Our second esolang of 2019: Wagon

Back in February, we did say there would be other esolangs this year, so here we go with the second one!

We present Wagon, a purely concatenative language (in the sense of Equipage) which is "second-order concatenative": instead of functions which take states to states, the symbols of the language represent functions which take functions from states to states, to functions that take states to states.

Also, we have recently made a few updates to our probably-not-esoteric but-not-exactly-mainstream-either language Robin, bringing it up to 0.4. Mainly this involved cleaning up its specification.

Quylthulg, Pail, Flobnar, and Maze Clouds installations

Lots more updates to installations.

First, we have discovered that it is possible to use the Haste compiler to create web-based installations for little things we have implemented in Haskell, by adding only a small module to hook up the internals to some HTML5 controls.

Thus we present online installations for three languages we implemented in Haskell: Quylthulg (where goto's is allowed, but only inside data structures), Pail (if Lisp stands for LISt Processing, Pail stands for PAIr Language), and Flobnar (where Befunge went drinking on its 18th birthday and got really quite remarkably drunk).

Since we developed a little system for doing these with Haste, we can expect a few other of Cat's Eye Technologies Haskell implementations to have online interpreters in the near future.

Second, we finally put together a distribution for Maze Clouds (a simple generative technique to generate mazy, cloudy forms) containing implementations in both Python and Javascript, and we put the Javascript one online here: Maze Clouds

SixtyPical 0.19 released

Sometimes you go down a rabbit hole because it opens up under your feet. That's what it felt like this time, anyway; I hadn't thought about SixtyPical for months, and then suddenly I find myself rewriting half of the compiler's internals.

The big thing, I guess, is that I realized the language doesn't need separate buffer and table types; only let tables have more than 256 entries, but say only the first 256 can be accessed by index; and let pointers point into tables, and say that is how you access entries past the 256th. Then you can just get rid of buffer completely. Which is what I did.

And then it because fairly obvious that "which table is this pointer pointing into?" could be tracked in the analysis context just like all the other things we're tracking, and after some consideration I decided a lexically-scoped block for it would be nice, and so the language now has point ... into blocks.

Doing these introduced or revealed a bug whose root cause seemed to simply be that hand-rolling immutable objects in Python (or rather, objects that you would like to consistently pretend are immutable) is a pain in the neck. Addressing that problem triggered another wave of changes, wherein the internal representation of type information was refactored into a single context (the symbol table) shared amongst the phases of the compiler, in which namedtuples are stored. It was a lot of refactoring, but the massive test suite helped keep things together, and it was quite satisfying being able to delete the __hash__ methods from objects, knowing they would now be given appropriate ones under the hood. And that fixed the bug.

Finally, I thought the script was getting a bit grotty, so I incorporated the "load-and-go" mechanism into the main sixtypical script itself.

Cyclobots, Chzrxl, Wanda, Velo, and ILLGOL installations

Lots of updates to installations.

First, our little dynamical systems Cyclobots and Chzrxl have had their implementations re-fitted to use PixiJS. PixiJS uses WebGL for display when it is available, so these installations now have the potential for having much nicer visuals than the previous versions. It's only minimally leveraged at this point — you can select "Blurred" or "Noisy" visuals — but the potential is there, I tell you.

In the process of switching over to PixiJS, these two projects have been given their own reference distributions instead of residing in the HTML5-Gewgaws distribution alongside everything else.

You can see these in action here: Cyclobots and Chzrxl.

Second, two of our languages that are implemented in Lua, namely Wanda and Velo, have been made to run on a web page thanks to Fengari, an implementation of the Lua VM in Javascript.

So, you can try these out online here: Wanda and Velo.

Finally, a distribution of ILLGOL running under FreeDOS is now installed online, under v86, an emulator for IBM-compatible PC architecture in Javascript. (We actually built this distribution a while ago, but at the time, v86 wasn't able to run it correctly. Now it is. Kudos to all v86 contributors.)

You can try it out online here: ILLGOL.

Our first esolang of 2019: Wanda

We present Wanda, a Forth-like, "concatenative" programming language that's arguably not concatenative at all, nor even "stack-based", because it's based on a string-rewriting semantics.

Wanda was actually started in 2009, but never really got off the ground. But it never really went away, either, so here we are, ten years later.

Ah, also, are you slightly surprised, or even alarmed, to hear that this is only our first esolang of 2019? It's true, there will be others this year (weather permitting). But you'll have to wait for those. and other website improvements

As you might know, Cat's Eye Technologies hosts git repositories of its projects on GitHub. And as you might also know, several months back, GitHub was acquired by Microsoft.

We do not regard this, in itself, to be a problem. There's nothing GitHub-specific about git; it's a distributed protocol, and a git repository can be hosted basically anywhere. The GitHub-specific things that GitHub does offer are handy, but we've intentionally avoided relying too much on them. For instance, we've tried to describe planned features in TODO lists in the repo itself, instead of opening issues for them. And shall we point out that Microsoft is only one of several 800lb gorillas in the tech world these days, and perhaps it's not the one you should be the most worried about anymore?

Ah, but I'm editorializing. The point is, one can lessen one's dependency on GitHub very easily by hosting one's git repositories elsewhere, and that's just what we've done. Deploying an instance of klaus, we've set up You can browse repositories from it and clone from it and download zipfiles from it and everything. (The repositories we have on GitHub will stay on GitHub, too, so if you want to fork them on there or open issues or pull requests there, you can, still.)

We've also done a fair bit of maintenance on the website in conjunction with this.

First — many would say this is long overdue — it's all https now. Don't worry about changing any links; it's not required, http requests will simply redirect to https.

Second, we've released version 0.8 of Feedmark, and the website is using it in the backend to read Markdown files directly as Feedmark. This lets us do things like format it more nicely in templates.

Lastly, we've cleaned up the Retrocomputing article, in particular, moving the things that are dependencies (even if they are "retro dependencies") rather than projects to the Project Dependencies article.

SixtyPical 0.18 released

We've released the latest version of SixtyPical, our low-level 6502-like language with abstract analysis. In particular, how blocks are analyzed has been cleaned up. When two block diverge (such as in an if statement), they no longer need to keep the same values initialized; instead, the two contexts are merged afterwards — any location that is trashed in one block will continue to be trashed after both blocks. (And if that introduces a problem after both blocks, the analyzer will catch that problem there.) Also, a goto may appear at the end of any reasonable block, not solely at the end of a routine, so long as the initialization constraints all work out as declared. (The context at the goto must be compatible with the context at the end of the routine.)

Our hope is that these changes will pave the way for optimizations such as tail calls and dead code removal.

Older news items from this feed, dating back to 2007, can be found in the Archived News Items article.