CatJam 2026

Another year, another CatJam, this time I'm gonna try to keep a devlog. It won't be as tidy or consistent as my December Adventures, but thought it'd be fun to do.

July 11th

You are at the lastest entry.

Parser been implemented. Need to construct a runtime for Kibble. However, I got sidetracked documenting stuff about Scratch's runtime. Kibble is directly based on it, so I figured I should take a bit of time to look over Scratch as a programming language. Most people talk about Scratch the Product and Project not Scratch the Programming Language. So hopefully that article feels a bit different.

Ideas for tomorrow

Going biking tomorrow. Dunno what coding stuff will happen. I'm honestly procastinating. I've gotten stuck pondering Kibbles semantics since there isn't much to yak-shave for syntax.

July 7th

I've come up with an idea for a catlang. I want to try to combine together Gilded, Scratch, and Cognate.

The Gilded started life as MOLD's scripting language. But I eventually backed out of implementing it fully cause it was to much work for the langjam. The main idea I found interesting from it was how closures were handled. Gilded had you explicitly bind scopes to quotations. This meant quotations acted like objects and could even implement crude prototypes.

Scratch is an amusing system oriented around actors on a stage. It a strict binary of totally global shared state or totally local internal state. Additionally, it has no mechanism of addressing other objects directly. You can indirectly do it by handing objects an ID then dispatching an event, but no such thing as "pointers" or "references". Finally, it's completely event oriented. Even while loops will yield to the event pump.

However, one oversight is the lack of simple scenes. I think Scratch would benefit a lot if you could associate logic and entity to a state your program can be in. Instead you are kinda forced to awkward signal to all objects if they should or should be visible.

Finally, Cognate is an interesting catlang. It's main gimmick is 1) being prefixed 2) all lowercased text is a comment. Statements can share data between each other using a stack. It's commenting approach allows for you to turn code into literate prose. I'm usually adimant about postfix, but I felt like experimenting.

The net result is something kinda weird looking. I call it Kibble. Here's my current draft for what I'm yearning for:

Actors [
    :Helloer :Goodbyer
    :Worlder :Changer
] ;

Every :Tick for :Helloer  does [
    Say "Hello, "
] ;

Every :Tick for :Goodbyer does [
    Say "Goodbye, "
] ;

Every :Tick for :Worlder  does [
    Say "World!"
] ;

Every :Tick for :Changer  does [
    Currently ; Is :HelloWorld ; Then [
        Become :GoodbyeWorld ; Done ;
    ] ;

    Currently ; Is :GoodbyeWorld ; Then [
        Become :HelloWorld ; Done ;
    ] ;
] ;

Scenes [ :HelloWorld :GoodbyeWorld ] ;

When :Started is heard by :HelloWorld do [
    Create Helloer ;
    Create Worlder ;
    Create Changer ;
] ;

When :Started is heard by :GoodbyeWorld do [
    Create Goodbyer ;
    Create Worlder ;
    Create Changer ;
]

Enter HelloWorld ;

This is just kinda the general vibe I want. The idea is this language can be plugged in as a scripting layer and have events pummped into it which trigger things such as Every and When. It's going to be kinda Elm-like.

Ideas for tomorrow

I've got work. So, probably not much progress. May attempt a parser for Kibble. I'm still sorting out all the semantics of the system. The problem with catlangs is there is so little syntax you are immediately confronted with the horrors of semantics and what you want to say in a language.

July 4th

Okay, I didn't actually do anything for the jam. I just kinda clean up my website, added a bunch of pages. Prior to the jam starting I did spend a while cleaning up MOLD's text editor. However, I'm yearning for something I haven't fully conceptualized...

It's been to hot to go on any sort of walk, so ideas have been stale.

Ideas for tomorrow

Figure out the idea... :thonk: