A language designed around the idea of data mutation. Like, just doing data mutation. No functions, no stack, just here’s some data and here’s how it changes. It’s very similar to imperative languages as you might guess, but it basically removes functions from the main data path and simplifies everything which leads to some weird syntax and features.

There are still functions in some ways via a trait system kind of like Rust (also where and polymorphism appears), but it’s not quite the same.

I don’t really know exactly how to explain it beyond that, so here’s a snippet:

[Import]
std

[Data]
a :: Int = 4
b :: Int = 5
a_str :: &Char = []

[Mut]
std.out write "The sum of 4 and 6 is "
b += 1
a += b
a_str alloc_num_str a
std.out write a_str

Not that += here is not equivalent to a = a + b, but rather += is the name of a Numeric trait procedure. Using words I might call it add. It’s a add b or with C+±esque syntax it’s like (&c)->add(b) or something.

There is a File struct in the std module and a Write trait implemented for &Files that includes a write(&Char) procedure as well as an instance of an &File called “out.” So to write a string of characters to stdout, you do std.out write <characters>

So from this, I can say that procedures in traits in this language are like mini versions of the stuff under [Mut] that you can call with parameters. These procedures can also have embedded C code which is how you interact with external stuff and how the core and standard libraries are implemented.

Trait and struct definitions go under [Type] and have their own syntax

Forcing all logic to be an explicit mutation of a singular datum may end up being the worst way to program ever, but it’s at least a different way

EDIT: Conceptually this is the same, but the syntax is a bit different now