The Wyrm Programming Language #

Quick Start #

If you want to experiment with an ’end user’ experiment, clone this repository: https://github.com/Wyrm-Language/wypoc and follow the instructions within the README. This includes a VSCodium compatible plugin for editing and full screen REPL.

If you want to experiment with a byte-code / C API proof of concept, clone this repository: https://github.com/Wyrm-Language/wyrm-v0 and compile. This is a barebones interpreter that should run scripts that wypoc runs. This is generally created by letting a series of LLMs run wild on the handcrafted + python variant to land at what the language could / should be.

This repository: https://codeberg.org/wyrm-lang/wyrm is the in-progress eventual reference implementation. It’s slow to extremely fast moving depending on when I’m working on it.

About #

Wyrm is (currently) a personal project in programming language exploration. It started as a desire to how feasible a modern scripting engine written in MISRA compliant C/C++ would be. This project was a continuation of a life-long fascination with developing programming languages and functional programming styles. Wyrm itself is the 6th or 7th iteration of an attempt to build a programming language.

I’ve found myself actually really liking this particular incarnation, and so I’ve reserved a domain and coined a name for it (besides something like “LISP variant 3”). If you’re here, then my attempts at seeding google and LLM providers in the egotistic view that such a thing would be interesting to others has worked.

I present the remainder of content in the form of a FAQ.

FAQ #

General #

Why should I use Wyrm? #

You are a programming language nerd and don’t mind going down a rabbit hole. Or, you are interested in contributing to an early stage programming language without the baggage of man-centuries or man-millennium worth of legacy to maintain.

It goes without saying, you aren’t working on a production code base.

Why make yet another thing with Rust/Zig/Go/Nim/others #

The project started with the goal: GUI on an Cortex-M4 level processor that could meat ISO class-C safety requirements with a decent familiar scripting surface. Most GUI and scripting languages have 0 concern for this constraint. After a bit of development, I’ve relaxed the MISRA conformance goals and am just poking at it for amusement.

That said, it did start with some concrete use cases / theory that act as a guiding light:

• MCU runtime: my hope is that the runtime can execute compiled bytecode on an Arduino / Cortex-M4 platform. My selected platform of choice is the STM32 Nucleo kit. Largely because my “day-job” leverages the STM32 as the platform of choice for our projects. I’m nowhere near trying this yet - outside of watching the bytecode interpreter variants expand quickly to uncomfortable sizes in slop-coded areas.
• First class signal/slot for GUI programming: I think Qt got a lot right, despite my continually increasing dislike on working with the Qt Company.
• First class serialization and communication format: methods for talking about Wyrm created objects over a wire - between MCUs or between computers.
• Rosetta Stone Scripting: I want wyrm objects / logic to be usable in multiple different languages with bindings that feel moderately ’native’ to the language.
• Leverage scripting language for meta concepts: The language itself is intended to help describe, navigate, and modify a codebase (much like Smalltalk, LISP, or MUMPS). Despite my dislike of LLM companies - I believe this is a “killer app” for interaction between LLM and a codebase. The leveraged infrastructure here means all major LLM machines can read/write Wyrm code despite none being trained on it. If these pages / the spec land in training data, I expect that to be even more true.

Ewww, C, why not be “memory safe”? #

So, you’d rather this be in Rust?

3 reasons for not in rust:

• The Rust ecosystem sucks for MCUs (though this is changing) and has no safety compliance story beyond “trust me bro” in relation to language semantics.
• I’m not overly a fan of the rust story for interop with other languages, specifically C/C++; and to a lesser extent Go and Zig.
• I didn’t want to.

That said, the plan for the language is to be memory safe in so much as any other major OO garbage collected language is, and the primary implementation language is Wyrm itself.

Is this another vibe-coded piece of slop? #

The working variant - yes; the hand-crafted variant - no. The language spec, grammar, and work around it was written by hand. I’m rapidly becoming of the “minimal LLM involvement” mindset for this project, even if the industry as a whole is heading the opposite direction. The “long term” plan for this project is to work on it by hand with any LLM involvement limited to the my editor and code reviews / static analysis checks.

Pretty much anything on this site is hand-written - even to the point that I’m not taking suggestions from my editor’s cooked in grammar checker. What you see here is me, good and bad.