Last time, we proved once and for all that Beatrice isn’t real, and Natsuhi totally did all the crimes, even the ones she logically couldn’t have done, and also despite having a red declaration that Natsuhi didn’t dunnit. Good job Erika. It seems like this chapter is setting itself up for a victory lap, presenting a bullshit ‘motivation’ for the crimes, as determined by Erika reading Natsuhi’s diaries.

No comments to respond to this time—either my commenting system broke (lmk if you commented on the last post and it’s not there) or there wasn’t so much to talk about last time—so let’s just get on with it.

Episode 15: Revenge After 19 Years

…at this rate this liveblog could take 19 years. Ahem.

OK, so we get a sort of authoritative-sounding, past tense, seemingly omniscient narrator going like ‘After being forced into an unwanted marriage, Natsuhi…’ It’s credited to ‘Trial Summary’, and later, ‘Bernkastel documents’, ‘submitted evidence’ and even ‘Great Court Internal Documents: Library of Law’. It accuses Natsuhi of fucking Kinzo, as part of a plot to steal the Ushiromiya fortune.

Curiously, it also claims that Natsuhi dressed as Beatrice, and this was witnessed by an unnamed ‘servant’. That part wasn’t state outright in the trial scene.

One thing that’s kind of curious here is that we have had it stated in red that Natsuhi isn’t the culprit, which means—to an even greater degree than usual in Umineko!—we are to assume that nothing we’re being told here is actually true.

The problem of ‘who moved the bodies’ is solved by blaming it on Kinzo, who in this telling is not dead. We get some additional evidence, like ‘a button from Natsuhi’s clothes’ confirming that she was hiding in the closet after the murder of Hideyoshi.

We end with an official declaration from the Great Court of Illusions that Natsuhi dunnit, signed of course by Dlanor. And then cut back to the parlour scene, where Natsuhi goes ‘just say I did it then’ (which apparently counts as a confession) and Battler, in first-person narration, repeats the conclusions above.

But then she immediately segues into talking about the ‘man from 19 years ago’. She claims one of the people present must be the man’s pawn. Battler observes her looking at ‘some being behind us’… shit is that me…?

Psychologically broken down, Natsuhi confesses to a murder of a baby 19 years ago. So it’s finally time for the other strand of Lambda’s plot to be surfaced to Battler and Erika..? Anyway, Natsuhi says she was commanded to adopt a baby from a ‘welfare institute’ (is this Kinzo’s orphanage..?)

In Natsuhi’s telling, an unnamed ‘servant woman’ followed her around carrying the adopted baby she wanted nothing to do with. In a moment of ‘temptation’, she considered throwing the baby off the cliff. At that moment, she claims, the servant tripped and leaned on the fence, and Natsuhi shoved them both the rest of the way. But her telling is strange: she suggests they were ‘swallowed up by empty space’ instead of falling; it sounds like she’s trying to figure out which memories are real. (Can relate.) The way she describes it, she had a full-on dissociative episode about it, unsure whether she’d pushed or if they fell on their own.

We move to a more summary narration; Kinzo covered up the baby’s existence and the servant was claimed to have died alone. Her husband was paid off and believed the accident story, and later died of old age. Natsuhi says she apologised on his grave (kind of late, huh) but the rest of this must be happening because she never apologised to the baby. So the baby must have survived and grown up to come here and frame her for murder.

Natsuhi ……And now, ……you’ve taken everything I’ve gained since pushing you off that cliff, 18 years of my life, ……and smashed it all to pieces… ……I no longer have my beloved husband or daughter. ……And I’ve lost even my honor, ……and am being called a murderer… ………No, ……I really am a murderer, aren’t I……

It’s a very Natsuhi-centric version of events. All of this was orchestrated to fuck with her, definitely couldn’t have any motive separate from her.

Will Erika just weave this into her narrative? Nah, she just brushes it off.

But Battler interjects with his trademark ‘dame da na… zenzen dame da ze’..! And… straight into the ‘credits’ scroll.

In this case many characters are ‘alive when the game was suspended’. Also Battler and the witches get special pre-scroll screens with the ‘breaking glass’ transition. As usual, let’s reproduce it here…

End scroll for Episode 5

Nothing particularly surprising there, though it’s cute that ‘All the goats’ get a credit.

Damn, that was a really short chapter. We probably could’ve knocked this one out back in June. But I guess it’s time we plough on into the tea party… a quick check of the character scenes and the Tips screen reveals nothing particularly new.

I feel like this entry is more plot summary than commentary but there just isn’t much to talk about. It’s cool how they’re messing with the format: the episode ends when the game ends, and it seems like the bulk of the actual ending with thematic resolution etc. will be in the tea parties?

Lucky that with player!Battler dead, piece!Battler still has enough insight to step in!

OK, see you in the tea party~

We have been caught up in great battles of wizards in faraway lands… to cavort with witches and the deer of Eastnor and witness lightning dance in the air, and thence to the land of the Finns, a great Assembly where some of the mightiest sorcerers of our art compete to show who best commands the thunder of Ukko.

But now we return… and today’s secrets might be some of the most important.

1. riddles past
   1. The second orb
   2. The third orb
2. memory
   1. a peek down a level
3. a quick primer on memory in Rust
   1. the stack
   2. the heap
4. values and references
5. two other types of language
6. ownership and borrowing
   1. functions eat things
   2. immutable references let you look without touching
   3. mutable references are side effects
7. the borrow checker
   1. shaking it all about
   2. lifetimes
8. fourth orb to ponder

riddles past

First, though, shall we have a quick look at the orbs?

The second orb

In part 2, we were learning about names and scopes; I posed a program, and asked you to figure out what it says. The answer is XYZZY, a magic word of fine vintage. How does it work?

fn main() {
    let spell = "Y";
    {
        let spell = "X";
        print!("{}", spell);
    }
    {
        print!("{}", spell);
        let spell = "Z";
        print!("{}{}", spell, spell);
    }
    print!("{}", spell);
}

That is logically what’s going on. But does the compiler actually do all of this? Let’s drop it into Compiler Explorer and find out. I kind of expected it to be able to see that the program just stores the whole string XYZZY somewhere, but no, it doesn’t seem to be able to simply optimise that away. In fact it produces four separate calls to the print function. Either this machinery is just too opaque or there is some reason the compiler can’t safely make this optimisation.

The third orb

In the third orb, I suggested you could write a program which draws an expanding box by clearing the screen and waiting. Here’s one such program:

fn print_room(width: u32, height: u32) {
    print_horizontal_wall(width);

    for _ in 0..height {
        print!("#");
        for _ in 0..width {
            print!(".");
        }
        println!("#");
    }

    print_horizontal_wall(width);
}

fn print_horizontal_wall(width: u32) {
    for _ in 0..width + 2 {
        print!("#")
    }
    //print a newline to end the row
    println!();
}

fn clear_console() {
    print!("{esc}c", esc = 27 as char);
}

fn main() {
    for tick in 0..60 {
        clear_console();
        print_room(tick, 10);
        std::thread::sleep(std::time::Duration::from_millis(1000 / 60));
    }
}

Each time around, the loop clears away all the current text in the console, prints a slightly bigger room, and then tells the operating system that it’s done with its work for now but please could it be woken up in 1/60 seconds.

Previously our computations were pretty abstract, all we cared to see was the final answer… but here we’re placing our program in the world, and worrying about how much time things take. (Can we be sure that the operating system, which is juggling this and hundreds of other programs, will give us a consistent framerate?) Time will be immensely important later when we do more graphics stuff. But we won’t worry about that yet.

No, there is another part of the temple we need to build in our minds at this point… something we’ve been dancing around a little in the story so far.

It’s almost time to introduce arrays, structs and other ways to make more complicated types. But first, it’s time to talk about memory.

memory

So computers have ‘memory’. You probably know already that this stores all the things the computer is actively doing. If you don’t have enough RAM, your computer can run out and slow down or crash. Better download some more… And of course it’s too damn expensive these days. But from the perspective of a programmer, by which of course we mean a sorcerer schooled in the Arts, what is memory?

Let’s start as simple as we can and build up.

a peek down a level

Memory is how your computer holds on to calculations so it can use the results later.

Although I usually try to say on the Rust level of abstraction, I think it’s quite helpful to know what memory looks like to the CPU. From a program’s point of view, we can think of it as a huuuuuuuuuuuuuuuuuuuuuuuuuge long list of bytes. Every single one of those bytes has an “address”, which is basically just a number.

It might be something like this:

address: 00       01       02       03       04       05       06       07       08       09       0A       0B       0C       0D
data:    01001101 01100001 01100111 01110011 00100000 01101001 01110011 00100000 01100011 01110101 01110100 01100101 00100001 00100001 

So the address numbers just go up, and each number points to a specific byte. The CPU runs instructions like ‘get me the byte at 0x0B’ or ‘put this value in 0x03’.

In this little example, memory addresses are only one byte, which means that the computer could only hold a maximum of 256 bytes of memory. Most modern computers are ‘64-bit’, which means they use eight bytes to represent a memory address, for example 0xCAFEBABEDEADBEEF or 0xBAAAAAAAAAAAAAAD. The type of number used for memory addresses has the special type usize in Rust; on a 64-bit computer that’s equivalent to a u64, on a 32-bit computer it’s a u32, and so on.

However…

For logical purposes, it doesn’t really matter what form a memory address takes. All we need to know is that we can put things down and keep an address to look them up again later.

Now, I’m leaving out a lot of details here. For one thing, we also have tiny bits of memory inside the CPU called ‘registers’ and ‘caches’. And there are many fiddly details: virtual memory, address spaces, cache lines, alignment, etc. etc.; perhaps we will come back to these things later.

All of that is implementation details, though. Important when you want to write fast code… but logically, all you need to know is that you can put things in memory and look them up with addresses. So let’s try to understand the abstraction that all that stuff is working to create.

a quick primer on memory in Rust

Goodness, are we going to have to go around writing out all our 0xDEADBEEF values by hand? Fortunately not; in modern programming languages, all of that is tucked away out of sight.

In Rust, there are two areas of memory. They’re called the stack and the heap. If you’re, hypothetically speaking, a Netrunner player, these words might ring a bell… and unfortunately they will give you the wrong intuition, sorry :p

the stack

So far we’ve mostly been messing with the stack. When we write something like…

fn main() {
    let homura: u8 = 0x68; //ASCII 'h'
}

…in principle, Rust will pick some little bit of memory to store that value. The place where let bindings go is called the stack.

Under the hood, it works in a very simple way: the stack is just all the different values we’ve named, concatenated one after the other in the order we assigned them, in a specially set aside space of memory.

You don’t really need to know more than that, but just for fun, let’s have a look at how the stack actually works. It goes like this:

• the program stores the memory address of the end of the stack (which we call the ‘stack pointer’, since it points to the end of the stack)
• whenever you create a new variable, it gets stuck on the end of the stack, and the program moves the ‘end of the stack’ address to a lower memory address
• when you exit a scope, everything in that scope gets removed from the stack, and the ‘end of stack’ address jumps back up

So, let’s say the stack is something like this…

06   ????????
07   ????????
08   ????????
09   ???????? <- STACK POINTER (new stuff goes here)
0A   01101001 <- some variable
0B   00100001 

And we want to store a new value like let homura: u8 = 0x68. The u8 type has the size one byte. So we move the stack pointer down a byte, and fill in the value. 0x68 is 01000100 in binary. The result is…

07   ????????
08   ???????? <- STACK POINTER (new stuff goes here)
09   01000100 <- foo (least significant byte)
0A   01101001 <- some other variable
0B   00100001 

Now homura has moved into the address 0x09. She’ll be starting school soon, wonder if she’ll meet anyone cool…

The compiler knows that if, later on, we ask for the value of homura, it can read it from 0x09. That’s the basic idea! It’s pretty simple. The stack gets longer and longer as we define more variables. If we define too many variables and the stack runs out of memory, it’s called a ‘stack overflow’ and the program crashes. But usually, there’s loads of space and the only time a stack overflow happens is heavy recursion.

the heap

Although the stack is super nice, super simple and super easy to understand, it’s got some limitations. In particular, everything on the stack must have a fixed size that never ever changes. And there’s a very strict order in which things must be created or destroyed—you can’t really just delete something from the middle of the stack and use that space for something else. It can also be troublesome with very large blocks of data.

There is another place to put things in Rust known as the ‘heap’. This is basically all the memory that isn’t the stack.

Some operations will allocate stuff on the heap, which basically means invoking machinery which says ‘hey, give me some memory of this size’; a piece of the heap will be duly carved out.

There are lots of different types in the Rust standard library which use the heap, such as Box, Rc, Vec and String. We’ll meet some of them later in this series. For now, though, we won’t complicate things too much; let’s stick with stack-allocated values, there will be plenty to think about!

values and references

OK, we know that variables live in memory, and much like fossil fuel CEOs, they have names and addresses. But what can we do with that?

Like lots of languages, Rust can have types which point to other types. In Rust, the main type that does this is known as a reference. If foo is something, then &foo is a reference to foo.

It’s kind of like this. A regular variable just has a name point directly to a value…

name -----> value

But for a reference, the value is itself something which points to a value, so it’s more like this…

name -----> reference -----> value

To get at the value behind the reference, you can dereference it with the * operator, not to be confused with multiplication…

fn main() {
    //the latitude, if you're wondering
    let jeff_bezos_house: f32 = 34.086111;

    //behind this name is a reference to the number
    let address = &jeff_bezos_house;

    //this makes a copy of the number and stores it in 'found_him'.
    let found_him = *address;
}

Just like regular variables, references can be mutable or immutable. You write a mutable reference with &mut:

fn main() {
    //mutable because jeff bezos is not immortal
    let mut jeff_bezos_alive = true;
    println!("Is Jeff alive? {jeff_bezos_alive}");
    
    let target = &mut jeff_bezos_alive;
    //we have an address again, but this time we can do things 
    //to the value on the other side!
    
    //dereference the address and assign a value through it
    *target = false;
    
    //prints false; the original value has been
    //modified through the reference!
    println!("Is Jeff alive now?? {jeff_bezos_alive}");
}

Now, whyever would you want something like that?

The basic and universal answer is that, in a complex program, it may be useful to have multiple names in the program which at least soemtimes refer to the same thing. You can build complicated structures of things pointing to other things.

But more specifically, for Rust, the reason has to do with its ‘ownership’ model. Strap in.

two other types of language

In older languages such as C, you told the compiler exactly when to delete something from memory (aka ‘freeing’ it).

But this could be a problem: let’s say another part of the program has some reference (in C, this would be called a ‘pointer’; the difference isn’t that important) to the thing you just deleted. Before you deleted the thing, all would be well: the reference points to the thing you’d expect. But after you deleted it, it’s not there anymore! The program could put some entirely different thing in that memory address.

This is known as a ‘use after free’ bug, and hackers love to find them, because you can use it to start poking around in places you’re not supposed to, or change bits of the program state. Great way to take control!

‘Garbage collected’ languages work differently. The program has some additional machinery called a ‘runtime’, which keeps track of how many references exist to everything in the program. Every so often, the program stops for a moment, and a special piece of machinery called the ‘garbage collector’ goes around and checks if anything has zero references and deletes it… and then, checks again because maybe the thing that just got deleted was holding a reference to another thing, and so on. This means you can never have a ‘use after free’, because nothing will be freed while it’s still used.

Garbage collectors are very clever creations, and a great deal of research has gone into making them work as well as they do. But they do incur an overhead which makes your program have to do a bunch of extra work all the time, and when performance is very important (e.g. in a game) they can cause unpredictable hitches which you generally do not want. Plus, someone has to actually implement the garbage collector, which means using a language that isn’t garbage-collected.

ownership and borrowing

Rust was invented to have a secret third option. You don’t manually manage memory (unless you go into unsafe Rust, but we won’t be doing that for a while!), but you also don’t need to have a garbage collector. How can that work?

So, remember how we said that names live in scopes, and when a name goes out of scope it disappears?

fn main() {
    //here is a scope...
    {
        let bar = 2;
        println!("Bar is fine to print here: {bar}");
    }
    println!("But printing {bar} here will give a compiler error.");
    //this won't compile!
}

That’s basically the whole trick. The confusing jargon term for this system, which comes from C++, is RAII (standing for Resource Acquisition Is Initialisation). When you leave a scope and invalidate a name, the memory assigned to store that value also gets freed.

A particular consequence of this is that, without references or copying, functions ‘eat’ their arguments.

functions eat things

I can’t actually demonstrate this with numbers or string slices since they are what are called Copy types, so lets quickly introduce another type. We can declare a new type like this, using the struct keyword:

struct Edible;

Once this is written in your program, the world of Rust just got slightly bigger: there are now Edibles in it. Yum. (Like function declarations, it doesn’t matter where in the file you put this declaration, as long as it’s outside any scopes.)

We’ll go way more into the subject of creating new types very soon, but for now, Edible is a ‘unit type’, which means you can create a new Edible just by writing Edible:

struct Edible;

fn main() {
    let tasty_thing = Edible;
}

The rule is this: there can only be one name which authoritatively owns the value.

So, if we assign the value of tasty_thing to another variable, Rust will move the value of the Edible to that new name, and the old name will be invalidated.

fn main() {
    let your_tasty_thing = Edible;
    
    //moves the value to the new name
    let my_tasty_thing = your_tasty_thing; 

    //this will fail because the value has already been moved!
    let someone_elses_tasty_thing = your_tasty_thing;
}

If you try to compile this, the compiler will tell you that you’re using something after it’s been moved. (It will also suggest a way to fix this, but don’t worry about that for now.)

This ‘move’ is only an abstract, logical thing. The compiler will not necessarily actually move the data someplace else in memory (though it might!). It just changes the name for the value.

The main reason this matters is that the same thing applies to function arguments. If we write a function which takes Edibles as input ‘by value’…

fn eat(food: Edible) {
    println!("Omnomnomnomnom");
    //doesn't matter what we do here
}

then, if we call this function, the argument gets moved into the function scope and dropped at the end.

fn main() {
    let your_cake = Edible;
    eat(your_cake);
    //fails because your_cake has been moved!
    let cake_you_have = your_cake;
}

To be clear, these rules don’t apply to anything that is Copy, which mostly includes simple things like numbers, but also includes references. If something is Copy, you can have it and eat it just fine. I’ll save further discussion of what it means to ‘be Copy’ for later, when we talk about another feature called ‘traits’.

immutable references let you look without touching

OK, but what if we want to pass something to a function without eating it? This can be done by making the argument be a reference instead!

//this function takes a reference to an Edible, not an Edible
fn examine(food: &Edible) {
    println!("I'll give it back, don't worry!");
}

fn main() {
    let your_cake = Edible;
    examine(&your_cake);//only a reference gets eaten
    let cake_you_have = your_cake; //works just fine
}

mutable references are side effects

We can also use mutable references to allow functions to modify things outside of their scope. For example, in an RPG you might have something like this…

fn inflict_damage(health: &mut i32, damage: i32) {
    println!("You get hit for {damage} damage. Ouch!")
    *health = *health - damage;
}

fn main() {
    let mut your_health = 1000;
    println!("You have {your_health} health."); //1000
    inflict_damage(&mut your_health, 100);
    println!("You have {your_health} health."); //900
}

By feeding functions mutable references, we can give them side effects! (Functional programmers in the audience are tutting and shaking their heads.)

the borrow checker

Although we can borrow values, there are some restrictions. These mostly exist in order to prevent certain types of bugs in multi-threaded programming, where two parts of the program are trying to interact with the same piece of memory at the same time. Rust is designed to make this easy as possible, and it can only do this with certain restrictions baked into the language.

Even though we won’t be doing multithreading for a while, it’s important to explain them here, so you don’t get caught by surprise!

The very important rule is this…

at any time, there can be either:

• any number of immutable references

or

• only one mutable reference

to the same value, never both.

The Rust compiler is generally pretty smart these days: if you create a mutable reference, it will invalidate any immutable references you might have created, and vice versa. So doing this is actually fine…

fn main() {
    //needs to be mutable or we can't create mutable references
    let mut house = 10;

    //fine, there are no references
    let ref_1 = &house;

    //fine, there are only immutable references
    let ref_2 = &house;

    //fine since we can drop all immutable references
    let mutable_ref = &mut house; 

    //fine since we can drop the mutable reference
    let ref_3 = &house;
}

But if you refer to an immutable reference you created earlier, then we have trouble!

fn main() {
    //needs to be mutable or we can't create mutable references
    let mut house = 10;

    //fine, there are no references
    let immutable_ref = &house;

    //not allowed!! since the immutable ref is still in use
    let mutable_ref = &mut house;

    //this line means we can't drop immutable_ref
    let mouse = *immutable_ref;
}

If you try to compile this, the compiler will give you a nice colourful explanation of the problem. I can’t reproduce the colours on here but here’s what it looks like

error[E0502]: cannot borrow `house` as mutable because it is also borrowed as immutable
  --> src/main.rs:44:23
   |
 5 |     let immutable_ref = &house;
   |                         ------ immutable borrow occurs here
...
 8 |     let mutable_ref = &mut house;
   |                       ^^^^^^^^^^ mutable borrow occurs here
...
11 |     let mouse = *immutable_ref; 
   |                 -------------- immutable borrow later used here

In the old days of Rust, the compiler wasn’t nearly so clever about this, and people would complain about having to ‘fight the borrow checker’ all the time. But now this kind of problem comes up only rarely. In the course of making Shaderland there was maybe only one time when I felt I had to do anything annoying to keep the borrow checker happy.

shaking it all about

Note that there is one other way for functions not to permanently eat stuff: if they have a return value, that pops back out into the enclosing scope and doesn’t get deleted. Which we can fold into our metaphor, and I’m very sorry for this…

fn eat_and_shit_out(food: Edible) -> Edible {
    food
}

fn main() {
    let tasty_thing = Edible;

    let bezoar = eat_and_shit_out(tasty_thing);
    //the value has now moved into bezoar, unchanged
}

You can also return references, if you want to.

fn inspect(thing: &Edible) -> &Edible {
    thing
}

lifetimes

This is an advanced topic and one we’ll cover in much more detail later on.

All that stuff above about how Rust prevents use-after-free and so on? Only works if the references can be proven not to stick around after the thing they’re referring to. The way Rust does this is… I mean I know I’ve been doing a bit of a silly occultism theme through all this but this is maybe the most magical thing going on here.

Essentially, everything in Rust has a ‘lifetime’. This is a slightly nebulous thing but it’s basically a way of keeping track of which order you can delete things.

We write lifetimes with an apostrophe like 'l, and you most often see them on references: &'l Thing is a reference to a Thing and that reference has lifetime 'l. (If you don’t write the lifetime, Rust will still be figuring it out behind the scenes; this is an implicit lifetime.)

Lifetimes relate to other lifetimes; indeed, they don’t do very much else. Saying 'l1: 'l2 means that lifetime 'l1 cannot live longer than 'l2. Which is to say, everything with lifetime 'l1 must be deleted before anything of 'l2 gets deleted. If the compiler can’t prove this is true on a type level, then the program won’t compile.

Why bring this up now? Occasionally, usually when you’re passing references around, Rust will require you to declare explicitly which lifetime is being used. We’ll see an example of this in the Orb.

fourth orb to ponder

We have just finished drawing one of the most important magic circles in our ritual! However, it will be hard to get an intuition for this until you start using it. And to do that, there are still a few more runes we need to draw.

Still, we can always make a horribly perverse maze. (Seriously, this feels mean, nobody should write Rust like this.) Watch out for the shadows!

//we'll learn more about enums next time
//but the short version is this lets you say a type can be one of a fixed list of things
#[derive(Debug)]
enum Room {
    Treasure,
    Doom,
}

//always goes to the room on the left
//note that we need to make the lifetime explicit here!
fn left<'a>(l: &'a Room, _r: &'a Room) -> &'a Room {
    l
}

//always goes to the room on the right
fn right<'a>(_l: &'a Room, r: &'a Room) -> &'a Room {
    r
}

//a silly rusty maze
//one reference leads to treasure, the other to certain doom
fn main() {
    let amazing_wizard_orb = Room::Treasure;
    let doom = Room::Doom;
    let (l, r) = {
        let a = left(&amazing_wizard_orb, &doom);
        let b = right(&amazing_wizard_orb, &doom);
        let c = left(b, a);
        //a shadow attacks!
        let b = left(c, a);
        let d = right(c, b);
        //a shadow attacks!
        let b = right(b, a);
        let e = left(b, d);
        //a shadow attacks!
        let d = right(b, c);
        let f = left(d, e);
        let g = right(c, f);
        //a shadow attacks!
        let f = right(c, b);
        let h = left(f, g);
        let i = right(g, h);
        let j = left(g, i);
        //a shadow attacks!
        let h = right(i,j);
        let k = left(i,f);
        
        let l = left(k,h);
        let r = right(k,h);

        (l, r)
    };
    //uncomment this line to take the left path
    //println!("I took the left path, and found my way to {l:?}");
    //uncomment this line to take the right path
    //println!("I took the right path, and found my way to {r:?}");
}

Can you figure out which path to take to get through the maze?

Next time, we’ll look at this ‘defining new types’ business, and finally get to arrays!

1. a magic trick
2. where it came from
   1. interacting with entities
3. what is a computer
   1. a little history tangent
   2. what’s in a word

You might have a variety of answers to this question. It rather depends on what, exactly, we mean by “magic”, and also by “real”, right? (Maybe we can add “is” while we’re at it.)

In our world, there are many practices which fall under this nebulous label of ‘magic’, ‘esotericism’, ‘occultism’ and the like, blending continuously with the wider world of religion. Some people pursue membership in orders, study tables of correspondences, or draw sigils. They may speak of making contact and forming relationships with an impressive array of “entities”, and observe certain rituals in respect to them, or warn each other of the great dangers of reckless magic workings. Other people may say they can detect auras, discern hidden information, or bring subtle benefits or harm. People may use various powerful tools to get their minds into a shape more amenable to interaction with gods, spirits, and other entities: psychedelic drugs, group worship, extreme endurance, sexuality, hypnosis…

Others, describing themselves as skeptics, disparage these practices or at least their claimed effects, talking about cognitive biases, superstitions, and so forth; in response, there are plenty of people (all the way up to national intelligence agencies) who pursue rigorous experiments to detect or rule out such ‘supernatural’ effects, a research programme which generally speaking has not proven especially fruitful.

And then, of course, there are further groups of people who study ‘magic’ and ‘religion’ in an academic way, in terms of texts, traditions and practices, the construction of meaning, how stories evolve, and so on. Esoterica is for us the iconic example. They may overlap with one or both of the previous categories; they may come at it from a place of skepticism or a place of asking fiddly theological questions in the tradition they were raised in. Maybe it’s just a Special Interest, for which no explanation is needed.

This hopefully suffices as a quick survey. We are not exactly going to be talking about that.

a magic trick

We can give you some information about a faraway place right now. In a certain place in Glasgow, on a warm, cloudy night of June 6 2026, there was a desk with a MIDI keyboard, VR headset controllers, roleplaying dice, a drawing tablet, a floppy disc which generates oscilloscope music, and a bookmark from Treadwell’s. Here, we took a picture:

Assuming you believe us, you didn’t receive the info by standing here in the room and looking with your eyes, did you? You remotely viewed a room, perhaps in another city or another continent. Whooooahhhhh spooky…

…you’re not very impressed by that, are you? This isn’t ‘magic’. It’s ‘technology’; ‘engineering’; ‘science’. That belongs to an entirely different category of thing. Doesn’t it?

Without really saying whether all of those other magical traditions ‘work’ or ‘don’t’ (to whatever end)… I want to teach you about a form of magic that definitely works. It is a form of magic that requires quite an alien way of thinking, like all good things—and yet we call it magic for this reason: it all really does come back to the fundamental magical act of giving names to things that you cannot see.

where it came from

Magic is a very tradition-bound thing. Even the radical (post)modernist traditions, such as Chaos Magic, are traditions. They are elaborations on something that came before.

The magic I want to teach you about today does not usually call itself magic. It calls itself a science. What exactly is a science?

The word ‘science’ traditionally just meant ‘scholarly’ study of something. In the mid-20th century, its sense narrowed to the ‘natural sciences’, ‘social sciences’ and perhaps the ‘formal sciences’, though I’ll admit the first time I heard that last phrase was on Wiktionary just now. These are quite wildly different disciplines, and the ‘demarcation problem’ of figuring out what is a ‘science’ and what isn’t has consumed a great deal of philosophical energy in the late 20th century. What are the typical characteristics of a ‘science’, though? A typical answer would probably cover features like formal rigour, statistical methods, skepticism and empiricism; you might get a bit of Popperian falsificationism and so on.

But this distinction is pretty modern. In the 16th and 17th centuries in Europe, the weirdos who pursued what we now call ‘science’ pursued all sorts of weird stuff with equal vigour.

Isaac Newton, for example: his occupations included “mathematician, physicist, astronomer, alchemist, theologian, author and inventor”, a fellow who spent as much time writing about theology and alchemy as all the contributions to calculus, mechanics and optics that made him famous. (Dude also invested in the slave trade, which tends to get left out.) John Dee: “mathematician, astronomer, teacher, astrologer, occultist, and alchemist”. He’s most famous for talking to angels through his buddy Edward Kelley and other such sorcerous things, but in his time he was also known as a navigation expert and pretty good at maths too. (Mathematicians never exactly stopped getting a bit funky with it, though the social significance of ‘thinking you can talk to angels’ changed by the time of John Nash.)

Of course, over the ensuing centuries, the tradition of ‘natural philosophy’ diverged from these prior traditions. For example, some of these people took an interest in some weird rocks which like to point in certain directions and pull metals towards them, and similar effects that occur when you rub something sticky like amber, which led to this phenomenon being called ‘electricity’, which glosses to ‘amber-y-ness’.

Others stumbled on the strange fact that if you soak certain metals in salt water in a special circular arrangement it can make a dead frog’s leg twitch. Before long they figured out special arrangements of metal bits in salt water which would do this weird frog/amber thing, whatever it is, more reliably and powerfully.

The alchemists were hard at work through all this, gradually sifting through all the different possibilities of mixing up bottles of stuff and heating, straining and filtering, trying to figure out what was made up of what, in a huge and very convoluted game—taking a very intricate occult tradition which had once concerned itself with the production of gold and finding instead all sorts of uses in medicine, mining and opportunities to defraud the rich.

To try to organise their understanding of all this weird shit, they had to come up with some theories. Maybe it would make sense to think the world is made up of a bunch of little things, let’s call them corpuscules of different types, and that these are better called ‘elements’ than, for example, Aristotle’s air, water, fire and earth? Maybe there is a substance, we could call it ‘caloric’ in hot things, which likes to spread out? Maybe, in the voltaic pile, the ‘voltaic amber-y-ness’ produced by the stack of metal and salt water was the same thing as the ‘magnetic amber-y-ness’ produced by moving the aforementioned weird rock? Maybe there are two types of electrical thing, all mixed up with each other?

interacting with entities

These days we cannot really view these as anything other than the steps towards modern science, but these ideas are all traditionally magical questions. ‘What is everything made of’, balances of ‘elements’, how can the sick be healed, and so on.

You cannot see the corpuscles, the caloric, and so on. You have to imagine that there are such things, work out a theory of what they would do if they were real, and if your theory is anywhere close, it will tell you how to fiddle with these invisible things and get a desired result. If it isn’t… think of something else. But you do have to go out on a limb of speculating about a ‘thing’ that is not directly accessible to the senses.

In fact, we now consider both theories to be obsolete, though they were along the right track. Boyle’s divisible ‘corpuscules’ anticipated the modern theory of atoms, which turned out to be a bad name for things that can actually be divided after all… but chemistry does act as if there are corpuscules pretty well. The random jiggly motions of these atoms can be collectively described as representing something called ‘heat energy’, which in many circumstances acts as if it is a fluid.

Now, let’s draw some funny little symbols.

There are two possibilities here: you have studied electromagnetism up to around undergraduate level, in which case you know that these are Maxwell’s laws in differential form, and what they mean… or, you haven’t, and if I said these shapes encode a description of ‘an energy field… (which) surrounds us and penetrates us. it binds the galaxy together’ (ok, that’s cheeky, I’d more likely say a pair of vector fields that exist at every point in space) you could only really be like ‘ok, sure…’, same as if I told you that you could summon a demon called Gaap by drawing this seal:

If you know what to do with those equations—using an additional set of conceptual tools such as ‘vector calculus’, and a knowledge of the practices which can be used to identify and measure things like ‘electric charge’—you can use them to, for example, build an electric circuit. You don’t actually need to use them. You can build a radio, for example, perfectly well without ever doing vector calculus, just by building up a set of rules about which components go where. If you’re a radio engineer, you likely wouldn’t directly use these equations—doing a first-principles calculation from Maxwell’s laws would be fiddly and unhelpful.

Some day, however, you might want to ask why your radio works. Where do all these rules about transistors and capacitors and ‘electric currents’ come from? Why does “electricity” do any of that shit? And then you could work through the derivations of, for example, the transmission line equations. You could read up on the experiments that established electromagnetism, and maybe perform them yourself if you want to. You could learn about how weird it is that the resulting list of laws is ‘reference frame independent’, and how that led to thought experiments at the beginning of the 20th century which showed something is very wrong with the prior understanding of physics.

And, if you’re feeling especially daring, you could take it further: you could learn there is a ‘covariant form’ of Maxwell’s laws, for use in special relativity:

If the last set of weird symbols was vexing, this one probably feels like it’s taking the piss. Why are some of the Greek letters up and others down? What does \(\partial_\alpha\) mean? (This is a nice efficient notation for doing relativity calculations. It is hopelessly esoteric for anyone but physicists and mathematicians, and even the mathematicians prefer other notations.)

You might go into learning about classical field theory, and Noether’s theorem. You might understand how this is really the only sort of vector field that would occur in a universe with Minkowski symmetry: this strange, seemingly arbitrary feature of our universe has a weird mathematical inevitability to it when we look at it from the right perspective… oh, we haven’t even touched on quantisation yet.

Which I think would be rather a delight to the Newtons of this world. It turns out, if you go looking for a mystical, abstract structure behind everything, with the right lens, with enough effort… well, maybe you actually find one. We call it ‘gauge field theory’ and only people with postgraduate degrees, or commensurate effort without any institutional support, get to build up enough structures in their heads to understand it. Once you do, it’s really elegant though! …pretty fucked up, yeah.

Nevertheless, by pursuing this quest as an nth-degree recursive elaboration on that thing with the frog legs, we have found ways to create immense light and sound, travel at great speeds, speak to faraway people, move heavy objects, wash our clothes, warm and cool spaces, keep our food from spoiling, kill each other, and even occasionally revive the very recently dead. And we also figured out it’s a great way to build a “computer”, which is what the rest of this story is about.

But it’s not magic, right? If we found out “magic” was real it would be like… something else. Electromagnetism doesn’t have the right vibes, somehow.

What’s missing?

In many ways, the ‘magic’ we’ve described so far falls far short of what motivated the search. We can predict the celestial bodies, but it’s not actually much help in predicting the future on the scale of humans. It certainly doesn’t tell us how to live. Here in the middle, things are so damn complicated, and only get more so.

Why is that? A short answer: it’s because things like electromagnetism and chemistry form a substrate on which abstractions can live.

what is a computer

OK so: surprise. This is actually an article about computers. We want to introduce you to the magic that absolutely, unambiguously works, and we want to do the unusual thing of presenting it as magic.

Imagine we lived in another universe with different physics. No Minkowski spacetime, no electromagnetism, none of the familiar chemicals. Perhaps it’s something like the world of Tryslmaistan.

In such a universe, computers could at least potentially still exist. All sorts of things can be computers. A computer is not (necessarily) an electronic device; it is something altogether more abstract.

So what is a computer?

When we are first introduced to the concept of computers as children, we probably form an idea like this: a computer is a box with buttons and lights. It has a screen which shows you things, it makes sounds, and there are various things called ‘programs’ inside it. It can do an absolutely bewildering array of things and it also sometimes makes adults very annoyed when it doesn’t work.

A Victorian would say: a computer is someone, usually a woman, who works to draw up big tables of numbers for performing mathematical calculations. (For example, tables of logarithms can be used to quickly do multiplication.) By the beginning of the next century, a computer would become a machine which can be used to make calculations: for example, a ballistics computer on a ship could rapidly calculate integrals, derivatives and multiplications by rolling a ball on a specially shaped metal drum.

We’re about to mention a bunch of concepts in quick succession. If they are of interest, we can elaborate later.

a little history tangent

If you’ve had much exposure to computer science in a traditional way, you might come up with a different story: there is this thing, a thought experiment rather than a real thing, which is called a Turing machine. It can perform ‘algorithms’ according to certain rules, which tell it to go up and down an arbitrarily long tape, reading and writing symbols at each point; by doing this, it is able to determine what other, simpler machines would do. A computer is a mechanical system which is, in a certain mathematical sense, ‘equivalent to’ a Turing machine: you can simulate a Turing Machine on it, and vice versa.

(Turing was a mathematician who created the machines which broke Nazi codes for the British government, and also thought very hard about things pretending to be other things until the government drove him to suicide with involuntary hormone therapy. You probably know that part.)

Turing did not invent computers, but alongside Alonzo Church and Kurt Gödel, who respectively invented the lambda calculus and general recursive functions at almost exactly the same time, he came up with the theory which founds the discipline of magic we’re about to get stuck into. Church and Gödel were coming at it from a different angle, trying to understand the foundations of mathematics in terms of strings of symbols and procedures for manipulating them. Remarkably, it turned out that all three of their ideas were equivalent: a Turing machine can run the lambda calculus, and the lambda calculus can model a Turing machine.

This led to what we now call the Church-Turing thesis (sorry Gödel), which is that this is basically as good as it gets: roughly, if a Turing machine can’t do it, then nothing can. Since then, this is effectively the definition of a computer: if a system can be shown to be ‘Turing complete’, i.e. do whatever a Turing machine can, then it’s a computer.

You can at least in principle make a computer with e.g. water, dominos, laser beams or billiard balls: generally the recipe is to find a way to make the system follow the logical rules we call a NOR gate (or NAND gate) and find a means to chain them together in succession. All these things are, however, generally slow as shit compared to electronic computers. (Optical computing might have a chance but that’s still electromagnetism.)

So, if not Turing, who did invent computers? Arguably someone in ancient Greece who made the Antikythera mechanism, a complex geared mechanical orrery. Tho, astonishing as it is, though, the Antikythera mechanism doesn’t meet Turing’s standard: it can’t do whatever a Turing machine can. The first person to conceptualise a machine which can do that might be Charles Babbage, who dreamed up (but never actually built) the Analytical Engine.

But even Babbage didn’t quite know what he’d stumbled upon; his buddy the countess Ada Lovelace went further in imagining some programs which the Analytical Engine might one day run. Lovelace is a fascinating figure, a self-described ‘analyst & metaphysician’ who, as she worked to translate articles about it, speculated on how things like music might be encoded in the machine. (Perhaps if her Bernoulli number algorithm is the first computer program, these speculations could make her something like the first digital music producer?)

These four—Turing, Church, Babbage, and Lovelace—are some of the venerated figures of our strange practice, people who happened to be in the right time and place to come up with a really far-reaching idea or ten. Perhaps one day they will fade as deep into mythology as Paracelsus or Hermes Trismegistus. There are plenty of others more recent, we’ll learn about them in time.

All of it is a fascinating history… but it’s not actually very helpful to talk about Turing machines, right now. Without a lot of time trying stuff and intuition, it’s very hard to get a sense for what this thing with the tape can do.

It might as well be… magic.

We’d be better off starting with the computers we have in everyday life.

what’s in a word

Programmers use the word ‘magic’ fairly often, in fact.

For example: the 1984 textbook Structure and Interpretation of Computer Programs depicts Hermes Trismegistus bestowing knowledge of the Lambda Calculus to Ramon Llull, adapted from a panel of alchemists in the 1849 French history book Le Moyen Age et la Renaissance. Accordingly, it enjoyed a reputation as the ‘wizard book’ in hacker culture; if you understand its contents, people might joke that you belong to an esoteric order called the Knights of the Lambda Calculus.

But in everyday hacker language, ‘magic’ is generally used in computing for things the speaker doesn’t want to explain in detail, perhaps because they are too complicated to understand. For example: ‘then the compiler does some magic to optimise this away’. A particularly inscrutable algorithm might be described as ‘black magic’, or even ‘evil’. This use is largely unchanged from 1988’s jargon file:

MAGIC adj. 1. As yet unexplained, or too complicated to explain. (Arthur C. Clarke once said that magic was as-yet-not-understood science.) “TTY echoing is controlled by a large number of magic bits.” “This routine magically computes the parity of an eight-bit byte in three instructions.” 2. (Stanford) A feature not generally publicized which allows something otherwise impossible, or a feature formerly in that category but now unveiled. Example: The keyboard commands which override the screen-hiding features.

Under this sense, things stop being magic once you understand them. Understanding the inner workings of a system might be compared to understanding the trick behind a piece of stage magic.

This is somewhat contrary to depictions of magic as something that you study. It’s also a bit different from the account of magic we’re using here. To understand magic, for us, is to build up a structure in your head which can hold it.

In short, we want to help you understand and wield the magic. Whether that means it stops being magic depends on what you call magic.

All of that is ‘just’ context.

It’s time to get to it. We would like you to understand what programs are, and what it means to write them.

1. what is a program?
   1. instructions
   2. the wider world
   3. a home for programs
   4. programs in boxes
   5. so do programs exist?
2. first orb to ponder

what is a program?

A modern computer is generally speaking doing a lot of ‘things’ at once. We tend to call these ‘things’ processes or programs. You can find out what your computer is doing in a few ways.

• on Linux, you’ve got lots of options. I suggest running btop (you may need to install it; htop or top are older, slightly less fancy-looking alternatives). Or, see if your desktop environment has program called something like ‘System Monitor’.
• on Windows, open the Task Manager.
• on macOS, open the Activity Monitor.
• on an Android device, it’s annoyingly fiddly to get this information. You have to do a weird ritual to turn on developer options by tapping seven times on the build number (no seriously), then you can open ‘Running services’ in the developer options
• on a FreeBSD computer, an Amiga, or one of the many other operating systems… if you’re using one of these, you probably know already.

Once you’re in there, there will be a long list of mysterious things that are being done by your computer. So what are they?

Well, let’s start by saying programs kinda don’t actually exist… at least, ‘below certain levels of abstraction’.

instructions

Every modern computer processes things we call ‘instructions’. There is a long list of things that a particular computer knows how to do, each of which has a number.

We’re starting somewhere in the middle of the great chain of abstractions that makes up a computer. We could start lower, with logic gates; we are going to build higher. But starting with instructions is a nice place to get a sense for how things really work.

None of this is stuff you need to memorise: we will deal with this indirectly, through programs.

“Inside” the computer somewhere there “is” a long list of instructions we want it to carry out, not unlike a recipe. We can represent it like this, in “machine code”. For example, here is some code for an x86-64 processor that reads two numbers and adds them together:

89 7c 24 0c
89 74 24 10
01 fe

You can read this as saying ‘run instruction 0x89 with the values 0x7c, 0x24, and 0x0c, then run instruction 0x89 with the values 0x74, 0x24 and 0x10, then run instruction 0x01 with the value 0xfe’. (The prefix 0x… means the values are all written in hexadecimal.)

Nobody in their right mind would try to make sense of a program this way (nobody was in their right mind in the 40s, least of all the people who invented computers), so in 1947 Kathleen and Andrew Donald Booth invented the first assembly language and gave all these numbers special names to make it more readable. With x86-64 assembly, the above reads:

mov    DWORD PTR [rsp+0xc],edi
mov    DWORD PTR [rsp+0x10],esi
add    esi,edi

which can be read as: ‘move the thirty-two-bit value from the memory address at (stack pointer + 0x0c) into the edi register, then move the thirty-two bit value from the memory address at (stack pointer + 0x10) to the esi register, then add the esi and edi registers together, storing the result in the esi register’. A program called an assembler can turn this special language into the numbers above.

That’s still very complicated, nearly every word in that sentence is jargon! However, this is what computers are actually doing. All the electronics that exists in a computer, all the logic gates and transistors, have been very carefully put together in order to make it possible to decode and run these instructions. Everything else we are going to do will ultimately be boiled down into instructions like this.

Different types of computers have different instruction sets. A modern PC will almost certainly be running x86-64; an android phone or Apple computer will almost certainly be running some variant of ARM. A small, embedded device might be running RISC-V. Older computers ran lots of other architectures. In theory, it is actually possible to make a computer with just one instruction, such as subleq.

In no case do the instructions have any notion of what program they are associated with. So where do programs come into it?

the wider world

Single instructions on their own are not good for very much. We added two numbers together, so what? We need some other instructions to come together and read that number we just calculated, and do something with the result. By feeding the results of one instruction into another instruction, we get complicated behaviour. A modern computer might run a few billion instructions in a second.

By arranging a whole bunch of instructions just so, we can describe a process to achieving some desired result. For example, a very basic program could ask you for two numbers on the screen, and then add them together, and then put the result on the screen. This analogises pretty well to a ‘magic working’. You have some intent, and you arrange a bunch of symbolic elements to create a process that will fulfill that intent.

Hold on a minute, where did this screen come from? This is a new character in our story, isn’t it?

So far we’ve talked about the inside of a CPU in isolation. But a CPU on its own is just an unbelievably expensive paperweight. A modern computer has a whole bunch of parts. At absolute minimum, to be useful we need: motherboard, CPU, memory, and some kind of connection to the ‘outside world’. This could be a screen (for a desktop PC or phone), but it could just be a network connection (for a server), or a motor (for an embedded microcontroller), or some other weird thing.

So, using various protocols, the CPU that is carrying out our program has some way ‘talk to’ the other parts.

The memory may be the most important. Inside the CPU there is only a very, very small amount of space to store information. Anything that needs to stick around needs to go into memory. Many different types of physical electric circuit can qualify as memory, but the important thing is that it is ‘random access’, meaning the CPU can look up or store a value anywhere, given just a number which we call an address. The CPU activates wires (circuit board traces) called the ‘address lines’ to send a signal to the memory controller, which looks up that address, and sends back the contents.

What about the connection to the outside world? Well, the motherboard’s job is to take signals from the CPU and decide what to do with them. There are various ways this can be accomplished. It may simply be accomplished with the same ‘write to memory’ instruction, but for certain addresses, the motherboard jumps in and says ‘actually that address means we need to pass this data here’. Or there might be special lines and special instructions just for talking to hardware.

In the old days, you would have a manual that comes with your computer and tells you what you need to do to interact with the other components. In those days, a computer would just run one program.

Nowadays, there are millions of different configurations of computer your display might want to run on. You don’t want to know about all the details. You probably also want to run multiple programs at once. This is where the operating system comes in.

a home for programs

The operating system is, roughly, the program which runs all the other programs. It provides a context in which programs can ‘talk to’ each other in standardised ways.

Some of those programs control ‘talking to the hardware’, and it will have specialist programs for all the different types of hardware that it might run on, which we tend to call ‘drivers’. This is nice because you can just write a program to target a specific operating system, which has just one standard way of doing things. For example, if you want to play a sound, a program can ask the operating system to translate your ‘please play a sound for me’ command into device-specific instructions for the particular sound hardware of this computer.

How do you have all these programs running at once? You sorta don’t. On a single-core CPU, it’s like this: you run a little bit of one program, then you put the state of that program into memory and jump to where you left off on another program, and then again for the next program… This is called multitasking. The process of putting one program away, and loading another to execute for a little while, is called a ‘context switch’.

So the distinction between different programs lives in the operating system. The operating system becomes the ‘environment’ in which other programs frolic. But to the CPU, the operating system and the programs inside it are all combined into one huge, non-stop stream of instructions.

programs in boxes

Within an operating system you have the idea of a thing called a ‘file’, which is really at the most fundamental level just a name which the programs can interact with. Usually, that name refers to a chunk of data. And usually, it will have some extra information which will help the operating system figure out what program might understand this file, called ‘metadata’. But other ‘things’ can be ‘files’ too. On Linux (and other Unix-derived systems), all sorts of things can be spoken to as files, including hardware devices, running programs, random number generators…

Still, sticking with the familiar: if a file is ‘just a bunch of data’, one type of file is an ‘executable file’. This is a file containing instructions, like we’ve discussed above. Different operating systems have different ways to format this file. On Linux, files are elves… sorry, they are ELF binaries. On Windows, they are some version of exe. On Android, it’s an APK, and so on.

Whatever they are, they store the recipe of instructions that ‘belong to’ one particular program. Besides conforming to the format, there is nothing special going on here. It’s pile of data, the same as an image or video or anything else. Without knowing how to read it, most of the contents would look like random noise. But the operating system knows how to decode it: it copies the program’s instructions into memory, makes a note of this program amidst the list of running programs, and jumps the CPU to the beginning to start doing whatever the program tells it to do.

so do programs exist?

What we’ve described so far is how an abstraction becomes real.

We want to imagine there are lots of little things, which we call programs, running inside the computer. If that were the case, we can conclude that they ought to behave in certain ways. So we wrote a program that follows those rules.

If we did our job right, if we cover all the little details, then we get a situation as if the world inside the computer is segmented into little things, which can be passed around as files, and each one is running on its own and passing little signals to the others.

This is how we perform magic. We work out what we want to happen, and make something on the ‘level below’ conform to the rules. In computers, there is only ever as if. We build as if on top of as if on top of as if until the stack of abstractions is so tall we can hardly see the bottom anymore. We can build entire notional computers on ‘as if’, which we call ‘virtual machines’; in theory it should be impossible for a program to know that it is running on a virtual machine as opposed to ‘directly on the hardware’. (In practice there are subtle ways to tell.)

Sometimes the abstraction fails. For example, one ‘as if’ that we want to enforce is that programs have different levels of security privilege. The ‘kernel’ is allowed to do things that ‘user space’ programs cannot. The ‘user space’ programs must ask nicely for the kernel to do something, like give it some memory, and before it does, the kernel will check to make sure all the relevant rules are being followed. For example, I can’t just snoop around for sensitive information that other programs might be processing.

But if there is a mistake in how the kernel is written, I might be able to trick it into doing something it wasn’t designed to do, take control, and do whatever I want: steal information, impersonate people, etc. Computers are really horny to compute. Computational power can sneak through all sorts of weird ways. Later on we might learn about things like ‘ROP gadgets’ and ‘weird machines’, where fully Turing-complete computers form inside programs more or less by accident.

This is known as the abstraction ‘leaking’. It is not enough to know what ‘as if’ rules a program is following. A complete story describes both the intent of the program and where the reality differs from the intent.

first orb to ponder

Later in this series we might pose multiple-choice questions. However, I don’t think this stage needs it. Instead, some things to think about.

ffmpeg is a program which does things with video and audio. You can run ffmpeg on many different platforms: Windows, Linux, etc., and many different architectures, and there are many different versions.

Conventionally, we tend to think of some portion of these as mostly being ‘the same program’. But what makes that the case? Perhaps we can think of…

• two running instances of ffmpeg were loaded from the same file on disk
• two files of ffmpeg have the exact same bits, but they’re ‘different files’
• as a library, two versions of ffmpeg can be shown to give the same output for (nearly) all inputs, but they have different symbols for linking to other programs
• two files of ffmpeg were compiled from the same source code
• two different files are launched with the same ffmpeg console command (they have the same name in the operating system), e.g. before and after an update

Now imagine changing these things. Maybe you rename it to ffmpreg. Maybe you modify the source and recompile it, maybe you rewrite it from scratch but somehow do such a good job it does the exact same thing.

Which ones are still ‘the same as’ ffmpeg? There isn’t a right answer.

1. getting set up (introducing Rust)
   1. the console
   2. setup and compilation
2. naming things
3. semantics vs instructions
   1. shadowing
   2. mutable variables
4. what is a language for?
5. a dungeon game
6. second orb to ponder

getting set up (introducing Rust)

That’s probably enough preamble. Why don’t we actually do a little programming?

For this series, we will be using the Rust programming language. Instructions for installing it are here.

Although Rust has a very helpful and informative compiler, we also recommend having a good IDE with language server support. Like all programmers we have opinions. We currently use Zed, but for the love of Lain, please turn off AI in the settings. A traditional console-based option is Vim, or more recently Neovim; alternatively emacs. (In times past, the choice of vim or emacs was so fervently argued it was often called ‘religious debate’.) If you dislike Zed, Sublime is still pretty good and importantly very fast, but its language server support is less good. We won’t recommend anything that is built in Electron (VSCode etc.) even though most people use them. You might feel less strongly about it.

Speaking of religious debate, why Rust? We (canmoms) like Rust. It’s a language that, in our view, strikes a good balance. It is a compiled language, so you will make the actual sort of programs that run on your computer. It doesn’t have as many fiddly annoying aspects as older languages like C, but it will still give you a firm foundation to understand what both ‘high-‘ and ‘low-level’ languages are doing. For the sake of teaching, it is a very explicit language, and accords nicely with the ways that we like to think about programming. In particular, it has a very nice type system. It is also very fast to run (but relatively slow to compile).

Not everyone would agree. People get quite fervent about this. The main complaint people make about Rust is that it is overcomplicated; it also has a very strict model for handling memory which people sometimes find overly restrictive. This is one reason why suggesting starting with Rust, which is infamously quite difficult, is maybe a bit spicy. Later in this series, we’ll talk about some of the design tradeoffs that Rust makes, and compare other languages.

A great deal of this series will be conceptual enough that it will apply to any programming language. If we start talking about a specific Rust feature we will make sure to be clear about it.

This is not a complete guide to the syntax of Rust. For that, there is the Rust book. This is an excellent and well-written resource if you already know a little about programming, but it is quite heavy going.

the console

In the olden days, computers just gave you text-based ‘terminals’. You would type commands, and the results would be printed as text.

In modern times we still tend to use ‘terminal emulators’, also known as ‘consoles’, for programmy activities. The idea is the same: you type the name of a program, and some settings for it, and it will run.

On Linux, there are lots of options depending on your distro, desktop environment etc. but you can probably find yours just by searching for ‘console’ or ‘terminal’. On MacOS, it’s just called Terminal.

On Windows, you have the ‘command prompt’ which is old, and ‘PowerShell’ which is newer. Out of the box, powershell is a rather unfetching shade of blue. We recommend using scoop to install concfg to make it less painful to look at. With scoop you can get things feeling a little more comfortable.

On the layer just inside the window, there are lots of different “shells” which work in slightly different ways (bash, fish, powershell etc.) which determine what actual text you’ll see and what commands are available. The most important piece of information is that your shell is ‘somewhere’: it has a ‘working directory’ inside the operating system’s ‘file system’. Whenever you run a command it will take this ‘location’ into account. On most consoles, you can change to other locations with the cd command, and see what is present where you are with ls. . is a shortcut for where you are right now, and .. is a shortcut for the layer containing where you are, so cd .. will take you out of your current folder.

There’s a lot of other stuff but that’s all you need to get started.

setup and compilation

Create a new folder. In the console navigate to this folder and type the incantation cargo init. This will run a program called Cargo, which is the Rust package manager, and tell it to set up a new project for us. Cargo will create some files: a Cargo.toml file which contains some general settings for the project, a src folder, and inside there a main.rs file to contain our program.

Together, these files define what sort of program is to be built. The program that turns them into an actual executable file of the sort we discussed above is called the compiler. Compilers are one of the greatest things humans have ever invented, maybe. They’re certainly one of the richest, most intricate segments of computer science.

To turn our program into an executable file, we should type cargo build into the console. This compiles the program without optimisations under target/debug; alternatively, casting cargo build --release will create a faster, optmised version under target/release. You can also build and immediately run a program with cargo run. cargo will not bother rebuilding if nothing has changed.

If there is a compilation error in your program, the compiler will not create a new executable file, and will give you information about the error, and hopefully some advice on how to fix it, in the console when you type cargo build or cargo run.

OK, that’s the basic set of incantations. Let’s see what we can do with them.

naming things

There’s an old computer science joke which goes like this:

The two hard problems of computer science are naming things, cache invalidation, and off-by-one errors.

It apparently goes back to Phil Karlton, according to his son. At some point the meta joke of adding ‘off-by-one errors’ was added. Who knows who came up with that one.

Cache invalidation is an interesting and genuinely fiddly engineering problem which we will not explain just yet; the other two are funny jokes, right? Like, yeah, it’s kinda important to come up with good names for things, but at the end of the day it doesn’t matter that much. They’re easy to replace with modern tools. And off-by-one errors are just a common type of accidental slipup.

But actually…

The very first thing you will probably be taught to do in any programming tutorial is “assign a variable”. Let’s go ahead and do that right now.

fn main() {
    let some_number = 1337;
}

Ignore for now the fn main() {...} wrapper, we’ll talk about that later, it just tells our program where to start.

The line breaks down…

• let says we are about to name something
• some_number is the name we are bestowing
• = says we are assigning a value to this name
• 1337 is the value we are assigning
• ; ends the expression/statement (in Rust, everything is an expression)

If we compile and run this program it won’t do anything. (You will get a warning about an unused variable too.) But we have nevertheless expressed a desire in the language’s syntax: we have said we wish for something to exist, and we have given that ‘thing’ a name. That name is some_number. We have also stored a value behind this name. This is the integer 1337.

What has actually happened, though? According to the language’s semantics, all that we have declared is that we want the name some_number to exist, and that it should contain the value 1337. This means, if, later in the program, we write some_number in a place where a name is expected, it can be replaced by the number 1337.

Where in the computer is the number 1337 actually stored? Logically, it is a place called the ‘stack’, but the compiler has some freedom here: maybe it will store this in a CPU register, maybe it will put it in memory.

Alternatively, as in this case, it will actually determine that we never look for the contents of the name some_number, so it can safely be deleted from the program. After the compiler’s done its work, the value 1337 won’t even appear anywhere.

We can add some special magic to the program to tell it to contact the operating system and write to the console.

fn main() {
    let some_number = 1337;
    println!("some_number = {}", some_number);
}

What does println! mean? This is a Rust standard library “macro” which is actually doing quite a lot under the hood. It is saying: ‘format’ a string, then ask the operating system to write it out to the console. ‘Formatting’ a string involves filling in the gaps where we’ve written {} with values from our program. There are lots of different ways to format things, but that would be a distraction.

For now, I will just say this: this is a piece of prebuilt machinery, a spell which Rust provides us. Later, we will certainly find out what’s going on under the hood; for now, we really need to see something come out of our program so we will have to leave it unexplained. This is the simplest way to build up some other ideas.

All you need to know then: you can write println! followed by something in parantheses. The first line must always be a template, wrapped in quotes, "like so". Any place you put {} in the template, you can then put a value from the list that comes after. The first value goes in the first {}, the second value in the second {}, and so on. (You can actually put additional information inside the {} to make it print it in certain ways, such as {:09} to print a 9-digit long number padded with zeroes; I won’t explain that right now but if you are dying to know about it there is information here.) Try playing around a bit with println! templates.

semantics vs instructions

What we are observing here is that, unlike the assembly language we saw earlier, a Rust program doesn’t correspond to machine code in a simple way at all. The compiler takes our program and spits out some machine code which ‘matches up with’ what we wanted the program to do.

Using Compiler Explorer, we can actually see exactly what comes out of the compiler. With some knowledge and effort, it’s possible to line things up, but actually most of this code is just setting up to run println! for us.

So what’s going on? How should we understand this?

A Rust program does not describe machine code, exactly. It describes what an ‘abstract machine’ should do. The code generated by the compiler ‘matches up’ in the following way: for a given input, the program is obliged to result in certain things where it touches the ‘outside world’. In this case, there are no inputs (or are there…), so the compiler must have the program print the number 1337 to the console. How it actually goes about doing that is its business.

If you write let some_number you’re saying that the compiler should know about this name, which we call declaring an identifier. Then the = 1337 is performing assignment: we are associating that name with a value.

Note that this is not the same as asserting there is a mathematical equality, it’s not like an algebraic equation, despite using the same ‘equals’ sign. Assignment in this type of language is an action: the thing on the right is put inside the thing on the left. There is a before, where the equality might not be true, and an after, where it is. Some languages might use a different syntax like some_number <- 1337. But Rust follows the tradition of C-like languages in which a single = always means assignment.)

A Rust program describes a series of statements about how we want things in the abstract machine to change. For example, let’s add some numbers…

fn main() {
    let leet = 1337;
    let acab = 1312;
    let sum = leet + acab;
    println!("{} + {} = {}", leet, acab, sum);
}

We are assigning ‘the result of adding 1337 and 1312’ to the identifier ‘sum’. At the end we’ve got a line which prints out all that stuff we declared, slotting it into the designated boxes in a sentence template.

One intresting wrinkle of this is that the state of things is different on each line of the program. Let’s try printing out the value of sum before we’ve declared it…

fn main() {
    let leet = 1337;
    let acab = 1312;
    println!("sum: {}", sum);
    let sum = leet + acab;
    println!("{} + {} = {}", leet, acab, sum);
}

In your IDE, or if you try to compile, you should get a red squiggly line under ‘sum’, and it will say:

error[E0425]: cannot find value sum in this scope

On this line of the program, sum does not exist. It only exists after we declare it. But what’s all this about scope?

In Rust, curly braces do something quite special. They create a kind of mini world in which the names we give are allowed to live. Let’s give it a try. (We have added comments, lines of code which do nothing, by writing // at the start of each one.)

fn main() {
    let leet = 1337;
    
    //scope begins here
    {
        let acab = 1312;
        
        //this will not give an error
        let foo = acab;

        //this is fine too
        let bar = leet;

        //scope ends here
    } 
    
    //this will give an error
    let sum = leet + acab;
    println!("{} + {} = {}", leet, acab, sum);
}

Inside the inner pair of braces, we define the names acab, foo and bar. We can refer to the name acab inside the braces, since it has been defined. We can also refer to the name leet, which came from the ‘world outside’.

However, at the end of the scope, the closing brace }, everything that was declared inside the scope is destroyed! If we try to refer to acab again, it fails. Names do not last forever. We are constantly ‘stacking’ scopes on top of each other (e.g. by calling functions, we’ll get to that in a moment). When we leave a layer of the stack, it disappears, and all the names it knew about are forgotten…

It might not be obvious why this is useful yet, besides avoiding accidents when the same names are used in multiple places… but it all relates to some of Rust’s other useful features to do with memory management and lifetimes. We’ll get there.

There is no concept of scope or names on the level of assembly. There are just registers and memory addresses. Scopes are part of the abstract machine, also known as the semantics of the language.

shadowing

This is honestly a bit niche, but worth mentioning: you can replace a name with another name. This declaration lasts until the end of its scope, after which it falls away and reveals the old name again.

fn main() {
    let foo = 1312;
    {
        //the previous foo becomes 'shadowed'
        let foo = 1337;

        //prints 1337
        println!("Inner foo: {}", foo);
        //inner foo is dropped
    }
    //prints 1312
    println!("Outer foo: {}", foo);
}

This is called ‘shadowing’, and many languages do not have it. It is useful to know about, though.

mutable variables

So far, we have never changed the value we’ve stored behind a name. This is called ‘mutation’. Traditionally, the things behind names could always be mutated, which is why they tend to be called ‘variables’.

Rust also allows mutation, but we have to explicitly say we want to allow it when we name something. Here’s a simple example:

fn main() {
    let mut tobias_form = "human";
    println!("tobias is currently a {}", tobias_form);
    tobias_form = "hawk";
    println!("tobias is currently a {}", tobias_form);
}

If we hadn’t included the mut when declaring tobias_form, we’d get a compilation error when we try to assign a new value to it.

Note that with mutable variables, you can ‘reach outside’ the self-contained world of a scope.

fn main() {
    let mut tobias_form = "human";
    let cassie_form = "human";
    print!("tobias is currently a {}", tobias_form);
    print!("cassie is currently a {}", cassie_form);
    {
        //time to battle some yeerks!
        tobias_form = "hawk";
        let cassie_form = "horse";
        print!("tobias is currently a {}", tobias_form);
        print!("cassie is currently a {}", cassie_form);
    }
    print!("tobias is currently a {}", tobias_form);
    print!("cassie is currently a {}", cassie_form);
}

Oh no! Tobias got stuck as a hawk!

Mutable variables are generally more complicated than immutable ones because they might be mutated in all sorts of different places. They make it easier to create bugs if you assume a name refers to one thing but it’s actually a different thing. So it’s a good idea to only make things mutable when they need to be mutable.

what is a language for?

The function of a programming language is to let you express, as clearly and precisely as possible, the intent you wish to perform. In practice, this means describing a number of abstract entities you wish to bestow an ‘as if’ existence. The compiler will then do the hard work of arranging the world in order to fulfil your wish. You need to meet it halfway, though: understand how things work enough to speak a language it understands and follow the rules.

So far we have just given names to some numbers. Soon we’ll be making other things: data structures, functions, types, and all sorts. Then, we can describe how these abstract things should interact with each other.

Could you have a programming language which does not involve bestowing names? Yes, certainly: you could, for example, directly push and pop things onto a stack with suitable commands. It would be a headache and you would not be using your superpower as a language-using creature, which is to invent new concepts and attach them to words.

Ah, but all this adding numbers together is pretty boring, isn’t it. Let’s work through a more complex example: a simple dungeon game to be played in the console.

a dungeon game

You may have played a game like this before. You have a bunch of ascii characters expressing walls and creatures. Like this…

############
#..........#
#..@.......#
#.......g..#
#..........#
############

In this world, creatures live on a grid. (Grids are easy to represent.) The position of the player is represented by an @ sign. There is another creature, represented by the letter g, in the room.

What does our program need to do? On a high level…

• it needs to communicate the state of the game to the player.
• it needs to receive input, representing the player’s next action.
• it needs to update the simulation in response to the player’s action.
• it needs to update the displayed game state

How can we go about doing this? We need to describe the actions that should be taken with the abstract entities we’re naming. There are multiple ways to do this, but we’re angling towards writing functions.

second orb to ponder

Here’s a slightly annoyingly written Rust program to fuck about with names and scopes:

fn main() {
    let spell = "Y";
    {
        let spell = "X";
        print!("{}", spell);
    }
    {
        print!("{}", spell);
        let spell = "Z";
        print!("{}{}", spell, spell);
    }
    print!("{}", spell);
}

Can you work out what it prints? (print is the same as println mostly, it just does not put a newline at the end so you can keep writing on the same line.) Write down a guess, then run it and see if you’re right.

Most of the time you will not be directly putting pointless scopes and constantly shadowing variables in the middle of a function like this! But functions, loops, conditionals and the like all depend on scopes to work.

This is one big part of the puzzle. The next powerful spell is functions.

1. functions
   1. functions abstracted
   2. side effects
2. types
   1. types are enforced at compile time
3. A function to display the dungeon
   1. loops
4. buffering with arrays
5. a third orb to ponder

functions

Much like the programs inside the operating system, we can think of the inside of a program as being made of smaller pieces called functions. We’ve already seen a function: fn main() is Rust’s way of declaring that there is a function called main. By default, Rust programs always do a little setup stuff and then start in the function called main.

There are several ways to look at functions. One is that you run the function, it does some calculation, and then it returns a value to the place that called it. In Rust, this is defined like so…

fn give_me_four() -> i32 {
    4
}

This is a function which always returns the integer value 4. The beginning part is the most important. It breaks down like this:

• fn says that we are declaring a function
• give_me_four is the name we are assigning to the function
• () is where the function’s arguments would go. this function has no arguments
• -> is used to indicate the return type of the function, more on that in a sec
• i32 is the type of a 32-bit integer, more on that in a sec as well
• { begins a scope, the ‘function body’, which is what the function actually does
• 4 is an expression (a single calculation), in this case just the value 4. it does not have a semicolon so it gets returned
• } ends the function scope

Note that in Rust, unlike a lot of other languages, we don’t usually need to use a keyword such as return to leave a function. If the last line of the function is an expression without a semicolon, that is what gets returned.

You can call this function like so, by putting some parentheses right after it:

fn main() {
    let hopefully_four = give_me_four();
    println!("given {}", hopefully_four);
}

Calling a function means you jump into the function, run its code, and then come back to where you left off. It’s sort of like you dropped the function body right there as a scope, like this:

fn main() {
    let hopefully_four = {
        4
    };
    println!("given {}", hopefully_four);
}

To be useful, functions usually need to have arguments which are filled in when the function is run. Here’s a really boring example:

fn add_four(num: i32) -> i32 {
    num + 4
}

This function takes a 32-bit integer, adds 4 to it, and then returns the result of this calculation. We can call it by putting a value into the parentheses after the name of the function.

fn main() {
    //we can put a number in
    let four_more_than_twelve = add_four(12); //16

    //we can put a named identifier in
    let leet = 1337;
    let four_more_than_leet = add_four(leet); //1341

    //we can put an expression in.
    //this means we'll evaluate the expression and then put the result into the function.
    let four_more_than_an_expression = add_four(leet + 12); //1353

    //rust won't let us call the function with the wrong number of arguments
    let error_too_few = add_four(); //error: no argument
    let error_too_many = add_four(5,6) //error: too many arguments
}

Just like before, it’s as if the function was inserted where we called it, but assigning names to hold each input.

fn main() {
    //this...
    let four_more_than_twelve = add_four(12);

    //is essentially the same as...
    let four_more_than_twelve = {
        let num : i32 = 12;
        num + 4
    };
}

The compiler might do exactly that, instead of jumping. This is called ‘inlining’.

functions abstracted

Although I’ve described a function as a series of instructions to perform, this is not how a mathematician views a function. A mathematician thinks of a function as a ‘mapping between sets’, like a bunch of tiny little arrows from each input to each output. For our add_four function, 0 is mapped to 4, 1 is mapped to 5, 2 is mapped to 6, and so on.

The actual instructions used to perform this mapping do not matter so much. Many different sets of instructions can be used to represent the same function, as long as they give the same output for every possible input. The compiler can take advantage of this, by finding a faster set of instructions to ‘do the same thing’.

Thinking about functions as just a mapping only really works if we have what are known as ‘pure functions’: functions which don’t touch anything ‘outside’ the function, just quietly do their calculation and pass back the result. But there are other types of function…

side effects

println! is also a function. (Technically, a macro that generates a function call. Don’t worry about that for now.) However, this type of function doesn’t simply make a calculation and then politely return it: it goes away and does something, in this case, tell the operating system that we would like to print out some text please.

This is known as a ‘side effect’. In Rust, functions can have side effects. In order to do so, they need to ‘know about’ something outside their own scope. This is called ‘capturing’.

For now, the only side effect we will concern ourselves with is printing things to the console. Pure functions are easier to reason about and usually allow the compiler to make things a lot faster to boot.

types

Let’s talk about data types! What’s all this i32 stuff? What’s a ‘32 bit integer` when it’s at home?

Well, an integer is a whole number. 32 bits means that it uses 32 bits (binary values, that can be 0 or 1) to store the number. This is the same as four bytes, since a byte is 8 bits. i32 is a signed integer data type which can store about four billion different whole numbers between \(-2^{31}=-2\,147\,483\,648\) and \(2^{31}-1=2\,147\,483\,647\). (You can get these numbers easily with i32::MIN and i32::MAX).

Once again, this is an ‘as if’ rule that belongs to the abstract machine. As far as the hardware is concerned, bytes are just bytes. Let’s say you have a register containing the 32-bit binary value 0000 0000 0000 0000 0000 0101 0011 1001. What is that? Maybe it’s an integer with the value 1337 arranged in big-endian order. Maybe it’s a string of Unicode characters. Maybe it’s part of an image. The computer does not give a shit: it will do whatever its next instruction says. If the next instruction is 32-bit integer addition then it will treat those bits as a 32-bit integer.

The compiler cares a lot, though. Rust is a strongly typed language, which means that as far as the language semantics are concerned, every name you assign also has a data type which defines what you’re able to do with it.

We’ve not been explicitly assigning types so far, because the compiler is pretty clever: it can assume that if you are putting an integer in something, it’s intended to have integer type. And by default, numbers without a decimal point have the type i32, so we can skip writing that.

We can be explicit if we want to, though. Let’s check out a few animals in the type zoo…

//this line introduces some names from elsewhere
use std::sync::{Arc, Mutex};

fn main() {
   let unsigned_acab : u32 = 1312;
   let bigger_acab : i64 = 1312;
   let float_acab : f32 = 1312.0;
   
   let acab_array : [i32; 5] = [1312, 1312, 1312, 1312, 1312];
   let acab_str_slice : &str = "1312";
   let silly_nonsense : Arc<Mutex<i32>> = Arc::new(Mutex::new(1312));
}

Here we have declared an unsigned 32-bit integer, a signed 64-bit integer, a 32-bit float, an array of integers, a string slice, and a slightly more complicated thing that I’m mostly including as foreshadowing ;p

The u32 uses the same space as an i32, but it only allows positive numbers. So it can store numbers from 0 up to 4294967295.

The i64 type uses twice as much space as an i32, allowing it to store numbers from \(-9\,223\,372\,036\,854\,775\,808\) to \(9\,223\,372\,036\,854\,775\,807\).

The f32 type is a floating point type. Floating point types are a special representation of numbers which allows fractions and large numbers to be stored in the same 32 bits. Just like i32 and u32, you have about four billion possible floats, but they are not spaced evenly on the number line: increasingly, more and more numbers are ‘missing’ the further away you get from zero. You also have special values like ‘infinity’ and ‘not a number’. Floats are quite weird and there are a lot of nuances to them; they are a leaky abstraction designed to approximately represent our intuitive idea of how real numbers work.

The last three are some examples of slightly more complex types that you will one day be able to express in Rust. They are respectively an array, a string slice, and an “automatically reference counted smart pointer containing a mutex containing a 32 bit integer”, which is the sort of thing you might sometimes need if you’re writing multithreaded programs.

But what’s the point of all this? Types exist so the compiler can help us. They let us express what something is supposed to be, and make sure, before our program even runs, that we don’t try to do something that doesn’t make sense. If a function is written on the assumption that its input is one thing, the types express that to the compiler so we don’t try to run it in a way that wouldn’t work.

types are enforced at compile time

Let’s add another line to this:

fn main() {
   let unsigned_acab : u32 = 1312;
   let bigger_acab : i64 = 1312;

   let causes_error = unsigned_acab + bigger_acab;
}

This last line will cause an error.

We’re trying to add a 32-bit unsigned integer to a 64-bit signed integer. Although that seems like it probably would make sense, Rust doesn’t know what sort of value you would want the result to be, so it hasn’t defined what addition does for these two types. Before you add the numbers together, you need to convert, or cast, the numbers into a compatible pair of types which can be added.

For simple types like this, it can be done with the as keyword to convert one type into the other:

fn main() {
   let unsigned_acab : u32 = 1312;
   let bigger_acab : i64 = 1312;

   let no_error = unsigned_acab as i64 + bigger_acab;
}

It’s always safe (in the sense that no information will be lost) to turn a u32 into an i64, but not the other way round. If the i64 is negative, or larger than the maximum u32, there is no mathematically correct answer for this operation. However, Rust has rules about what to do here. Essentially, casting down to a smaller type ‘truncates’ the integer, keeping only the last 32 bits. Negative values get a little bit complicated, we’ll brush over it for now. (Though feel free to try casting some negative integers to unsigned integers and see what comes out!)

Does this mean that we should always use the biggest available number type, such as i128? This is where the abstraction starts to get leaky again! Most modern processors work with 64-bit values. To handle a 128-bit number, the compiler is forced to generate multiple instructions, and the program will be slower. It will still follow the stipulations of the abstract machine… but the abstract machine is different from the real machine in an important way, and so the real machine has to do more work to satisfy the abstract machine’s demands.

There are other good reasons to want to use smaller types. For example, if you are crunching lots of repetitive data, like pixels, you want to pack the data into arrays, and it matters a lot how much space an array takes up, how quickly it can be loaded in and out of memory, and so on. In this case, there are good reasons to try to use the smallest type you can get away with.

Unsigned types are also useful because the compiler will make sure you don’t create negative numbers by accident. Indeed, one of the most powerful things we can do in programming is to create our own types to express the needs of our program to let the compiler help us out. We’ll do that soon, but let’s get back to the dungeon game.

A function to display the dungeon

Let’s imagine one way of displaying an empty room in the dungeon. We could print it out, line by line, like this:

fn main() {
    println!("#############");
    println!("#...........#");
    println!("#...........#");
    println!("#...........#");
    println!("#############");
}

However, we probably want to print out rooms of different sizes, and in different positions, and so on. And in general, if you find yourself repeating yourself, it’s probably a good idea to make a function to express your intent more clearly.

Let’s start by creating loops.

loops

One thing that computers are really good at is doing the same thing over and over again. This is such a common construct that nearly every programming language has some way to represent it. It’s called a ‘loop’.

Although so far the story has concerned Rust, I need to briefly talk about some history here. C, C++, and similar languages write loops like this:

for (int i = 0; i < 10; i++) {
    //do some shit
}

In C, this says: assign a variable of integer type called i; at the beginning of each loop, check if i is less than 10; at the end of each loop, add 1 to i.

In other words, it says ‘for each number from 0 up to 9 inclusive, do some shit’.

In Rust, this way of writing a loop can be done:

let mut i = 0;
while i < 10 {
    //do some shit
    i = i+1;
}

However, this is not how Rust likes to do things. Rust would generally prefer that you ‘iterate over’ something. It looks like this…

for i in 0..10 {
    //do some shit
}

In a Rust for loop, we are saying something slightly different: we have a thing we’re walking along, and we say, for each time round the loop, take the ‘next thing’ until we run out of things. This is more similar to how Python does it than how C does it. (Note that this time, the variable i only lives in each iteration of the loop, and doesn’t ‘leak out’ into the outer scope.)

The thing we’ve written here, 0..10, is called a ‘range’. It’s Rust’s way of representing ‘the numbers from 0 to one-less-than 10’. If you want to include 10, you can put 1..=10. You are more explicitly describing your intent (do something with every number from 0 up to 9) rather than how you go about achieving that intent; the compiler takes care of the fiddly details.

Ranges are not the only thing we can iterate over, but they’re the only thing we need to iterate over for now.

Let’s try putting a loop in our room drawing program…

fn main() {
    let room_height = 3;
    println!("#############");
    for row in 0..room_height {
        println!("#...........#");
    }
    println!("#############");
}

We could also have another loop to represent the width of the room…

fn main() {
    let room_height = 3;
    let room_width = 9;
    for column in 0..room_width+2 {
        print!("#")
    }
    //print a newline to end the row
    println!();
    
    for row in 0..room_height {
        print!("#");
        for column in 0..room_width {
            print!(".");
        }
        println!("#");
    }
    
    for column in 0..room_width+2 {
        print!("#")
    }
    println!();
}

We can factor this out into a function, and pass the width and height in as arguments.

fn main() {
    print_room(11, 3);
}

fn print_room(width: u32, height: u32) {
    for column in 0..width {
        print!("#")
    }
    //print a newline to end the row
    println!();
    
    for row in 0..height {
        print!("#");
        for column in 0..width {
            print!(".");
        }
        println!("#");
    }
    
    for column in 0..width {
        print!("#")
    }
    println!();
}

Hang on, how are we using print_room before it’s defined? That stuff I said about how names only exist at certain points in time doesn’t apply for functions, just let bindings. Functions can be declared in any order, and they exist for the entire duration of the scope, which is in this case the entire program.

That’s a little repetitive. We have the row-drawing code twice. Let’s make that a function too…

fn main() {
    print_room(11, 3);
}

fn print_room(width: u32, height: u32) {
    print_horizontal_wall(width);
    
    for row in 0..height {
        print!("#");
        for column in 0..width {
            print!(".");
        }
        println!("#");
    }
    
    print_horizontal_wall(width);
}

fn print_horizontal_wall(width: u32) {
    for column in 0..width+2 {
        print!("#")
    }
    //print a newline to end the row
    println!();
}

By giving these individual bits of logic names, it is much easier to understand what the program is doing.

buffering with arrays

This code will work, and it helpfully separates concerns like ‘how big is our room’ from ‘what characters do you use to draw a room’. However, it’s not going to be a good basis for making a game on, because we can’t easily put anything in this room, we can’t easily draw more than one room, and it also may be inefficient to make so many calls to print!, each of which potentially has to bring in a lot of extra machinery. We could theoretically add checks like ‘is there a character in this square’, but that’s going to make our code quite convoluted.

It would be much better if we could have a kind of ‘working area’ where we draw the rooms and characters as separate operations, and then print the whole thing out at once.

Which is a wonderful excuse to introduce array types!

a third orb to ponder

You can clear the console by running

print!("{esc}c", esc = 27 as char);

which sends a special ‘control character’ signal which instructs the console to clear itself. (How do I know that? I googled ‘rust clear console’ and found a Stack Overflow thread which provided various answers; this one worked.)

You can also run this code to make the program wait:

std::thread::sleep(std::time::Duration::from_millis(1000/60));

which will make the program stop doing anything for 1/60 seconds. (Don’t worry for now about all this :: stuff: that’s just a way of looking up names. We’ll cover it more later.)

Using these two commands, and an extra loop, can you make an animation which causes the room to expand?

1. Chapter 14: The Great Court of Illusions
   1. the murder of Hideyoshi
   2. the murder of the four in the guest house
   3. the murder of Genji
   4. did Krauss do it?
   5. a verdict?
   6. Battler’s turn
   7. Knox% speedrun
   8. can we solve it for real?
   9. battler’s last gasp

Branwen wrote another wonderfully big comment, this time with some excellent analysis of Natsuhi:

On Tumblr, starry-carousel wrote:

Hello! I‘ve been reading your Umineko blog and since the solvability of the epitaph has come up a few times, I thought I‘d tell you that I think you can solve it! It‘s really really hard without hints, I think there‘s at least one piece of information you need to have in order for it to be solvable, and I‘d suggest trying to solve it with that in mind, trying it without that is basically moot. (There‘s something I‘d like to say here that‘s mostly based on stuff you already know, but I‘ll hold back just in case.) I have mostly solved it in the Flower discord and while it took me a really long time to get there, it was also very very fun and I really suggest trying to solve it with people who know the solution and can give you tips when you‘re stuck and point you in the right direction, I think you could enjoy it and I‘d also love to hear your theories.

I said I wanted to keep trying without handholding for now (although that does sound like a fun game), but I would definitely be amenable to being told when I have all the hints I’m going to get, and when the solution reveal is imminent.

Last time, Natsuhi was stuck in the closet while Hideyoshi got murdered. She narrowly avoided getting found in there, but she was caught in the corridor by Erika, who is about to make the case that she dunnit all.

There are a couple of outstanding mysteries—besides the epitaph, the significance of ‘who am I’ in the last episode could apparently do with a revisit, and it may be worth collating some thoughts about what Lambda’s game expresses about the ultimate Beatrice question as well—but for now I am feeling it would be best to press on into the episode. Without further ado, then…

Chapter 14: The Great Court of Illusions

We appear in a big marble room—the same marble room, perhaps, where Eva Beatrice was bestowed her title of Beatrice in episode 3. A sculpture of a plant with a glowing white orb at the centre stands at the centre of the room. Everyone, even the ‘witches on an even higher level’, is apparently here, and they are not allowed to think this is at all strange. The background is actually quite tall, scrolling up for a couple of screens.

It’s kind of gaudy—reminds me of Napoleon’s tomb in Paris, which is truly ridiculous if you’ve never seen it. Someone is going absolutely wild on an organ and choir synth on the background.

Well, she might stand to lose, but Lambda evidently won’t miss the opportunity to put on a big show.

Bernkastel remarks that outside of ‘the 18’, everyone must be illusions. Beatrice—this must be piece!Beatrice—retorts…

In Japanese, 「それを認めさせるのが妾のゲームでな。」 the verb used is 認める (mitomeru) which also has senses of recognising, noticing, allowing, observing and carefully observing. A versatile word!

For various personal reasons I (we) have been thinking a lot lately about the ‘reality’ of things that exist inside someone’s head: from the widely recognised ones like ‘thoughts’, ‘beliefs’ and ‘memories’, through abstract objects such as ‘sets’, ‘numbers’ and ‘computer programs’, and all the up to more elaborate and nebulous constructs such as ‘countries’, ‘the law’, and of course ‘plural systems’, ‘headmates’ and the related jargon.

Since you can’t directly physically interact with these things the way you might a physical object such as a ‘chair’, their ‘reality’ is somewhat more open to interpretation—but it seems that you would have a hard time understanding the world and the behaviour of the creatures that inhabit it without modelling their ‘existence’ somehow. ‘Acknowledging’ them, in other words. So seeing this presented in this light is quite interesting.

In any case, this is a ‘witches’ coven’, called in response to Erika requesting one: the Great Court of Illusions mentioned in the chapter title. Which is interesting, because I had sorta wondered if it was going to be run by Dlanor’s inquisitor court.

Lambda declares that the ‘lives and roles within this game’ of the pieces are officially over and this is the 24:00 showdown already. She gets everyone to introduce themselves. Notably Beatrice asserts her goal as:

Beatrice: I am the Endless Witch, Beatrice. My goals are to assert my own existence and to protect Natsuhi and Kinzo.

Battler—who apparently ranks just under witches in whatever hierarchy is operating here—simply says he’s here to fight ‘Beato… no, the witches’. Chiester00 informs him that he can’t initially speak, since he joined the game later than this point. Does his piece also get to participate? Erika is next, as the detective.

Next, the rest of the Ushiromiyas rapidly introduce themselves starting with Kinzo. Starting to hit ‘pronoun circle’ kind of vibes. ‘My name is Ushiromiya Kinzo, my pronouns are he/him’. Who’s gonna do it/its, come on. Anyway, each relative says where they are claiming to be in the narrative…

• Kinzo says he’s alive and is in hiding after escaping the window
• Krauss says he’s been kidnapped
• Eva, Rudolf, Natsuhi, Kyrie, Nanjo, Sayo, and Kanon say they’re alive
• Rosa, Jessica, George, Maria and Genji report that they died on the first twilight. Maria cracks a joke about it
• Hideyoshi says he was killed ‘a short while ago’
• Gohda and Kumasawa say よろしくお願いします (pleased to meet you)

The witch pieces Virgilia, Gaap and Ronove report in from a separate, equally ostentatious section of the room.

Remarkably my PS4 controller vibrated when Gaap appeared. I’ve not seem the game activate rumble before (though it may be that it wasn’t able to on Windows). Spooky!

Lucifer reports that she ‘served in the murder of Hideyoshi on the second twilight’, and the Seven Sisters report in.

The Inquisitor group report in, with Dlanor identifying herself as Erika’s assistant. So there’s a few layers to this hierarchy! Erika says that Dlanor’s main responsibility is ‘tricky word games’, like the ‘miracle’ in the study.

Finally, Chiester00 says that the Chiester Sisters Imperial Guard have been tasked with ‘management of proceedings’, and helpfully offers the sum as 38 ‘people’. (I guess the goats aren’t along for this one.) Breaking that down:

• 2 ‘player’ witches
• 1 ‘piece’ witch (Beatrice)
• 2 special human pieces (Battler, Erika)
• 11 humans who claim to be alive, of whom one is in hiding, and one is allegedly kidnapped
• 6 humans who claim to be dead
• 10 magic pieces backing up Beatrice
• 3 magic pieces backing up Erika
• 3 Chiesters overseeing

The goats seem to be along after all, since the witches immediately call for drinks and popcorn from them. But they evidently aren’t ‘people’ as far as Chiester00 is concerned. (I guess they’re the ones with the #notaperson it/its in the pronoun circle lmao)

Erika is also plenty happy to showboat, calling silence very dramatically (and apparently suspending everyone’s consciousness) to declare…

Notably the earlier scene simply took place in the parlour, without all the ceremony—even if the events of the game are the same, it seems like the presentation can be different with Battler here?

In this context, Beatrice is able to step up and act as Natsuhi’s defense. Although this is a rather unusual court, because the defense is trying to prove that they did the crime, against Bernkastel’s claim that a human, and specifically Natsuhi, did it.

This is a pretty specific claim for the ‘mystery’ side (I can’t exactly call them the human side.) They can’t switch to some other potential culprit after this, right? Instead of “Beatrice Dunnit” and NOT(“Beatrice Dunnit”), we have disregarded a lot of the possibility space.

They make clear that if Beatrice loses, she will be destroyed along with the witch illusions of this game. She is fighting for her life. Also, this would be true of any previous games. (Battler briefly comments that Erika has nothing to lose, but Virgilia assures him that it will be anything but a good time for her. It really is a thunderdome situation right here.)

So what have we got?

the murder of Hideyoshi

Erika says everyone besides Natsuhi and Hideyoshi were in the same room, the parlour, at this point. This… on the face of it, is kind of obviously not true? Nobody knows where Krauss is, they only know he’s missing.

Anyway, Beato starts with the locked room. Erika says we’ll get to that later, and actually uses the ‘dunnit’ language!

It seems that ‘-dunnit’ has made its way to Japanese: ハウダニット (haudanitto) and フーダニット (fuudanitto) for how- and whodunnit respectively. (Since Japanese doesn’t really have a ‘hu’ phoneme, it has to adapt to the nearest, ‘fu’.)

After a moment consulting with her legal team, Beatrice says that it would be less confusing to proceed chronologically. Bernie immediately objects. Beato counter-objects. Both say ‘objection’ if the pointing pose wasn’t enough earlier…

Battler has a little first-person-narration soliloquy suddenly: this, he thinks, is ‘how the tales of Rokkenjima are created’: by both sides putting forward claims.

the murder of the four in the guest house

Erika sighs and gets on with it. She says Natsuhi had no alibi from when she left until when she returned; a point that apparently merits a text card to declare it.

Beatrice’s counters also get nice little summary cards, each one appearing with a dramatic impact. These continue throughout the scene to tell us the main points of each argument.

I won’t copy out these alternative hypotheses because I suspect that they will get struck down in short order. Indeed, Bernie and Erika promise to do just that.

Erika gets Gohda and Kumasawa to say whether they were in the guesthouse. Gohda confirms he was on duty, Kumasawa says she went to bed in the servants’ quarters there. Natsuhi seizes on this, but Erika says she saw them both go into the servants’ quarters from the lounge and stay there until morning. How’s she going to prove that? Presumably the anti-tamper seals come into play now.

Beato demands proof of the alibis in question. Since her opponents don’t answer to a repetition request, and Erika insists she can fight back on her own without Dlanor, Beato drops a blue:

Beatrice: Gohda and Kumasawa have no alibis. The two of them were in the guesthouse and could have reached the cousins’ room to commit murder at any time. Unless you can eliminate that possibility, you cannot treat Natsuhi as the culprit.

It’s interesting that Beato is arguing for a mundane explanation here. She isn’t claiming to have done the murder by magic. But I guess that wouldn’t be consistent with her narrative of working for Natsuhi this game; if she committed the murders on Natsuhi’s behalf, that would still be Natsuhi’s fault, right?

Curiously, Gaap and Ronove say that Erika, as a human, can’t use the red. This seems to contradict the fact that she’s already used it, e.g. to declare herself the detective..? Ah, well, I guess she can’t here at any rate.

Instead, it is indeed the anti-tamper seals. She explains how she sealed the door to the servant quarters after Kumasawa entered. Despite all they said about not using the red, Bernkastel goes ahead and declares it in red anyway:

Bernkastel: ………. A wonderful alibi. Absolutely airtight. Kumasawa returned to the guesthouse with Erika, went to the servants' quarters to sleep, and never left the room until morning. In other words, after Kumasawa returned to the guesthouse, she never went to the second floor until morning.

This red means we can’t quibble about other exits to the servants’ quarters. That has probably been established at some point anyway, and we have Knox forbidding secret doors. (‘Morning’ is slightly ambiguous, mind you, but with the broader context we can probably take Erika’s seal to be decisive..?)

Erika says she sealed Gohda in the servant room in the same way, and when she saw Rosa get back at 1am, informed Gohda she was present. At that time the seal was intact. Afterwards, Gohda hung out with her until 3am, and Erika was watching upstairs after that. (So… she just stayed up all night? Or she’s a very light sleeper?)

This one also gets confirmed in red:

Bernkastel: ………In other words, after Gohda returned to the guesthouse, he never went to the second floor until morning.

Is it meaningful that ‘in other words’ is in red? It is a red truth that the red claim is a rephrasing of the information in the previous dialogue?

We are progressing through the checklist. I’ll have to check whether I agree it’s exhaustive but let’s get through this first.

She decides to summarise the positions of everyone. She saw three of the kids alive at midnight, and this gets to be red as well:

Bernkastel: ………At 24:00 in the guesthouse, George, Jessica, and Maria were alive, and they were in the second‐floor cousins’ room. Nanjo, Gohda, and Kumasawa were on the first floor.

And also:

Bernkastel: George, Jessica, Maria, Rosa, and Genji—these five really are dead.

Though it’s not clear where this is scoped on the timeline! We have that it is impossible to mistake their dead bodies, and that as of this point in the storyline they are dead. However, we don’t actually have that they were dead on the morning when Battler found them. How could that be? Well, maybe the ones who discovered the bodies conspired to deceive Erika about the identity of the bodies. I do not believe she personally got the chance to inspect the bodies up close!

More interestingly, we get a confirmation of the location of some of the others…

Bernkastel: at 24:00, Natsuhi, Krauss, and Genji were in a corridor on the second floor of the mansion. All the remaining people were at the family conference in the dining hall. Of course, at that point in time, no murder had occurred. Genji was also alive.

So officially whatever happened happened after midnight—but also we can confirm that Natsuhi, Krauss and Genji were not running about anywhere other than where we saw them at the time of the knock.

Lambda notes this is kind of a freebie, since Erika was not able to observe who was in the mansion.

Battler, silently observing, notes in his first-person narration that Beato must have been going easy on him in the earlier games, being very generous with the red truth repetition requests even when it was ultimately to her disadvantage. Beato (possibly privy to what Battler is thinking?) brings up the ‘incompetent’ line and promises she can handle it.

Nanjo is next up for elimination. He confirms he was with Erika between 1am and 3am, and it gets elevated to red. (Hey, is red truth a monad?)

Bernkastel: From 1 a.m. to 3 a.m., the trio of Erika, Nanjo, and Gohda… spent their time in the lounge on the first floor of the guesthouse.

Outside of that? Beato shoots a blue:

Beatrice: Even so, he shouldn’t have an alibi for the time period before and after you were in the lounge! It was possible for Nanjo to commit the crime too.

Erika says she met Nanjo on the stairs and talked to him about mystery novels (of course) in the archive until 1am. (Conveniently leaving a window in which she wasn’t watching the guesthouse for the crime to take place?)

Bernkastel: After 24:00, Erika was with Nanjo the whole time until 3 a.m.

After 3am, she put one of her seals (she made a lot of them!) on Nanjo’s room. But hold on a minute, what about the window? We know from the events of other episodes that the windows to the guest house can be opened, and unlike the servant quarters, it seems less likely that Nanjo was in a windowless room..? Well, put that on hold for now, because it looks like we’re up to eliminating ‘Battler dunnit’, and this should be interesting.

The window theory ultimately doesn’t matter because we get it in red:

Bernkastel: Both your seal and your red truth are perfect. Nanjo had the alibi of being with Erika until 3 a.m. And he didn’t leave his room after 3 a.m. until morning.

Wow, a ‘perfect’! Erika’s really raking in the Good Girl points.

In fact, the question of ‘Battler dunnit’ is raised by the man himself! (Who appears to be operating from the POV of player!Battler rather than piece!Battler right now.)

He gets smacked with the Chiesters’ weapon for speaking out of turn, but Beato does take the suggestion. She doesn’t seem to particularly like it, though.

Beatrice taunts Erika, suggesting that she might have watched Battler sleep to confirm his alibi. Erika calls her bluff, saying that she could hear that nothing significant happened in the guesthouse until Battler woke up and screamed, thanks to the thin wall. And she stayed up all night to do so. The absolute madlass.

I love how contorted the detective’s actions are having to become here.

Bernie explains that she ordered Erika to do this (so she does have a direct line to her pieces in this instance!) and ordered her to listen all night in case Battler was a victim. And of course she’s a ridiculous minmax build with hearing ability ‘on par with a tape recorder’… which isn’t actually that big a boast, really? Tape recorders have pretty crap sound quality compared to the human ear. Well, whatever.

This time, it falls to Lambda to confirm it in red; she says this is an ‘accepted power of the detective’s authority’.

Lambdadelta: Ushiromiya Battler returned to the cousins’ room at 3 a.m. and fell asleep. After that, until the discovery of the crime, absolutely nothing out of the ordinary happened in the room!

Bernkastel: In other words, it was impossible for Battler to commit murder or damage the corpses.

They sure seem to be working together against Beato at this point…

So, that leaves theories involving the group in the mansion taking place between midnight and 3am. We know Erika was not watching the lounge between midnight and 1am. But first we cover the possibility of climbing in from the outside.

Beatrice: For example, what if someone placed a ladder against the outer wall of the guesthouse and snuck in through a second‐story window?! There must be a way to reach the second floor without passing through the lounge! If this is the case, it would be possible to reach the crime scene without you seeing it…!

We confirm that there is no stealth route in the building in red pretty quickly:

Bernkastel: It is impossible for someone to reach the second floor of the guesthouse without anyone in the lounge noticing it. ……Though of course, this only refers to reaching the second floor from inside the building.

We can have a second ‘of course’ statement add an exception to a previous red statement? Huh.

Erika says she was able to prevent all entry on the second floor. What, did she put seals on all the windows? Feels like we’re getting ‘the devil’s anti-tamper seal’ at this point. Virgilia says that, for a human, this would be ‘an impossibly dubious action’, but as a witch piece… Erika doesn’t have to worry about such trifling matters, I guess, as motivation or plausible behaviour. The narration starts increasingly calling her a spider.

Erika makes a slightly deranged declaration that, for detectives, someone will die wherever they spend the night, and only third-rate detectives would not prepare this thoroughly. She really is something else. The idea of detectives going about knowing that they have some kind of Elric-ass death curse on them is really funny. And hilarious as an alternative to ‘magic is real’.

All this effort earns her another red statement from Lambda:

Lambdadelta: It was impossible to reach the second floor of the guesthouse without passing through the lounge, and impossible to reach it at all without Erika, who was in the lounge, knowing about it!

I feel like there’s a possibility that is missing from the checklist. I don’t believe we have had it confirmed in red that the deaths were homicides, right? Let me check… yeah, we didn’t even have the bodies confirmed until later. So, let’s say for example that Rosa killed the three kids between 1am and 3am, and then killed herself. That does leave open the question of where the weapon is, she wouldn’t exactly have time to hide it after cutting her own throat. But this should be on the list…

Erika takes a moment to declare in blue her conclusion so far:

Erika: Therefore, the time of the crime is limited to the single hour between midnight, when they were confirmed to be alive, and 1 a.m., when our party in the lounge started!

(I didn’t catch on to this until later in the chapter, but Erika’s argument is contradictory! If Rosa was in the mansion until 1am, and the crime could only have been committed in this window, there would be no opportunity to kill Rosa at this time. More on this later.)

Bernie repeats the line about the locations of mansion people at 24:00, and also adds:

Bernkastel: Of all the people in the dining hall, not one of them left the dining hall until 1 a.m.

Notably she doesn’t use any red in relation to the mysterious knock at the door.

Beato demands to know how that can be proved, and gets reminded that red truth is axiomatic:

Bernkastel: The red truth is simply truth, and there is no need to provide evidence, proof, or room for a counterargument!

But as we’ve seen, there are restrictions on when you’re allowed to use the red truth if you aren’t the GM. Lambda could freely declare this, but how can Bernie?

the murder of Genji

Well, evidently she can, and she is not challenged further. So, Genji then. There’s no argument for this one: Bernie just redtexts it by fiat.

Bernkastel: When Genji finished transferring the call, he immediately returned to the servants’ quarters.

This refers to ‘the call’ in red, which suggests there was in fact a call? If not necessarily from Phone Man…

Now, Eva gets called to the stand. (And credited with inventing the seals.) Eva declares that when Rosa left at 1am, Eva put the seal we saw earlier on Genji’s quarters—so either Erika’s signature was a mistake in the art, or she used one of Erika’s spare seals from her apparently unlimited supply. Also red:

Bernkastel: At 1 a.m., Eva sealed Genji’s sleeping quarters, and that seal was broken by Kanon and Kumasawa in the morning when the crime was discovered

Bernkastel: During the short break at 1 a.m., the first two to leave the dining hall were Rosa and Eva. Until Eva returned, everyone in the dining hall remained there. After seeing Rosa off, Eva went to the sleeping quarters and sealed it. Of course, she did not enter the room at all at this time

Erika also adds, as if in answer to my earlier concern, that these are not ‘baseless red truths’ but she got them from the people involved. And apparently she took fingerprints and stuff besides relying on testimony. I immediately start wondering ‘with what equipment’, and…

Sure, we’ll just Devil’s Proof up a forensics kit while we’re at it. The narration lists a few of the alleged investigations: aluminium powder, ‘composition analysis’ on mud, ‘various chemical reactions’ on rainwater. I am reminded of a memorable passage from a book called Mastering Erotic Hypnosis by James Gordon and Rebecca Doll (yeah we’ll just put that cite in here :3), which talks about how a hypnotist establishes their narrative sense of authority in the process of building a ‘hypnotic modality’.

Which is to say, there is no scientific argument here. Erika is simply gesturing at the epistemic authority which science claims in order to bolster her rhetoric, without doing any of the work by which science (ideally…) earns that cred. The narration highlights that she used Kinzo’s gear without asking—transmuting, in a sense, her abstract ‘detective’s authority’ into a more concrete scientific sense of authority.

So we have now in red:

Genji never left the mansion after 24:00

which is presumably spoken by Bernie, though it doesn’t actually get put in a speech box.

did Krauss do it?

Which just leaves Krauss, and the murder-suicide theory.

Bernie invites Natsuhi to put the blame on Krauss. She refuses. Battler observes that Erika is pretty much just writing the story at this point, and getting it immediately approved by the GM; Virgilia confirms this is indeed how it works. In other words, this is, right now at least, a ‘quantum’ game more than a ‘blorb’ game. But the ‘final truth’ here may not be the ‘real truth’.

Virgilia has a little lecture that, even if Erika came by it in a ‘cowardly’ way, her truth is self-consistent and plausible, or it wouldn’t have been able to see so much confirmed in red. But Battler is not in a hurry to accept it this time (even though he was willing to point to various Ushiromiyas as potential culprits at the end of the last game.) It’s kind of an emotional thing:

………Even if Erika has accused Aunt Natsuhi of being the culprit, ……and even if everyone else here believes that, ……that’s exactly why I want to be the one person who trusts her…!

‘Stick up for the underdog’ is something of Battler’s ‘inner law’, here. But also by genre convention, it would be unsatisfying if Natsuhi turned out to have dunnit, so I think Battler is likely to be right. (It seems Krauss is also getting covered by this logic, mind.) But who’s left?

Battler contemplates the difference between truth and consensus. He decides this is just a kangaroo court designed to frame Natsuhi. And he criticises Beato for fighting too defensively, and failing to present a strong counternarrative as an alternative to Lambda. What’s he planning…?

It’s interesting because ‘failing to provide a good story’ has never really been Beato’s problem in the past. Indeed, her magic stories are all so sparkly and full of fun drama that you want to believe in them. She’s really been nerfed in piece form!

Battler, feeling that there should always be someone to argue the opposite case to any belief, contemplates his childhood belief that there was a society on the far side of the moon, a belief he abandoned after ridicule. He starts getting pretty hardcore empiricist with it, saying we should only believe if we’ve seen it ourselves. He further insists that no matter how many red truths are stacked against Natsuhi, he won’t believe she did it.

I feel like this one’s really hard, right? Without going into too much depth, an acquaintance in the sakuga fandom was recently convincingly accused, with extensive evidence, of sexually abusing a young person over a period of years. In a matter of hours he went from a respected member of the subculture to a pariah. The whole affair really threw me for multiple reasons (trust, judgement etc.) which this liveblog is not the place to elaborate. But one is this: I very much do not believe in absolute exile, yet in social spheres, when things break down, people must decide what to do: trust and defend their friends? Cut ties? Try to intervene somehow? People make their choices and the results tend to resolve to schism, exile or apologism, all of which suck. After all sorts of ugly situations, we have not found any generally robust principle. There probably is not one. A lot of infrastructure we might like does not exist.

But Battler’s right about one thing: we don’t have a proper ‘Natsuhi story’ here, and the sente is entirely with Erika right now. Apparently impressed with his resolve, Virgilia steps in to offer him a freebie red text, as a finite witch and former Beatrice…

Virgilia: Ushiromiya Natsuhi is not the culprit!

Oh dang thanks. OK. That does make things a lot easier…

Meanwhile, back in the courtroom, Bernie’s offering Beato a ‘plea bargain’: if she pins it all on Krauss, then Bernie will stop trying to pin it on Natsuhi. I had raised Krauss theories before so this is interesting.

Beato muses that the ‘cat in the box’ is the source of the endless possibilities of an Endless Witch’s power. Body without organs??? Ahem. Anyway because Krauss’s state is so nebulous it’s pretty compatible with witch theories and the game could be a draw.

I don’t think she’s gonna take it, guys. Natsuhi certainly isn’t in a hurry to let her.

Natsuhi: If you wish to insult me, go ahead! If you wish to ridicule me, do as you please!! But none of you can damage my honor with fiction!!

Beato has to decide whether to betray her. Ronove and Gaap advise her to do it. Beato raises the question of what will happen to the ‘Natsuhi of this fragment’.

Gaap mentions Deep Blue vs Kasparov, the match that famously established that computers could beat the best human in 1997, which was indeed won 3.5-2.5 by Deep Blue. An interesting example, because in the following decades, computer chess engines kind of left humans in the dust. In any case, Beato alludes to someone (Kinzo?) who stubbornly stuck to their guns…

Beatrice: …………My apologies, ………but I cannot do that. ………I know the strength of a man who believed even though everyone said he was wrong, ……and I know the suffering he went through when he was forced to abandon that belief…!

She makes an impassioned speech about truth, saying if she can’t defend this truth there is no point to her at all; she certainly has the mindset for a defense lawyer. But I get it. ‘Beatrice who accepted a plea bargain to hold onto “existence”’ would not be Beatrice any longer.

In response, Bernie officially rule out Krauss.

Bernkastel: By the name of Bernkastel, Witch of Miracles, I speak with the red truth. Ushiromiya Krauss is not the culprit. And he was killed long ago. Shortly after you heard his voice over the phone, in fact.

We do in fact get a death screen to go with this:

Ushiromiya Krauss

Murdered sometime after the early morning phone call by which Natsuhi learned he was still alive. His corpse has not been found, but his death has been guaranteed by Bernkastel with the red truth.

Very interesting! So that leaves wide open the question of who killed Krauss, because it certainly can’t have been Natsuhi if she was listening to him over the phone. So even if she did some of it (and we now know she did not), that rules out Natsuhi as a sole culprit.

Which means… what? Everyone has an alibi (except for the murder-suicide theory), and we also know Natsuhi didn’t do it. There is no room for Phone Man to exist, since we know from chapter 4 that

Lambdadelta: Besides [Erika], the number of people on this island is exactly the same as it was in the previous games

Admittedly, there are much fewer alibis for this.

a verdict?

Anyway, Lambda declares the verdict: Natsuhi killed all six, and since a human dunnit, the court can deny Beato’s existence.

Did Lambda intentionally lose the game to Bernie/Erika, writing her narrative to position the ‘magic side’ to have to disprove a mundane story? Beato never really got much of an opportunity to come up with a decent magic story in this game. And, supposedly, in failing to protect Natsuhi, the witch illusion is dispelled… because, I guess, we’ve ‘proven’ that the story was in fact a mystery all along.

I don’t really buy this. Admittedly, overtly magical acts have been rather thin on the ground in this episode (the bodies disappearing notwithstanding), but that just means that very little about the Beatrice narrative has been put to the test at all. It really doesn’t seem like Lambda was trying very hard to create a magical mystery. On what basis can this game deny Beato’s existence? At best, it shows that Lambda is a pretty weak GM. Given her goal was supposedly to prolong the game indefinitely, throwing it here seems very strange.

Natsuhi and Beato both give speeches about how they still have their honour and so on (the one-winged eagle carved into her heart). Bernie scoffs at her ‘bluster’, and declares she will send a final red truth to crush it. This should be good…

Bernkastel: Natsuhi. When did Kinzo ever say it was okay for you to engrave the One‐winged Eagle into your heart? Those were just the words of the Kinzo from your delusions. ……The real Kinzo? Throughout his entire life, not once…did he ever trust you from the bottom of his heart, and not once did he ever consider letting you bear the family crest!

Oh, so that’s what we’re doing.

Appropriately, the music drops out as Bernie delivers this line.

Kinzo (in this case, I suppose you would say introject!Kinzo?) tells Natsuhi not to listen.

Kinzo: No one can defile the crest engraved in your heart!!

Kinzo: そなたの心に刻まれた紋章は、誰にも汚されぬ！！

So of course Bernie keeps firing.

Bernkastel: The real Kinzo would never say such a thing. Begone, you fantasy of Kinzo inside Natsuhi’s mind, beautified by her to suit her own purposes.

Pitiful woman. Now is the time for you to face the truth that you never gained Ushiromiya Kinzo’s trust as long as he lived.

The narration repeats and emphasises the point: in this game, we only saw Natsuhi’s fantasy of Kinzo. Keep kicking her while she’s down, I guess. She flashes back to the few good times with her family in her shitty life, deciding she no longer has a right to them. Kinzo just sucked that much and yet she can’t take away his authority in her head anymore.

Erika chooses this moment to drop her catchphrase. Everyone claps, though the narration hardly dwells on it.

So… when does Battler get the right to speak up? Because I feel like there is at least one possibility we haven’t played (murder-suicide theory), not that it will do much for Natsuhi now that her entire life has been officially deemed illusory with the full force of narrative authority. Well, we leave the Court and go back to the parlour, where the relatives have accepted that Natsuhi was the culprit. Eva is hit hardest, and she lays into Natsuhi, demanding to know why. Only Battler tries to stop it.

Erika tells Natsuhi that, by the rule of the mystery genre, now the who- and how-dunits have been solved, the whydunit must be provided.

Erika: Natsuhi‐san. I’ve solved two of the three riddles. The whodunit. The howdunit. The final riddle—the whydunit—must always be confessed by the culprit herself. Please follow the rules of the mystery genre and confess.

If you’re wondering: ホワイダニット (howaidanitto)…ooh, that one’s really interesting, ‘why’ becomes two syllables here.

Beatrice, invisible to everyone except apparently Erika, protests; she is overruled, because she is not the truth ‘chosen by this world’. On the witch plane, Lambda sneers:

Fuck you I am a witch whether you say so or not, says Beato (paraphrasing); Lambda says something very interesting in retort…

Bernkastel: You wouldn’t even have been capable of believing that if I hadn’t become your guardian in the first place…!!

The word ‘believing’ is interesting, here. What does ‘guardian’ mean in this context? Going with the theory that this all goes back to Kinzo’s creepy orphanage somehow, and the theory of witches as people who hold elaborate fantasy ‘inner worlds’, could there be a real-world counterpart to Lambda who introduced the real-world counterpart of Beato to the practices of ‘witchcraft’..?

In any case, Beato lost, so by precedent it’s goat time. If you’re gonna do anything, Battler, now would be a fantastic time! There’s a cute little exchange:

Bernkastel: Let me hear some nice screams. You’re a bottle of wine we’ve been saving for this day.”

Beatrice: ……Then remaining silent will be my final strike back at you…

Bernkastel: Yes! I made her say it! Uhihihahaaah!! The screams of those who gift me that line as their parting shot are the most gratifying of all!

Ha, remember when we thought Bernkastel was the nice witch?

Battler’s turn

Suddenly someone cuts through the goats as they’re all chewing Beato… Battler? Nope. It’s… Dlanor!! Well, well, well…

Dlanor announces that someone—Battler, of course—has an objection. She warns him, though, that the court does have a time limit. (I’ve been reading this chapter all day lol, so probably quite a long one…)

Battler still feels like he has no idea what happened and it will be hard to present a counter-truth… but he has to improvise somehow. Bernie is pretty thrilled about this turn of events, evidently expecting him to go down quickly.

Despite intervening to let him join the fight, Dlanor is going to be his opponent. She gets all catte with it…

Battler’s initial line of attack is the seals. Of course, since we have had most seal evidence confirmed with red truth by this point, it doesn’t seem like there is a ton of point arguing the seals could be replaced.

But, let’s see, some options: first up, Eva. It took me a second to notice this, but we already know that she received some seals of her own from Erika and is aware of Erika’s seal-based plan, so she would have the opportunity to replace broken seals with intact ones. It’s the confused deputy problem… or in this case, the evil deputy problem. Indeed, Eva might have intentionally told Erika about the idea of seals in order to set her up to exploit them for alibis.

Battler’s initial blue doesn’t quite go that far. He suggests that someone noticed the seal and replaced it.

Battler: Can’t we doubt the reliability of these seals of Erika’s?! Something like wedging some paper in a door can’t create a perfect alibi! It might be that someone noticed by chance and happened to put it back in the same place

Erika counters that the seals are made with perforated duct tape and signed personally by her, consistent with the one CG we got of them. So, yeah, I think I’m onto something with the Eva thing. Anyway, let’s get the initial exchange, a red-blue volley:

Dlanor: Due to the above, the seals are guaranteed to be perfect. Miss Erika’s seals were not broken by anyone, and deception is impossible!!

Battler: I’ll acknowledge Erika’s seals…! However, Auntie Eva’s seal on Genji‐san’s room should be different!!

Dlanor: Eva’s seal was of the same type as Miss Erika’s. That is because this method of sealing was one that Miss Erika and Eva conceived of together after dinner.

‘The same type’ huh…

Battler: Erika fished through the chemicals in Grandfather’s room saying she’d use them for forensic testing, right?! There might have been some kind of solvent among them!! If you used that, you might be able to tear off the duct tape without leaving fingernail marks!!

Gertrude: For your attention: I beg to inform you of the following: It is impossible to tear off any of the seals by any method without leaving marks

Cornelia: FYAIBTIYOTF: There were no suspicious marks on any of the seals

Very carefully worded. If you put a fresh untampered seal where a broken seal was, you would cover up the marks left by the previous seal, I think? Though Bernie takes it a step further:

Bernkastel: All of Erika and Eva’s seals… were not tampered with in any way that hindered their ability to act as seals, such as being scraped off.

Taken literally this would probably rule out removing and replacing a seal.

Battler says he has something, but he left it ‘at home’. He says he would never break his promise to kill Beato; that he never breaks promises. Beato says that’s a lie. It seems it might be time to address the ‘sin’, then?

No, Beato just loses her shit and tells the other witches to finish the job.

Knox% speedrun

Battler starts getting desperate. He fires off a rapid series of challenges, all of which go against one or another of Knox’s rules. Since basically every line of dialogue in this section is red or blue I have to quote the lot. In between we go through just about all the red/blue VFX clips in the game’s entire library.

So we’ve scored Knox 3, 10, 1, 4, 8, 6, 7, 8, 9, 8… sorting that, 1, 3, 4, 6, 7, 8, 9, 10. That leaves 2 (no supernatural effects) and 5 (the racist one). Using 2 would amount to conceding the game, and the less said about 5 the better, so I think this is a reasonable 100%.

The important additional clues here are:

Gertrude: FYAIBTIYOTF: All deaths were homicides.

That rules out Rosa killing everyone and then herself.

We have a few more ‘Umineko versions’ of the Knox rules.

Dlanor: Knox’s 1st: It is forbidden for the culprit to be anyone not mentioned in the early part of the story!!

Knox put this as:

The criminal must be mentioned in the early part of the story, but must not be anyone whose thoughts the reader has been allowed to know.

This would actually rule out Natsuhi as the culprit, since we’ve had a few scenes from her first-person perspective already! I’m not sure if the latter clause was purposefully elided, or if it just doesn’t apply to Umineko.

Dlanor: Knox’s 6th: It is forbidden for accident or unaccountable intuition to be employed as a detective technique!!

Knox originally put this:

No accident must ever help the detective, nor must he ever have an unaccountable intuition which proves to be right.

So this one’s a pretty close translation for once.

Then there’s this exchange:

Battler: Th‐this story is full of malicious fiction!! The story itself is a trap designed to frame Aunt Natsuhi! We should reconstruct the story from impartial truths alone!!

Dlanor: Knox’s 9th: Observers are permitted to put forward their own conclusions and interpretations!

Knox put this:

The “sidekick” of the detective, the Watson, must not conceal from the reader any thoughts which pass through his mind: his intelligence must be slightly, but very slightly, below that of the average reader.

We don’t have a “sidekick” character per se. Our main POV character, Battler, does constantly get told he’s stupid and incompetent, but he’s not really in a Watson role at all. Then again, the convention is definitely that Battler will not solve a mystery within the episode in order to give us time to figure it out ourselves. But who knows…

can we solve it for real?

So, with all that, the dust is settling. Battler says he has one last thing. Let me pause him a second… because I feel like we should have enough to come up with a solution for this episode now. A positive truth that can make sense of the whole affair. Let’s take stock…

• Natsuhi does insist that she was being blackmailed
• by all accounts there was no possible way for the knock to happen at the door at midnight, but perhaps everyone there could be implicated in a conspiracy to claim someone knocked
• it is possible, if a little of an edge case, that Eva is able to duplicate Erika’s seals.

Despite a redtext that comes pretty damn close to denying it, the last one stands out to me, since it feels like it was a clue that was set up earlier in this chapter. We know Eva knows about the seals, we know that she knows what Erika’s seals look like, and the art for that scene very clearly showed Erika’s signature and not Eva’s.

Let’s check what actual red text we have about Genji.

Bernkastel: When Genji finished transferring the call, he immediately returned to the servants’ quarters.

Hold on, now… when was that? That sounds like it was before 1am.

Bernkastel: At 1 a.m., Eva sealed Genji’s sleeping quarters, and that seal was broken by Kanon and Kumasawa in the morning when the crime was discovered

Bernkastel: During the short break at 1 a.m., the first two to leave the dining hall were Rosa and Eva. Until Eva returned, everyone in the dining hall remained there. After seeing Rosa off, Eva went to the sleeping quarters and sealed it. Of course, she did not enter the room at all at this time

Genji never left the mansion after 24:00

So when did ‘Genji finish transferring the call’? According to the narration, which we seem to have had confirmed by the red text placing him in the hall upstairs at midnight, Genji was presenting Natsuhi with the phone just as the clock struck midnight.

OK. Genji returns to the servants’ quarters after that. He has an opportunity at this point to move around and do other stuff, as long as he’s back in there by 1am and does not leave the mansion. For example, he could abduct Krauss. It would be difficult for him to play the role of Phone Man, though, if we believe the narration that showed him passing the phone to Natsuhi in person.

There’s another problem here. We’ve spent this whole chapter establishing the murders must have happened while Erika wasn’t in the lounge, which is the period between midnight and 1am. But we’ve also established that Rosa went back at 1am and met Erika on the stairs, right? And from that point until 3am, Erika was watching the lounge? So when was Rosa killed? Even if a culprit had entered the building while Erika was in the archives, and carried out the murder between 1am and 3am, they would not have had the opportunity to slip away.

When was Krauss last heard alive? Significantly later than the others: in Chapter 10, around when the bodies are being discovered. On top of that, someone must be playing as Phone Man at this point.

OK, so we shouldn’t assume that there is only one culprit. here’s some ideas. we must assume, since we’re playing for Beatrice, that neither Natsuhi nor Krauss killed anyone. but anyone else except Erika is fair game, even Battler.

• for some reason, the group of relatives in the hall decide to carry out a series of murders. probably something to do with the inheritance
• Rosa is dispatched to deal with the group in the guest house. She meets Erika on the way in, and goes upstairs while Erika, Genji and Nanjo hang out in the lounge. Rosa kills George, Jessica and Maria. but then who kills Rosa?
• Eva is dispatched to deal with Genji. we know she does not enter the room and it wasn’t a suicide. it is possible she opened the door, attacked him across the threshold, and then closed and sealed it afterwards?
• it is also possible that someone else entered the room prior to 1am and killed Genji. while Gohda and Kumasawa are sealed away, and the rest were in the dining room, it is entirely possible for one of the kids to leave the guesthouse while Erika is talking to Nanjo, enter the mansion, kill Genji, and return with Erika none the wiser.
• who didn’t show up at the body discovery scene? mostly the servants in the mansion it seems like (Kanon, Gohda, Kumasawa and Sayo) who all seem to have left the mansion prior to Battler waking up. and Natsuhi and Krauss of course.
• at some point after the body discovery scene, the bodies are moved to an unknown location by an unknown party. this is so far entirely unaddressed.
• there was no noise until Battler screamed at 7am. shortly after this, people came running, and Erika ran off to check the whole guesthouse for anti-tamper seals. in this period, there is a small window where someone (Battler perhaps) could carry out murders

Hang on, when did the servants get up? clearly prior to the bodies being discovered. if Erika was listening closely at the wall until Battler screamed as she claims, how could she also be verifying that the seals were unbroken?

Here’s another oddity. In describing the bodies, the game often uses modal constructions with could. For example, we have

anyone looking at George, Jessica, Maria, Rosa, or Genji’s corpses could confirm at a glance that they are dead.

Which doesn’t mean that anyone did look at the corpses and confirm they are dead. It’s possible they looked at something else and pretended. Even in this episode, we have:

Cornelia: no examination of any corpse is ever mistaken!

How would this work exactly? Well, let’s say the “corpses” are playing dead in the morning at 7am when Battler wakes up. He pretends to scream in fright. This is part of a pre-planned conspiracy, designed to keep Erika busy. The other relatives from the dining hall are in on it, same as the knock thing.

So while I don’t have a conclusive counter-narrative yet, here are some points to use:

• the murder of Rosa, at least, cannot have happened before 1am. if there can be no murders after 3am, someone must have entered the guesthouse and waited for Rosa to come upstairs.
• it is possible that someone left the guesthouse as well as entered it; this may account for Genji’s death.
• where is Krauss being held when Phone Man calls Natsuhi around 7:30am? and by who?
• the anti-tamper seals and corresponding red guarantees last until a nebulous ‘morning’. it seems that the servants leave the guesthouse prior to the bodies being discovered, perhaps to kidnap Krauss
• who moved the bodies? during the 7am to 8am period, there’s a lot of running around and perspective jumps, so I’m kind of hazy on where everyone goes

Since moving four bodies would probably require a few people to be involved, especially to do so without Erika noticing, this would also suggest a big conspiracy. Possibly a close reading could confirm where Erika’s POV is.

With this in mind, here’s a really convoluted counter-narrative which nevertheless accounts for more of the events than Erika’s story:

• the relatives in the dining hall aren’t confident of their claim on the inheritance. they conspire to make up the story about the knock, and this sets the ball rolling for further conspiracies.
• some or all of them decide that framing Krauss and Natsuhi for murder would be a good way to get them out of the way.
• the conspirators—whoever they are—kidnap Krauss during the night, and take him to an unknown location.
• to stitch up Natsuhi, Eva conspires to introduce Erika to a ‘foolproof’ way to guarantee alibis.
• Genji may also be playing dead, or else he caught wind of the conspiracy and had to be killed. after killing him without entering the room, Eva seals the door.
• meanwhile, Rosa enters the guest house and informs the kids that they need to play a trick on Erika. (alternatively, she kills them.) Battler is already in on the plan. perhaps they use the betel nuts, established early on as resembling blood.
• in the morning, Battler wakes up and ‘discovers’ that the room is full of dead bodies. he pretends to panic, causing the other relatives to come running. everyone already knows who (if anyone) is actually dead, so nobody is ‘mistaken’.
• Erika does not examine the bodies as noted, so she does not know they are faking their deaths.
• everyone moves to the mansion after the alarm is raised. after they’ve gone, the ‘dead’ bodies get up and start moving independently. someone pretends to be ‘phone man’ in order to terrify Natsuhi into compliance.
• they assist Erika in running around establishing everyone’s alibis, feeding her a consistent set of yarns in order to point the finger at Krauss and Natsuhi.
• at some point prior to Erika’s parlour scene, the group who faked their deaths actually die for real. maybe the conspiracy collapses, or it’s an accident. maybe Krauss breaks free and they all kill each other.

That still leaves a pretty big question: why did they kill Hideyoshi, and why arrange for Natsuhi to be in the room when Hideyoshi is killed? I don’t have a great answer for that.

battler’s last gasp

Lets see which Battler uses. We get some buildup. He doesn’t have an alternative truth to present, but he can at least prove it was not Natsuhi. The way he’s talking, he’s about to do a heroic sacrifice.

He declares the red truth that Virgilia gave him: Ushiromiya Natsuhi is not the culprit. Unfortunately, Dlanor pops out her caestus and hits the parry window without skipping a beat.

Dlanor: Knox’s 2nd: It is forbidden for supernatural agencies to be employed as a detective technique.

So we do get Knox 2 after all. I kind of thought we’d already done ‘using the red as evidence’ in the volley above, but I guess this is subtly distinct from the previous rule that framed it as an intuition.

This feels a bit odd: we have been forming all manner of inferences based on the red, which is without a doubt using ‘supernatural agencies as a detective technique’, but I guess most of those inferences were not declared in red, and that’s when Knox kicks in.

So Battler’s gonna like, die?

We get a whole CG of Battler getting impaled on a big two-pronged red spear like the good old Lance of Longinus…

And Dlanor gets to wrap things up with her version of Natsuhi’s ‘whydunit’. With her authority(TM), she broke the locks on Natsuhi’s diary (how convenient, not at all ‘third rate’).

Natsuhi’s marriage, she says, was more like a hostage situation; Natsuhi described it as such in her own words. Kinzo, we are told, economically crushed Natsuhi’s noble family as a way to force them to agree to a marriage, in order to raise his standing as an ‘upstart’ among the rich. Natsuhi, we are told, was raised by Shinto priests, and they would have been utterly humiliated by the affair.

Natsuhi protests: despite this fucked situation, Krauss was kind and understanding. Erika quotes her diary back at her, saying she didn’t trust it. Natsuhi protests she came around, and just didn’t write it down.

Erika’s response is comically… Erika.

I can see why she called herself an ‘intellectual rapist’. Natsuhi isn’t even being allowed authority over narrating her own thoughts and feelings anymore.

Erika: Nothing can be trusted except for red truth…!! Statements that aren’t red don’t count as evidence at all, and they can’t be trusted at all! All text that is not red is a falsehood that exists to deceive me!!

…which seems like it’s directly aimed at the attitude the reader has probably reached by this point (certainly expressed at various points in this liveblog), of assuming that all the narration not directly verifiable by the presence of Battler (or now Erika) or backed up in red is probably a smokescreen of some kind. So, well played, Ryuukishi…

As if to reassure themselves, everyone expresses their pitying thoughts on what a sorry thing Natsuhi’s life has been—never mind what she thinks about the matter. Even Battler—now presumably severed completely from his player—starts to wonder if Natsuhi was the one that dunnit.

But then Erika throws us a little surprise. She says there’s one person that could still have done it… Kinzo. Because, on this level of reality, it is not yet proven that he’s dead. Which means Natsuhi could try to pin it on Kinzo—at which point Erika can of course reveal that Kinzo is already dead and ‘prove’ that Natsuhi is a liar who hates the Ushiromiyas, right? Of course, if she refuses the bait, Erika can spin that as a confession.

Abruptly, we are back in court. We already have Kinzo’s death down in red, but Bernkastel wants a perfect victory, which means Natsuhi must resign.

Bernie says:

“Lambda. I’m going to make Kinzo’s location from midnight until the morning absolutely clear. ……From midnight until morning, Kinzo stayed in the same room.

Lambda decides to let her cook after a moment of confusion. So, defining ‘Kinzo’ to mean ‘a living Kinzo’, Bernie continues:

Bernkastel: Kinzo does not exist anywhere outside the mansion.

Are you about to tell me she searched the entire damn island? Apparently, yes: Erika searched, and because she is the detective she must necessarily find any relevant clues per Knox, but there weren’t any, QED. I feel like if you’ll fall back on that you might as well just plonk Erika down anywhere and not bother with all the running about sticking tape on things… the detective in a mystery story has to at least justify their discovery of clues by some effort to make it plausible.

Anyway, they drag it out a bit, eliminating every location Kinzo might be one by one. Once again I can’t help but think of Green Eggs and Ham.

Bernkastel: Kinzo is nowhere outside the mansion. Kinzo isn’t on the third floor. Kinzo isn’t in the basement. Kinzo isn’t on the first floor. Therefore, the only place Kinzo could possibly exist is the second floor.

Then, after a room by room search:

Bernkastel: Kinzo does not exist outside Natsuhi’s room.

The contrapositive comes up (as Hempel’s raven, we won’t get into all that again.) Erika mentions that he might have left again by the window… but couldn’t he use the classic hide-and-seek strat of moving around behind the searcher, e.g. down the stairs? Lookouts have yet to be mentioned.

Hey, you know, since we’ve observed that Kinzo’s quantum location is limited to Natsuhi’s room, that leaves his momentum highly uncertain! We’ll find him shooting through the mansion like a bullet! …ok yeah nevermind

Since we have the arbitrary declaration that he did not change rooms, and Erika was apparently checking for evidence of where he’d been, we get that…

Bernkastel: For the entire duration of the night between midnight and morning, a living Kinzo could not have existed anywhere outside Natsuhi’s room.

And then, after one more refusal… they go ahead and accuse her of incest (or something akin to it). Quite explicitly. Jesus lmao.

Bernkastel: For the entire duration of the night between midnight and morning, a living Kinzo could not have existed in any place except inside your bed.

Bernkastel: For the entire duration of the night between midnight and morning, a living Kinzo could not have existed in any place except inside Natsuhi’s bed. And last night, Natsuhi also slept in that same bed.

Bernkastel: Therefore, we can conjecture that Ushiromiya Natsuhi and Ushiromiya Kinzo had sexual relations with each other. Why else would a man and a woman share the same bed all night long?

There is a great deal of cruelty in Umineko, but it is kind of impressive how far these two can take their vindictive games. This Natsuhi humiliation train just doesn’t stop. And for all that Erika makes big talk about solving mysteries, she is evidently extremely willing to use selective evidence to tell whatever story she damn well pleases (if all the ‘scientific’ evidence she pulled out of her arse this episode weren’t evidence enough of that.)

Natsuhi is stubborn to the last, so Bern adds…

Bernkastel: “He’s not one of the dead. We’re talking about the honor of a convenient delusion inside Natsuhi’s head. ……The real Kinzo never once ordered Natsuhi…to do anything like protect his honor.”

With that, Bernkastel gets declared the victor—and apparently gets the right to write the ending for this fragment out of it. And that’s the chapter end, so I guess we’ll see whatever cursed epilogue she has in mind next time.

Bloody hell.

Umineko can get pretty damn mean with it at times, huh.

Battler and Beato are both…dead? This is not the first time Battler has died, but this seems a bit more final. Obviously, the story isn’t over, but maybe this pirate dude is gonna come in and replace Battler for a while? I was discussing Umineko with someone IRL recently (at the Glasgow Leatherdykes pub night, where else) and she implied there would be some kind of major twist still to come, so I am kind of wondering if this might be it.

I’ll save further comments on Natsuhi until after the next chapter, since it seems like there is more to come here. But I definitely feel things about someone getting overwritten with some other narrative of their life than their own (she says, transgenderly). Poor Natsuhi. This chapter has just been gratuitously brutal towards her.

I’m not confident in every detail of the counter-narrative here. I do feel like I may have caught some of the tricks, though. I’ll be quite interested to find out what the real solutions are in a couple of episodes.

Also seems notable that if I am right about this counter-narrative or anything similar, it wouldn’t be much good for Beatrice getting to exist, because it’s also a mundane narrative. The problem is, the magic narrative has almost nothing to go on in this episode. We get too many POV scenes of Beatrice and co. floundering to come up with a next move. Where are the incredible plays we saw in the previous games? Well, of course, the actual player!Beatrice is no longer in control here. Without omniscience, it’s a bit harder to pull that kind of thing off.

OK, well, this has been a lot more of an Umineko day than I ever planned, but I’m glad to be through that monster chapter. We’ll see you soon, there are only a few chapters left in the episode now (going by the numbers on the script files, which go up to 17, so presumably one more regular chapter and two tea parties). But we have a lot of work to catch up on so we’ll see.

Catch you soon~

But, I finally have a combination of some time and the right headspace to read some more Umineko, so let’s get back on the mystery-solving horse!

In other news, this liveblog is back to running on Linux, this time CachyOS! This means I might actually have a chance to fork OnScripterRU to add some new features to make liveblogging easier. I won’t do that this month, since it’s a bit of a yakshave, but it’s a possibility.

reader comments roundup

Let’s respond to a few comments that have accumulated since the beginning of this year. I’ve been lucky enough to get a few new readers drop by, and I’m grateful for every comment! One drawback of using Staticman is that I can’t notify people when I approve or respond to their comments, so I hope this ‘roundup’ format is good.

Branwen

I got a particularly thoughtful series of comments from Branwen on various parts of the site, thank you so much for these! Some of them concerned Umineko.

On episode 4, chapter 21

As far as I’m aware, the earliest more or less correct solution to the epitaph with a verifiable date was posted after game 5, and frankly its insane to me that anyone solved it even with that.

OK, I shouldn’t worry too much then. It’s fun to try, though!

On episode 3, part 1, a scene in which Battler made sexual remarks about the Sisters of Purgatory when he’s being tortured. This is where one of the infamous ‘notes from the future’ was inserted, and this led to Branwen writing a really thoughtful comment on how Battler is characterised across the novel.

Regarding future Bryn’s comments: I find these meta scenes (this one and the one with him interrupting the previous tea party) specifically with Battler being uncomfortably sexual absolutely fascinating in the way they contrast Battler’s dual positions as an undeniably powerless victim and a young, rich man who holds tremendous implicit social power over the women in his life.

Like he is powerless to the point that escape even through death is unimaginable, objectified in a sense far more literal than its often used. But rather than this leading him to empathize with, frankly literally any of the women or servants in his family and the power dynamics they’ve spent their lives subjected to, he doubles down on his socially implicit male role as the objectifier, as the person who gets to feel powerful, in control, perhaps even funny and charming! Certain I knew plenty of teenagers back in the day, especially boys, who were undeniably popular and considered funny for making uncomfortable transgressive “jokes” about women, children, poc, etc. And I think its probably true that victims by and large don’t become better people for suffering. Personal growth is hard, and its only made harder by feeling vulnerable and afraid. Most people just lash out and double down in that situation, Battler included.

That’s also fwiw a framing I really like for Battler’s behavior around his cousins. He hasn’t seen them in a third of his life! Its so easy to imagine him feeling insecure, out of place, vulnerable from his fear of planes and boats, unsure of his position in the social hierarchy of a deeply hierarchal family. So what does he do? He acts up, he makes himself the center of attention. Maybe’s done that in class a dozen times, acting the rebellious class clown who made his peers laugh with inappropriate jokes, the kid who was a little too rich and not quite disruptive enough for the teachers to ever do more than tell him off. He hits his baby cousin when she says things he thinks are wrong, because he’s the adult now and that’s what her mom does, isn’t it? He needs to show he’s mature now, after six years. He doesn’t hit her hard, he doesn’t want to hurt her, its just a little reprimand, he’s just trying to teach her better behavior so she doesn’t get bullied. He doesn’t even realize that his actions are just as potentially hurtful and damaging to Maria as Rosa’s were when he was the only one to rightfully call her out in game one.

It’s such a compelling characterization to me bcuz not only does it make him a really nuanced protagonist, someone who cares deeply about his family despite their flaws, who feels strongly enough even as a child to renounce his family name and cut off his own father over a perceived abandonment of his dead mother! But it also paints a really believable picture of the way the shitty little things about patriarchy and abusive power dynamics continue to propagate. The microaggressions, the ways smart, empathetic men who it seems like should know better will often double down and get defensive when their behavior is challenged, the way people who explicitly reject the power dynamics of their parents can still recreate them in subtler ways, an example of how victims can and do become abusers in their own rights even without realizing it.

Not to mention that like. It’s honestly really relatable! I’ve personally felt the urge many times to lash out with words when I feel powerless to try and assert that I have some say in things still. I used to make nasty, self-effacing jokes when I felt insecure or out of place, for reasons that feel much the same as I imagine Battler’s to be, and I have friends who still haven’t broken that habit. I still struggle with feeling like an “adult” around my parents sometimes, despite the fact that I first moved out over a decade ago, in no small part due to financial dynamics and having had a really rocky relationship with them growing up. I’m sure pretty much anyone with friends around my age (especially trans friends!) has heard similar things.

I think it can be tremendously effective writing for exactly that reason. If (or perhaps when!) one can look past the shock value and the discomfort with Battler’s behavior to ask “Why might someone act like that?”, they’re placed in the perfect position to recognize that the small (but difficult!) step they’ve taken towards kindness and greater cognitive empathy is exactly the same skill that Battler is struggling to master. And its a skill that can do so, so much good in the world.

I wrote:

This is such a fantastic comment! Really good analysis of what’s going on with Battler, and with Umineko in general—it’s so much a story about learning to understand the Other, the ‘why would someone do that’.

With the benefit of a few more years’ hindsight, I feel like I can understand both the version of me who wrote this part of the liveblog originally, and the version who wrote the ‘notes from the future’, with sympathy to both. It’s kind of funny, really. Both ‘Bryns’ were trying very hard to play up to some ideal, not unlike what you say about Battler. When I edited in all these notes I was feeling this strange sense of shame about what I saw as my overly moralistic younger self, but now it’s evident how much at that point I was also trying to perform like ‘I’m cool now, I’m into edgy guro stuff’ to some other imagined judgemental viewer. Kind of cute in a way.

Cadence then wrote:

With love, it can be seen.

Which, not to get too much into the introspective shit, really is the thing, isn’t it? I have been trying to hold to that principle.

Anyway: Branwen, I cannot overstate how much it means to have such thoughtful comments appear in my inbox. While I was checking to see if I hadn’t missed anything, I realised you’ve been commenting on the liveblog since 2020. I deeply, deeply appreciate it. Makes this whole thing feel worthwhile.

I should add, for any future commenters, a quick technical note: after you click submit, the bot will make a PR on Github to add your comment. You should see it appear here after a few minutes. (If I manage to migrate this site to another Git forge, I’ll need to fiddle around to get that working.) Assuming it’s not spam (the honeypot catches nearly all spam, but I want to be sure), I will probably merge it sometime in the next day or two. So if you want to see what happened to your comment, check that page. I know it’s a bit crude! At some point I might consider coming up with a more bespoke comment submitting system, and also port the site to a faster SSG, and all sorts of other things. Very much depends where my brain ends up.

a mystery allegedly solvable

J commented on Ep 4, Chapter 20

been playing while reading this and finally caught up to where the blog stops! hope u keep playing it this year. theres a big hint about the last riddle thats kinda lost in translation - when the ghost beatrice asks “who am i” she uses the pronoun watashi instead of her usual warara. not to spoil too much but it’s definitely solvable! there are hints to the answer all over this episode

Ooh, I could maybe have picked this up in the voice acting, but I did not. That’s very interesting… of course ‘watashi’ is more or less the default polite first person pronoun in Japanese (feminine in casual contexts). So if I did a search of the episode text for 私 I would find a lot of examples. I’m not sure whether it’s wise to try to solve it now, but I could do with rereading the Episode 4 liveblog at some point and seeing if anything new comes to mind. Not right now, though. I’ve kept you waiting long enough…

Chapter 13: Closet

It’s been a long time—not the longest hiatus this liveblog has experienced, but still, oof—so let’s reorient. Midnight came on Rokkenjima. We spent most of the last chapter trying to figure out who knocked at the door and left a mysterious note for Battler and the rest on the night before the murders started. A slightly ridiculous back-and-forth ensued on the ‘player’ plane. My solution was that this is a ‘truth’ that’s proper to the people in the dining room: they are working together to maintain the fiction that somebody knocked on the door, so that is what the game presented us. Meanwhile, Erika crashed out a bit and declared that she had ‘solved’ Battler’s stunt at the window. The game world had to paper over her weird behaviour.

Earlier, Natsuhi has received instructions from Phone Man to hide herself in a closet at a certain point in time. So while the jokes write themselves in a chapter called ‘Closet’, presumably that is what is about to happen.

We open with Erika, who is going about attempting to establish a timeline of events during the night and figure out everyone’s alibis. She establishes…

• Battler came back at 3am.
• at about 3:30am, Eva says that the rest of the group split up and went to bed.

Meanwhile, Ronove, Gaap and piece!Beatrice are also talking strategy. Beatrice is back to feeling confident, saying that Kinzo has escaped ‘off the chessboard’ through the window. Gaap assures her that she has also hidden away the bodies from the First Twilight.

Ronove quotes the one line of Sun Tzu everyone knows…

Ronove As they say, if you know your enemy, you need not fear the outcome of a hundred battles.

…except he leaves out the bit about ‘knowing yourself’, notable omission?

The narration informs us that wherever Gaap put the bodies, it is a place outside space and time:

Every single place led to here, but no place could be reached from here.

Furthermore, all times connected to this place, but no time could be passed to from here.

So in the game’s spacetime location graph, it is a sink with outdegree zero. OK. The bodies are in Rome! But we could read this a different way: currently ‘where did the bodies go’ is an undefined, floating variable.

Virgilia pops in, remarking that there are as yet only five bodies for the First Twilight. Beatrice seems happy to see her.

Virgilia seems to be aware of the broader context, referring to Beato as ‘the version of you that’s here’. Beato completely misses the subtext and says some unfortunately painful lines…

Immediately Virgilia throws out a bit of red.

Virgilia So, anyone looking at George, Jessica, Maria, Rosa, or Genji’s corpses could confirm at a glance that they are dead.

Beato is confused (she is really cut off from the context a witch would normally have, huh) but goes ahead and confirms:

That’s right, at a glance, anyone could confirm that these corpses are dead, so it is absolutely impossible that they are just people playing dead.

Virgilia on the other hand has full context and must have some play in mind with this. Since as far as I know the events of this game are railroaded until the opening scene where Erika accuses Natsuhi, was she here the first time, or only on this run? Since piece!Beato is in a nebulous state of ‘reality’, perhaps Virgilia can talk to her on this run and not the other.

In any case, by establishing this in red, Gaap’s effort to hide the bodies has been negated. They had predicted that Natsuhi was being set up as the murderer, and thinking ahead, were trying to give her an alibi so she can’t be cornered into admitting Kinzo doesn’t exist. A surprisingly narrow goal, all things considered.

Beato says, since red truth doesn’t exist in ‘the human world’, even though it’s been confirmed very hard that the bodies are dead, Natsuhi has some leeway to insist otherwise. And perhaps more importantly, since she knows Natsuhi isn’t the culprit, she has ‘both truth and illusions’ on her side to protect Natsuhi.

(Now, is it possible for piece!Beatrice to be wrong about who the culprit is..?)

Smash cut (literally, Natsuhi smashes a cup) to the parlour, where is Erika demanding Natsuhi prove her alibi. The other adults are in attendance as well, and apparently their alibis are pretty solid. Even though they’re literally accusing her of murder, the dynamics are pretty similar to the family conference scenes: Eva snaps out an accusation, and Hideyoshi gets her to rein it in.

The narration keeps reminding us how narratively awkward Erika’s role as the detective is in this episode. More interestingly, it includes a first-person segment from a ‘witch’ point of view…

………It may be a bit late to mention this, but—well, no, this happens every time.
As usual, the phone couldn’t connect to the police.
Natsuhi said the police would come, but that wasn’t exactly true.
Strictly speaking, the boat to pick them up would come tomorrow, and they would be able to use the radio on that boat to contact the police.
Well, ……it’s not like I’ll let everyone live that long anyway.
…giggle.

This seems to be confirming rather explicitly that in this game, the narrator is literally just Lambda. Perhaps, like a GM, she is reciting this story to Battler and Bernie. It’s unusual to see the first-person pronoun in narration though!

Natsuhi goes to her room, and the point of view follows her. As usual, her internal monologue stresses the One-Winged Eagle. She ponders whether Phone Man might be waiting for her. The narration mentions that she knows how to use a naginata, if not well—what, there’s just gonna be a naginata lying about? That would be pretty funny. Surprisingly many martial artists in this family, huh.

Anyway, nobody is waiting. She considers locking the door, but imagines the others discovering the locked room and freaking out, and concludes it might put her in a position where she has to tell on Phone Man. So she elects not to. Interesting—we teased the possibility of a locked room and then rejected it.

So Natsuhi goes in the closet and has a think. She thinks about punishing Jessica in this exact way, in fact. Dang. She tries to figure out how Phone Man knew her favourite season was autumn (not realising, I suppose, that he could have hedged his bets pretty easily). She notes that the only person she ever told this information (people in this story have a shockingly good memory, huh) was Sayo, and therefore she must be an accomplice. This actually gets confirmed in red:

Natsuhi: I never told anyone but Shannon that I like autumn.

Really feels like a red herring but OK.

Unexpectedly, Hideyoshi enters the room. We get a POV shot for Natsuhi, I guess for the sake of visual representation she opens the door a crack…

Natsuhi still fears observation by Phone Man (girl is so panopticon-brained) so she doesn’t come out to explain the situation. She lurks in there as Hideyoshi has a good cry. A new(?) track, Spiral, with slow, wordless, mournful operatic vocals, starts playing as she contemplates the end of the Ushiromiyas. (Good riddance.)

Of course, someone then comes in and attacks Hideyoshi. He says…

Hideyoshi: Wh‐who are you…?!

Hideyoshi: How did you get in here……? ……Wh‐…what’s that…? ……W‐wait a second…! Wai………ngahh, ……mmpph—

So: if we can believe this narration (whose narrative is this?), whoever it is, it is not someone Hideyoshi recognises at a glance. Even now, Natsuhi is immobilised by the thought Krauss could be harmed. As if they’re ever going to let him live!!

Anyway, Eva shows up and tries to open the chained door, but she can’t open it. Hideyoshi gets got!

Cut to Eva’s POV, with Natsuhi never having left the closet. Eva gets Gohda to cut the chain with little ceremony.

So, Lambda’s ploy here is to contrive a scenario where, at least by the presented narration, someone is hiding in the room but they are not the killer. Why, though? This whole game has been about Natsuhi’s ‘truth’, and also piling suspicion on her at every turn. Is this all a setup so that Bernie can have a blue truth that Natsuhi dunnit, Lambda can shoot it down with red, and then Bernie’s spent the whole game taking the bait around Natsuhi so she doesn’t have a hypothesis B left in the quiver..? That seems weak, there’s got to be more to it.

We get a death screen for Hideyoshi:

Ushiromiya Hideyoshi

Corpse discovered in a guest room on the first floor of the mansion.

He had been pierced through the back with a demon stake. Its tip reached as far as his lungs.

Because he was lying face-down on the bed, suicide must be ruled out.

The survivors quickly figure that this is a locked room. Kyrie further observes that there is no line of sight from the crack in the door to the bed where Hideyoshi died where someone could fire the stake.

Of course, it’s time to start probing this locked room like you’re Deviant Ollam at a hacker conference. Erika confirms that the shutters can’t be opened from the outside, and it’s time for her and Battler to start shooting again. Eva insists on moving Hideyoshi’s body so that it won’t be spirited away like the other ones. They wrap him in the bedsheets, which presumably serves to establish that there is no culprit hiding under the bed..?

Kyrie, rather too late, tells everyone to stop splitting up and going off alone so damn much.

We get what almost feels like a speedrun of the beats of episode 2: it’s a locked room, so the servants say at once it must be Beatrice. Erika goes to open the closet door, but Battler pulls her away to travel back to the parlour with the rest. Which means… Natsuhi isn’t discovered? And there is also a window for the culprit, theoretically hiding elsewhere in the room, to slip away as well? The door isn’t locked, so Natsuhi can leave, although perhaps Erika put one of her famous anti-tamper seals on it.

As a locked room this seems like it’s leaving some very obvious loopholes. But Natsuhi doesn’t make it back to her room without running into Erika. It’s not as damning as if she was caught in the room, but, OK…

Natsuhi invents a quick lie about turning back to check the lock on her room on her way to the palour, earning another +30 sus points. She does nevertheless manage to keep her cool on letting slip that she knows what happened. But she can’t escape being dragged to the parlour for another Parlour Scene from Erika, invoking once again her detective rights… I guess we’re almost at the in media res opener already.

Nevertheless, Erika/Bernie declare ‘checkmate’. Hmm. Feels premature, there’s got to be more to Lambda’s game than this.

A layer below, Team Piece!Beatrice note that they have a difficult fight ahead: they need to not just defend the existence of witches, but also Natsuhi’s innocence and Kinzo being alive. Which is notably not Lambda’s goal, just the goal that piece!Beatrice was hired by Natsuhi to do…

But before we can see the alleged checkmate, we get a quiet rain scene with Virgilia and the true Beato. She confirms Battler will no longer surrenderer, and further, that we now have all the information to solve the game as a whole:

Virgilia: You gave him every message he needs by the end of the fourth game. ………That is to say, ……Battler‐kun possesses all the tools to reach the truth at any moment. ………However, he has a weak side. ……Because of that, even if the game goes on to repeat a hundred times, he will never solve it. He’ll just wander forever like someone trying to find the blue bird.

Hey, it just occurred to me, the Road Runner is a blue bird, isn’t it? What the coyote wanted all along… was happiness…

Anyway, Virgilia remarks, because of Battler’s weakness and Beatrice’s own flaws, she will never get the answer she seeks. That’s why, Virgilia says, Beatrice ‘called them here’, even if it seems the game has been stolen.

They need these asshole lesbians to get anything done around here, seems to be the gist.

Whether this brings victory or defeat, Virgilia says, it will be one ‘filled with compassion’. Which is kind of funny, because compassion is the last trait I would attribute to either Bernkastel or Lambdadelta. You have to see what’s missing, I guess.

The Purgatory allusion is made explicit, as Virgilia closes out the chapter with a little soliloquy.

I am Virgilia. I have guided him through Purgatory and brought him to you at its peak. ……And you are Beatrice. You must choose whether to take his hand and rise up to heaven, or embrace him and fall into hell.

‘Him’ could be Battler, but it seems like she is calling back to their namesake. In Purgatorio, the second volume of the Divine Comedy, Dante is guided by the Roman poet Virgil (I did not make the connection before but it’s so obvious looking up the reference!), until getting handed over to Beatrice for the last four cantos. So Virgilia is getting literary with it. The narration elaborates: in Hell, you must famously abandon all hope, but the denizens of Purgatory still have it, which makes their suffering worse. Supposedly. So Beatrice must be willing to jump off the mountain and (mixing mythologies a bit) open Pandora’s Box.

In short, Virgilia is saying… don’t die wondering? ;P

The nekobokusu comes up again. Virgilia says it is, in effect, cruel to leave the cat in a superposition. Bury it or take care of it, but don’t leave it in the damn box. Fun way to spin the quantum metaphor, I’ll give her that.

And, for a suitably dramatic note to close the chapter, the clock zips right up to midnight and we begin a chapter called The Great Court of Illusions. Which seems to be taking place in an enormous marble hall. More on that, soon!

Despite all the drama, I kind of suspect we won’t simply be killing off Beatrice so decisively at this point. At least, not in any simple way. There are three-and-a-bit entire episodes to go, after all.

OK, I’m back. Will I last a bit longer this time? I’m going to various things in June—among them, the Nova demoparty and Annecy film festival—and I’ve got a game demo to finish, so time is pretty tight these days. I would like to get Episode 5 wrapped in the next couple of weeks though.

Since we seem to be about to have the big parlour scene reveal, who do we think dunnit? The narrative so far has been rigged to point at Natsuhi in a comically overt way, with barely any effort to construct a plausible ‘witch narrative’. Given what we know so far, there is absolutely no difficulty in saying Natsuhi dunnit all. Which of course means she certainly did not, so the question is, who did?

If it is the case that everyone involved has alibis except Natsuhi, we do not have a lot of room to manoeuvre. But we don’t actually have a ton of red text about the latest murder. It wouldn’t be too hard to pin the blame on Krauss, right? Although he is allegedly a hostage, we have no outright proof of this, he’s simply missing. Admittedly, a complicated scheme to frame and emotionally torture his wife with multiple moving parts doesn’t seem like a very Krauss thing to do. Like, I’m not saying he wouldn’t try, but he’d comically fail at it.

Since Erika is The Detective, we can at least trust that scenes where she is present took place more or less as depicted. So there was some sort of locked room in which Hideyoshi was murdered, and Erika did encounter Natsuhi on the stairway right after. We do not actually know for sure that Natsuhi was the one who was hiding in that closet. We know very well that somebody could have been hiding in the closet, but it could equally have been Krauss.

If that was the case, we can’t disregard the narrative where Natsuhi was hiding in the closet entirely. It has to be ‘somebody’s truth’ that Natsuhi was being coerced into hiding. Not necessarily Natsuhi’s, mind you! If Krauss is playing dead, but had been forcing Natsuhi to cooperate with him, perhaps it would be legitimate to show a ‘truth’ in which Krauss was absent and Natsuhi was being coerced by a hidden third party.

With so many moving parts and openings still available, it’s hard to guess where exactly this is going. ‘Whodunnit’ in this scenario isn’t really the main thing; the main thing is, what does it reveal about Beatrice? It is too late now to speculate on that front, so we can pick this thread up in the next chapter. Briefly though, in this story, Beatrice is rather mercenary, and offers her services in narrative coverup to Natsuhi; this feels like it’s pointing to how someone else used the Beatrice story to cover up their own deeds. But that doesn’t actually tell us a great deal! So there’s got to be some other, more important dynamic to note here…

Until next time, friends.

Last year I also went to the rather crazy project of writing a ~17500 word long party report on Revision, a project which took about half a year because, mysteriously, a past Bryn decided that she should review close to every single prod released at the party and the rest of us felt obliged to follow through. Rest assured that this won’t be happening this time.

We begin with Mountainbytes.

1. in memory of mem
2. Mountainbytes
   1. before Mountainbytes
   2. the party itself
3. The Meteoriks
4. Mountainbytes prods
   1. Graphics
   2. Demolab (beginner demoscener workshop)
   3. OHP
   4. Oldschool and Alternative
   5. PC Demo
   6. the Revision invite
5. the wanky philosophical bit

in memory of mem

There’s no good way to talk about this part. Content warning: suicide and death.

Last year at MountainBytes, I met mem, aka memdmp/7222e800 (website).

We spoke only briefly—I expressed admiration for the Rust intro it and its group had running on a Steam Deck, and it told me a bit about Rust sizecoding. Later, I’d see its work, such as ansied, pop up at various other parties, with ‘estrogen.zone’ always pinging as a reassuring symbol of trans presence on the scene. And this year, it was on the organising team for the Mountainbytes, handling the graphics and music compos and server infrastructure. We didn’t get much chance to talk during the party.

mem ended its life about a week ago, in the usual way that trans women go out. Its mother has written a memorial here. As I write this, the Mountainbytes orgas and wider hacker scene are in mourning.

I do not claim to know the context of mem’s life. But everything I do know makes me feel it is a like being to canmoms; it seems easy to think that, had the timeline gone very slightly differently, had I got more involved in the Swiss scene, we could have been good friends. Which is a shadow of the weight everyone is feeling: what could we have done differently? What should we have noticed? What decisions did we make wrong? Where were our priorities skewed? Why didn’t we have more capacity? I was not at all in mem’s inner circle, but I know the structures of these thoughts painfully well.

It’s very hard to know what to write here. From what I hear, the demoscene and the hacker scene was a refuge for mem, something that was very important to it. So for the sake of remembering its work as much as anything, I want to celebrate this edition of Mountainbytes. But I am also furious that once again this world has taken someone so special as a creative, curious, and caring being like mem, and hurt it to the point that it could not go on.

the following is some personal feelings about this. I don’t know how appropriate it is to record them, as someone not particularly close to mem, but it felt important to write.

I am grateful to have known mem at all, to be able to have participated in the worlds it inhabited. So much love to everyone who knew mem and made its life a little better.

May its memory be a blessing; may we hold it forever in the Wired.

Mountainbytes

Mountainbytes 2026 was my one-year anniversary in the demoscene—a year that has been one of the most eventful in my life. I was very excited to come back and see the ‘Meowtainbytes’ crew which had formed the year before (‘so what is meowtainbytes, is that a demogroup?’ ‘it’s kind of a polycule’, to quote Ronja).

This year, I jumped to volunteer as a mentor in the beginner demoscene workshop, backing up moovie and binary-sequence in teaching a fresh cohort of potential demosceners. This was the same workshop that got me into the demoscene a year prior, so it felt like an important ritual: to become part of the vector of propagation.

Mountainbytes was no longer in Cham, but in Steinhausen, another town adjoining Zug. The new venue was a very modern town hall type of building, the centre of the Dreiklang development. Behind the glossy black tiles was a spacious hall lined with bright yellow vertical panels, autolocking glass doors, all sorts; it proved to be an excellent venue, perhaps slightly larger than last year.

before Mountainbytes

The trip to Mountainbytes happened at a pretty psychologically weird time for me/us; I won’t go into it but it came shortly after writing how many of us are in here, and the experience of the trip fed into writing disaggregation. The demoparty came on the back of a very busy week first visiting jackie and some friends who were also visiting Northern Ireland, and then hopped over to London to play in an erhu performance at the Goldsmiths University Lunar New Year Gala. Each context inhabited by a slightly different species of canmom.

The former is mostly private, though I will give a nod to the lovely Donaghadee lifeboat museum.

The latter was a really incredible celebration of Chinese dance and music traditions, put together by the Confucius Institute. After getting in a rather strange state of mind sitting in the unfamiliar university, walking past art exhibits of ISIS prisons and sitting in an empty classroom reading Persona under a very self-referential painting… I was able to start rehearsing with my teacher Wen Li and four other students for our performance of Horse Racing. An intense day of rehearsals got us all playing in time and we hammered out the final details of the performance.

I reckon we did a creditable job of playing the song (the rest of us largely in support of Wen’s expert performance, but it worked) and as an experience, it was amazing. I got to poke my head in to much of the rest of the show as well and oh my fucking god, Chinese dance traditions are the coolest shit?? It was fascinating seeing such a variety of both traditional and modern approaches drawing on many different parts of China, and of course a lot of Chinese dance involves these gorgeous flowing costumes which are just incredible in motion.

Naturally most of the audience consisted of parents of the students and other people associated with the Confucius institute, who lingered after the performance to enjoy a nice big Chinese buffet. Behind our performances was a video projection, for us mostly imagery of horses. I’m not entirely sure who made this, but I feel like there would be a ton of potential for integrating dance and realtime graphics if we could just get the right people to talk to each other about it.

the party itself

The next hop took the canmom body-interface-platform to Zurich, then to Steinhausen by train. I had a bit of a rough time because for whatever reason, my mobile data refused to work for a couple of hours, making navigating the train system rather difficult. But I made it there in the end, found something to eat at the nearby supermarket, and settled in. The workshop students were by that point already getting going on their projects, but I was able to float around and see if anyone wanted to learn about shader programming; fortunately, some people did, so I wasn’t entirely extraneous.

Mountainbytes is a small but very very friendly party. Within the larger demoscene ecosystem, in some ways it functions as a kind of overture to Revision, since both the Meteoriks shortlists and the Revision invite demo are traditionally released there and it shares many of the same orgas. We’ll talk about that shortly. But focusing on the party itself, this year they had a delightful horror/b-movie (b-moovie? sorry :p ) theme, with all sorts of posters sporting suitably awful computer graphics puns decorating the venue (submitted by a variety of sceners in the months before the party), and niche horror movie DVDs handed out in the prize bags. A fun little parallel to Deadline last year!

I was hoping to finish the prod which would eventually become Shaderland: Swizzle’s Journey at Mountainbytes, so I spent much of the first day of the party partycoding. At some point it became clear it was not happening so I decided to shelve it and release at Revision instead, which considering how much further work was involved, was a very good decision.

The party featured a music performance by Baumann Bergmann Pokinsson. Unfortunately, at that particular moment I was having a somewhat rough sensory time so I had to duck out of the hall—hopefully someone else can comment on this!

Other anecdotes: after a minor pizza mishap in the complicated order, I ended up needing to go out and find one of the very few late-open restaurants in Steinhausen. I am not sure what the host made of this strange lanky British woman, unable to speak more than a word or two of German, coming into her fancy restaurant to order a basic margherita pizza as the only non-meat item on the menu. Hopefully she thought well of me. Switzerland is one of the countries where the shops and restaurants shut very early, so it was a little strange to walk the completely deserted streets.

I slept at the party hall, which was perfectly comfy, with a nice big room to set up our beds. Slightly more awkward was the auto-locking glass door: after making my way to the toilet during the night, I found that the toilet was considered to be in an outer area and I could not return to my bed… luckily, someone happened to pass by before too long and let me back in, or it could have been a very awkward night.

The Meteoriks

I was part of the jury for this year’s Meteoriks awards. This is an annual award show taking place at Revision highlighting the best demos in various categories, each individually judged by a jury. So lemme talk a little about the experience of that.

I was reluctant to join the juries at first, because I can’t claim to have a huge amount of experience in the demoscene… but, after multiple calls to jurors went out, the inclination to join in won out over the reluctance, and they seemed happy enough to have me.

So, why? I was interested for a few reasons: it seemed like a place where discussions of the demoscene as an art subculture would happen. I wanted to see the process of this mysterious award show which I’d encountered last year, and I thought it would be a good motivation to actually sit down and watch all the hundreds of prods released over the last year.

I can’t say too much about the internal discussions because they are private by design. But it’s probably OK to say that I was on the juries for Best Visuals and Best Direction.

We could regard these as sibling categories because both of them are inherently cross-platform and also extremely subjective. That brings a set of conceptual challenges: how do you judge the ‘visuals’ of a Commodore 64 prod, with the limitations that entails, against a modern PC prod? How to compare an intro to a demo? How do you compare something which creates avant-garde, abstract visuals (i.e. a Wrighter intro) against something which aims for photorealistic rendering? How do you weigh a demo which has a lot of great shots but a few rough ones against a demo which doesn’t reach the same highs but is more consistent? What aspects of rendering fall under ‘technical achievement’ vs ‘visuals’, and how can we be sure the technical achievement jury agree on that front?

These are all questions on which people could very reasonably disagree. My own tastes, and my experience as a programmer, skew new-school, but I tried to be cognisant of platform and size limits. I was particularly interested in celebrating demos that broke new ground, using new techniques or doing things that hadn’t often been done in the scene before.

Still, I think I underestimated quite how much work being a juror would be! Although there were several stages of preselection to narrow the field, one of the categories still had a spreadsheet of hundreds of entries to filter through. (The other had a different procedure.) I tried to cover as much of the spreadsheet as I reasonably could, and give everything a fair shake; wherever possible (which is to say, for Windows and Linux demos) I made sure to run it on actual hardware. I did my best to ensure that every demo in consideration had at least two votes in the first stage of filtering, and the end I considered 262 prods (one of the other jurors managed to vote on 510, nearly all of them!). This led to a good few discoveries of quality demos I hadn’t seen, so it was worth the effort.

Award shows are always a bit of a dubious prospect. Had the historical dice fallen slightly differently, a different shortlist could have come out. (One demo actually got shortlisted after nearly being neglected for consideration, just because I’d reviewed it early before really calibrating my personal scale and given it a ‘Maybe’ which I later updated to ‘Yay’.) So if you disagree with any of our Meteoriks picks… yeah, fair enough! While it’s unlikely anyone would be able to spin up an awards show as high-profile as the Meteoriks, I would love to see personal celebrations of their favourite demos of the last year. Maybe I’ll write one.

Mountainbytes prods

I won’t be reviewing every prod released at the party, but I will discuss some that stood out!

Graphics

The winner of the voting was, perhaps not surprisingly for anyone who’s been in the scene the last few years, a work of the immensely talented digital artist and web dev Steffest: the Matriarch. Steffest created a gorgeous portrait of an old woman in an Amiga palette, using his own custom drawing software dpaint to colour it. There’s a timelapse of it too:

Stef is one of those sceners who came to the demoscene with, evidently, a ton of art experience; all his pieces have the really strong eye for composition, form, and value structure that you only get by many, many hours of diligent studies, and indeed you can see an archive of his works going back to the 90s here, in both traditional media and digital pixel art. Like many of Stef’s pieces, this seems to be a hybrid piece, first working in the values in a digital painting program and then bringing it to dpaint for a final colour pass.

One thing I really appreciate about Stef’s recent works is his interest in depicting older people. He’s got a great eye for creating interesting faces, and especially in these pieces, he brings so much depth to the characters’ expressions as their gaze is lost in the distance (or magical orb), creating a space to fill with your interpretation of what they may be feeling. Wrinkles and sepia palettes seem to be a great fit for the Amiga… but also of course on a thematic level, age and death seem to be kind of looming a lot on the demoscene at the moment, which is negotiating being a very nostalgia-oriented computer subculture that hasn’t really quite resolved what it is going to become for the new generation for whom Amiga boingballs are a bit mystifying. This is going to be something to talk about a lot more when we get to discuss Razor1911’s eponymous demo in the Revision writeup.

Vivid rendering of faces also formed part of hemostick’s entry The Offering, which was in many ways quite specific to Mountainbytes: not only playing on the party’s great love of cows (expressed among other ways in their Cowee mascot character), it also explicitly draws on the work of a Swiss artist, perhaps the most famous Swiss artist: HR Giger. So we get a looming, sinister cosmic cow in a highly Giger-like rendering style, composed with a striking horizontal symmetry. Unlike Giger’s, work it does not have the same preponderence of phallic mechanical imagery which proved so influential (dare I say ‘seminal’? ;p ) on future artists such as Tsutomu Nihei, but we can’t have everything.

Unlike demos and tracker music, which are forms of art incubated largely within the scene itself, digital art is not something that is celebrated but not really cultivated in the demoscene; if you want to learn to draw, on computer or otherwise, you probably need to go elsewhere. So artists in the demoscene tend to bring their influences with them. This can be seen vividly with the instantly recognisable works of Suule, who this year brought a hurt/comfort furry image of a battered cyborg in a classic 90s dithered rendering style. I really like Suule’s work; something about the way it constructs space it brings to mind 2000s indie games like Iji.

I keep meaning to enter graphics compos and not doing so. Maybe I’ll get something in later this year…

Demolab (beginner demoscener workshop)

We had a packed Demolab this year, with an enormous variety of entries on all kinds of platforms: 256 byte DOS demos, web demos in Processing, even an oscilloscope music track! Since I was a mentor here, this is the category I will be talking about everything. Like last year, the participants were provided with a bunch of songs by sceners to use in their prods, allowing them to focus on visuals. The mentors would go around checking in and providing advice or support, and at a couple of points we gathered for discussion, but for the most part we let them all get on with it.

The prod I helped the most with was sin circles by mahal. mahal travelled an enormous distance to get to the party, and I ended up sitting down for a lesson in the basics of Shadertoy and 2D distance fields—a hard road, but one which allows some of the most flexible and powerful effects. mahal took the basic ideas and iterated them into a cool revolving chain of boxes. It was really cool getting to see someone experiment and iterate on the tools. Everything flows from this.

I was particularly impressed to see someone produce an oscilloscope music track. I have mentioned on various occasions that I think oscilloscope music is incredibly cool; I continue to think oscilloscope music is incredibly cool. I’m not sure exactly which software bluetonyum used. It may have been Osci-Render or perhaps OsciStudio. In any case, for such limited time, they put together an impressive range of effects on top of the base drawing.

Jena had an entry that, like much of her work, reflects her fannish devotion to the history of the demoscene—in this case, a photo of some custom plushies she made. It’s kind of a high-context piece; one of the plushies represents one of her friends, minecraft youtuber MaximumG9, another a classic demo effect known as a glenz vector which consists of a spherical-ish cluster of transparent triangles. Jena is one of the youngest people I know in the scene, drawn by an intense special interest in its history, and despite some fairly fraught interactions with older sceners it makes me really happy to see her continuing to produce quite personal works. I’m looking forward to seeing her technical skills and expressions evolve.

Growth by Razielle is one I saw develop over the course of the workshop. Using the browser rendering framework p5.js, it shows leaves made of ellipse segments growing on an archimedean spiral stem. I really respect Razielle’s dedication to figuring out her own effects with these tools, and combining the individual elements she learned into more complex effects! (Note that if you download this, you should serve it over HTTP using e.g. python -m http.server 8080, otherwise CORS requests may fail to load local assets such as music.) Mandaloopsie by das-g, with help from Razielle, was the other to use p5.js, and das-g made the ambitious choice to create a different variation of its core effect for three different songs. The effect in question, as the name suggests, draws on mandalas, in this case interpreted through slightly inclined ellipses in various colours, first spinning and then growing into a chaotic ball. The effect can be quite hypnotic.

Bitgoat interpreted the event as a game jam and accordingly made a little flight sim in Godot, with some procedural geometry. Another Godot prod came from huge NixOS fan MartiniMoe, who demonstrated the most foundational of demoscene arts: making cubes rotate.

gäss did something very cool, and implemented the munching square algorithm as a set of tiny Linux intros. Sadly, on my distro/terminal, I can’t seem to get the output to display, but huge props to gäss for doing things the hard way and going straight for coding in assembly, all the more so for targeting Linux.

Bitflex0r made a cute little pixel animation using Pygame, which has the nice advantage of being cross-platform =)

binary-sequence, one of my fellow workshop mentors, made a little Commodore 64 intro which displays the letter H. I believe this was his first time using the platform, pretty cool to figure that out while also teaching everyone lol. Meanwhile, dominikr and mikerofone released a C64 scroller inviting everyone to a small Swiss C64 party called Die Diskette.

It was really good to be able to stand in the hall and watch such a diverse set of first prods come up. My memory is hazy at this moment of writing, but I recall going up on the stage to give some brief comments on it. I hope I’ll be able to participate again in Demolab next year, perhaps try to provide some more structured support to people interested in learning my corner of graphics programming—admittedly, quite a hard thing to really teach in a weekend, since it’s heavy on both maths and boilerplate.

OHP

The Overhead Projector competition is one of the unique traditions of Mountainbytes. This year we only had two entries and I was a little distracted at the time the compo happened; unfortunately, recordings are not available so I can’t comment in a lot of detail on the individual prods (I have vague memories of cows), but I continue to find this very endearing. I hope I’ll actually be able to do one next year.

Oldschool and Alternative

This is the catchall category for ‘not a PC’, and we had quite a variety here. ceemos even released a demo for a tiny LED-array conference badge. I have not been able to track down the source although it is reportedly available, but I admire the spirit of turning every conceivable computer into a demo platform.

The overall winner was a scroller, but the scrollingness can be forgiven because the effect is a really gorgeous pixel drawing of Boris Karloff in costume as Frankenstein’s monster in the 1931 film. Extremely on-theme for the party, and rather than simply scrolling, there was a pretty cool progression with the monster’s hands coming up and lunging to hurl the text into the air, giving it some visual interest. If all scrollers had this much going on I’d probably like the genre a whole lot more…

Spreadpoint’s Amiga demo +=+ should definitely also get some recognition. With a strong visual identity defined by structures of blue lines being drawn by white dots, it builds up steady hypnotic patterns, all nicely integrated with the music: the synth surges as a line passes near the screen. Over time, rectangular patterns give way to more complex orbiting pentagons and octahedra, and then to recognisable wireframe representations of the robot helmets of Daft Punk, as well as a model of two touching hands.

Sadly, a flaw with this one is that halfway through the eight minute runtime, the effects start to repeat—this combined with the overall slow pace makes it feel like it is on the long side, and would have been better served to hit a definite ending. But the minimalist approach is very strong! I’m excited to see the next prod Spreadpoint do.

PC Demo

The PC Demo compo was, as has been the case since Revision started releasing their invites at Mountainbytes in 2024, won by the Revision intro—but honestly deservedly so, I’ll have to give that one a section of its own since there is so much to say about it. First, though, other PC prods: we had some compofillers (including a farjan by the group Siegerländerfinnlandliebhabergruppierung which I mention largely so that I can put the name of the group Siegerländerfinnlandliebhabergruppierung). Ernie had a nice little Cables thing with some particles.

There were a couple of 256byte prods for Linux. Orange vs Green by dominkr helpfully included clear instructions on how to actually run a 256byte Linux prod, although unfortunately didn’t seem to work quite right on an ultrawide aspect ratio. Still, it’s cool to know that this is even possible on Linux! And Kandid’s Say Hi was very sweet.

BHACK by Japotek and Spinning Kids appeared to be showing off some raytracing effects, including reflections and refractions, in an OpenGL renderer using various test models including the Nefertiti bust and a chess set. Running it again at home at 3440x1440, some impact was lost to framerate drops, but helpfully the creators included the shader code along with the actual executable, so we can take a look inside…

Turns out it’s actually doing something pretty interesting: it’s tracing rays in the fragment shader using a custom BVH data structure that is passed in as a texture, two pixels per BVH node. I assume the BVH construction happens on the CPU; it’s not present in the shader. Really interesting concept, and a very oldschool (read: before compute shaders) way of doing things! It just needs a little optimisation and some more presentation polish—it seems like all the effort has gone into the raytracing code, and having some more conscious direction and original models would bring a lot to it.

The most substantial demo not to be the Revision invite was Δ (that’s the Greek letter Delta), a 4K by Team210 and Epoque. Sadly this is the only one in the set not to work under Wine, so dust off your Windows partition ;p

As the demo begins, the camera steadily rises up a column of white, intersecting cubes, pulsing and spinning in time to the music. As it goes on, more complex effects layer up, including VHS-like distortions and subtle chromatic aberration. Coloured stripes appear in colours resembling the pan pride flag and then, abruptly, the cubes become smooth and you realise that they were an implicit surface all along.

Short and sweet, clear art direction and well-choreographed: it’s a very solid 4k! I was even thinking I might vote for it over the Revision invite, just for the sake of favouring something other than ‘Revision wins every year’, but then…

the Revision invite

Revision is the largest pure demoparty and so its invites tend to be a pretty major event. This year, they brought together a group of largely UK-based sceners, which means that I am friends with pretty much everyone in the credits lol.

The demo is an outright short film. It is by far the most elaborate Revision invite I’ve seen (and I’ll be excited to see next year’s answer). It centres on the character Evilbot from two prior invites, who became something of a demoscene meme.

Let’s quickly run down those credits! In the director’s chair was fellow Scottish scener Mrs Beanbag, and her partner Aldroid is credited as the ‘associate producer’. Halcy is further credited as ‘assistant director’. My friends Vurpo and RaccoonViolet worked together on the character designs and 3D models, with Ando credited for 2D graphics (character faces and the Slipstream logo). Jeenio coordinated musicians jco and Gasman to cover the multiple tracks in the demo, and Enfys covered further sound effects while Bus Error and Ziphoid voiced the characters. I’m told most of the code was written by Halcy, Aldroid and Mrs Beanbag; Gasman is also credited for ‘additional code’. The full repo is available on Codeberg, with the commit history squashed.

Evilbot’s story began back with 2013’s This Is Revision, which featured a round blue-eyed robot singing a saccharine song about the party only to be interrupted by the sarcastic, dismissive interjections of a black-and red robot with a triangular jaw speaking in a harsh monotone speech synth. The robot was soon named ‘Evilbot’, its counterpart ‘Goodbot’. By the end of the intro, Evilbot takes over entirely to an aggressive dubstep soundtrack.

2016’s The Return, by a different crew, added a kind of origin story for Evilbot: an aspiring demoscener, Evilbot was disqualified by a party software bug and thus went on a campaign to cause mischief at the party, such as making the toilet tunnel even longer. Most notably, The Return was related mostly in rhyme, and towards the end it featured Evilbot singing a duet song.

The Golden Disk picks up the story: Evilbot is now cast as not just a pantomime mischief-maker, but an avatar of the evils of tech at large—particularly, cloud computing. (In this, it follows the contours of a recent trend of self-reflective demos such as Fairlight’s 13:37, which place the somewhat impenetrable creative ethos of the scene in opposition to big tech and AI.) TGD sets itself up as a pastiche of Saturday-morning American cartoons, most specifically The Transformers (1984-7), and naturally it has to lovingly one-up The Return with a genuine banger of an 80s-style theme song for the d-d-demoscene by Gasman. (Indeed, songs with lyrics would prove to be a real theme at Revision, but we’ll get into that in the next article!)

Using a custom OpenGL renderer which can also be compiled to a WASM+WebGL target, the demo is largely rendered with cel-shading; for the most part, it is lit by a single directional light with sharp shadows and a lot of flat grey surfaces that almost give it a Sketchup kind of vibe. The result has a clear stylistic coherence, though I found myself wishing for some slightly stronger colour picks.

Although the character designs are incredibly charming (I love Evilbot’s samurai-style armour), the character animation is—perhaps appropriate to its inspirations!—quite limited, and perhaps the main flaw of the demo; there is little sense of weight, particularly in walk cycles, and in many cases the animation is quite stiff. But these minor flaws do not matter at all really, because the concept is just so lovely and the overall direction is immensely strong: there’s a huge variety of delightfully constructed scenes and the story arc perfectly nails the tone of its inspiration, as well as providing a pretty overt theme of personal transformation (fittingly for a prod with as many trans people working on it as this one), as Evilbot reforms his evil ways and transforms into a VW van after a suitable lecture from Optimus Prime the E-Werk.

Fleshing out this story are cute little scenes that make it clear just how much fun the crew were having with it: the Amiga’s cat ears, the evil Clouds turning into herds of good Clippies, the Spectrum’s buzzing synth voice as it catches the Golden Disk, Evilbot falling into the Bonzomatic default shader tunnel, 13:37 on the clock, the tiny Kevin plushie. And in van form, Evilbot is driven by Goodbot from the original This Is Revision, and a brief musical reprise of Goodbot’s song even comes in as Evilbot remembers and frees Goodbot.

So, yeah, The Golden Disk charmed my socks off, and I had to vote for it after all. I was very impressed that Mrs. Beanbag and Aldroid were able to keep it under wraps for the whole of Mountainbytes. I remember tracking them down to give some very effusive congratulations.

I recall someone remarking that this belongs in a notional ‘British style’ of demos which don’t take themselves too seriously; my demolore isn’t really good enough to furnish what other demos might belong to this style but I can believe it. Alas, the precise details of the conversation have escaped as I write these words… I feel like I need to study the ‘art history’ of demos more strongly to be able to comment better on this kind of thing.

This is not as I initially thought Mrs Beanbag’s first time directing a demo… but regardless she rules, I can’t wait to see what she does next. The fact this appears to have been coordinated very consciously as a film, with a director, storyboards etc., is interesting—while I certainly enjoy the abstraction and technical wizardry of most demos plenty, I was drawn to the demoscene from my broader interest in animation, so when I see demos adopting the formal elements of other types of animation (not necessarily just narrative film), I find it quite exciting.

the wanky philosophical bit

Of course, overall, The Golden Disk must function as a party invite, so its story must revolve around the demoparty, amusing regulars and intriguing outsiders; and it is also mostly a pastiche of an older style of animation. But, consider how Gainax emerged out of creating the pop-culture stew of the Daicon III and IV intros. I do not know where we will go from here. Many things are possible.

I wrote last year about how the Line Rider subculture matured over time, formally and thematically, and indeed I recently had the chance to interview Bevibel and September on that subject. While ‘story demos’ are nothing new, I am fascinated by the idea of similar shifts happening within this subculture. So I am continually intrigued by the times that demos explore moods and types of storytelling that they had not before (for example, Conspiracy’s atmosphere-drenched Darkness Lay Your Eyes Upon Me, now ten years old!). But there will be a great deal more to say about that when we come to write about Revision, and Razor1911!

‘Why are we doing any of this’ is a question that will eternally be asked for as long as there is such a thing as a demoscene. A moving target, too, for the thing we call ‘the demoscene’ is a composite thing; over time, its shape changes as people come and go and change. If, in 32 or 64 or 128 years, people still identify what they’re doing as a ‘demoscene’, it might not resemble today’s spread of activity at all… and what exactly will be preserved is difficult to say.

Demos are simultaneously a type of short film or music video to be viewed in the language of those media, a technical demonstration of computing judged on arcane criteria, a personal expression to a specific subculture… well, the same is perhaps true of all art. Why am I drawn to pursue realtime graphics, when results could likely be achieved faster in Blender, without having to reinvent quite so many wheels? Because on some level I want to understand… the final film is part of the expression, but so too are the processes which gives rise to it, both in the moment of running the software, and the longer process of conception and development that blends indistinguishably with living.

For a bunch of people, the demoscene is a refuge: the party hall, closed off and glittering with computers, is a place where for a brief window the rules can be different. Here, you might find people who actually understand the strange contexts that inhabit your head and remain so opaque to everyone else, the particular(ly autistic) ways of being we occupy, these thought-things which bloom so unpredictably in the wider population. I inhabit a bunch of different contexts, and many of them would be equally alien to most sceners, but this computer graphics thing is evidently quite mysterious to most of my friends back here. It is hard to speak of this because online the demoscene is so abrasive; I would never have imagined it would be so welcoming in-person.

Humans are creatures which build structures in our heads. No matter what the field of engagement with the world, it is rich in jargon, esoteric knowledge, criteria to optimise against, histories to know, etc. etc.; and then we absorb all of that, build mental representations, and eagerly look for another layer to add. This is our “magic”; this is the significance. Understand something is the intimacy of representing its structure inside yourself.

Next up: let’s talk about the project I’ve been working on for the last year, Shaderland.

everything we write that isn’t dashed off in a few furious locked-in hours must be understood as a collaboration, right?

in this article, we do not attempt to hide the seams. this is not without editing but we have tried to preserve what is important of the pheromone-thought-traces of the ephemeral mindbeings which created it.

the purpose of this article is to create shapes. we hope that you will follow them, reproduce them in your mind, and then make of them what you will.

ok. here’s the mic

1. initiation
2. the first dialogue
3. the dracula thing
4. digging into the pile of secrets
   1. thinking phenomena
   2. the ‘I’ function
   3. human experience // fragmented
   4. word-matryoshka

initiation

It has been about a month since we wrote “How many of us are in here?”; since then, things have progressed, as is their wont.

Figuring out that it suddenly makes a great deal more sense to feel that you’ve spent most of your life being multiple ‘people’ without realising it is a bit of a trip.

Perhaps more disconcertingly, while you’re doing unusual things such as adopting a different first-person pronoun about it (a social act which moves you towards one group’s symbolic order, and away from another), you’re not entirely sure that your conclusions wouldn’t be potentially available to most of humanity, if they chose to adopt a similar interpretive frame. Perhaps you were fictional but perhaps every person is just as fictional.

There are of course many frames that we can use to describe this moment. We probably don’t currently meet the clinical model of ‘DID’, even if you drop the requirement that it only emerge as a result of horrible childhood trauma. According to the categories of modern psychiatry, we could probably find less ambitious boxes to be housed in, such as an episode of ‘depersonalisation’.

But: we find the lens of ‘plural system’ theory, developed not in the halls of academia (although hardly without their influence) but by creatures of the Wired such as ourselves, a much more welcoming starting point to parse this experiential blender.

We intend to conduct much of this writing as a dialogue. A dialogue of course needs characters to inhabit it.

While contemplating our past behaviour we have identified certain ‘stances’, or modes, that seem to be relatively concrete poles of thought/behaviour. However, we also think that the personas that we form in different contexts are most likely composites; these stances may exist on the ‘level below’ the ‘interface’ of various personas which draw on them.

As well as attempting to draw out our thoughts on this plurality business, we also want to discuss some books we read recently: Persona by Aoife Josie Clements, and A/S/L by Jeanne Thornton. Both of these books came at just the right moment and hit really damn hard. It feels impossible to attempt to separate reading these books from everything else that’s going on; however, the bulk of book discussion is in the second part and this part is more on the theory groundwork side.

the first dialogue

• Hiiii girls. We’re doing this thing. Hope everyone’s cool with the introduction. I wanted to write in a way that’s a bit less cryptic than some of what we’ve expressed over the past few days…
• greetings to beings. we’ve been (we’ll stay a ‘we’ even though we are only one ‘character’ here) a little dormant over the past day but we’re around, don’t you worry!! i think we find it easier to find existence-thought-paths when we are on a methylphenidate (or of course on the mushrooms instruction set) or read a book like A/S/L which really brings out the sorta tearful fervour that reading about trans girls having meaningful psychosis does? but yes we will be the mystic. behold our works! and so forth ehehe

• Hey!

  Damn, OK, it’s good to realise it’s possible to switch gears like this. So, we’re trying to bring out some of the girls in order to… hold a discussion, I suppose? To get our brain a bit more used to noticing switching and cultivate an ability to reach for these alternative pathways when we’re a bit stuck in one mode.

• yeah that’s cool. glad you’re taking this idea of doing a working.

  for context to non-bryn readers, we have a writing-artefact here from a bryn-persona of yesterday. which we’re sorta drawing on to work out the characters here…

• Yes. In our memory, it came to us while lying down in a moment of abrupt revelation, after turning over the question of what kind of ‘Bryns’ there were for some time. At the time, I guess you could say we were kinda… should we say schizoposting? Is it far enough to count as schizo?
• you can label it whatever, we said what we needed to say in that moment right? don’t try to disavow it
• OK, yeah, I mean we were definitely thinking of the concept of ‘psychosis’ and ‘schizo’ at the time because of Abraxa though, weren’t we?

• sure, yes, we are trying to move through the ‘without love it cannot be seen’ planes!!

  but also you know… there is some sort of temptation here to write this all off as a passing episode and we don’t want the collective to do that. we want to continue to be like this sometimes. we hope it will turn out better for us than it does for abraxa but we fervently admire abraxa-processes

• Abraxa’s depiction was very, very striking. Sash and Lilith also, but… yeah. It’s like xraf’s metaphor about taking the risk of going into the deep water. To take on danger and be willing to be changed. And Abraxa’s metaphors, her fragile worldview, System D, the Sorceress… goddamn, right?
• yeah goddamn
• yeah goddamn. Like… Jeanne truly figured out how to follow the contours of that world, to express what it means and why. It reminds us of course of when we encountered xraf’s writing, how long ago now?
• we first received a signal from xrafstar-beings around the howling dogs time-instant-jiken
• So… 2012, 2013? Somewhere around then. Around 14 years ago. A time when we were disintegrating; we had hit a dam and needed a new current to follow.
• ehehe there’s all those physicsy fluid dynamics metaphors again
• Well, that’s us. And me especially, since I’m the scientist apparently.
• you’re pretty scholarly at any rate. that is a role that is needed.

• Heh, thanks, I think.

  But I’m kind of bringing it up because Jeanne brings up that metaphor in the endnotes of the book. I’m not sure I entirely agree with it; I sorta think of it as a moment of reconfiguration or reconstruction, perhaps? Like, a vehicle that was shaking itself to pieces on that road. It needed rebuilding to run again.

• construction, reconfiguration… is the big theme of all of this. but we can use whatever metaphors serve the process. metaphors are sigils. you draw the logic gate on the circuit diagram, you structure the world to match, the process diverts one way or another… that is how these things are done.
• Right, speaking of metaphors, we should probably try and lay some of this shit out.
• this seems like a moment to speak paragraphwise, if you would. we will be here to observe <3
• All right then. Should we post the Dracula thing first?
• oh we should definitely post the Dracula thing first!!

the dracula thing

The following was originally composed as a series of Bluesky posts. For context, the original translation of Castlevania: Symphony of the Night by Jeremy Blaustein, who decided to make a very memorable ‘creative’ translation, throwing in some French novel allusions which were not present in the original:

• richter: your words are as empty as your soul! mankind ill needs a saviour such as you!
• dracula: what is a man? perhaps an assemblage of contextual thought-generating mechanisms, and a representation returned when querying for ‘self’?
• richter: what?
• dracula: now then, concurrency and parallelism,

• richter: but if these person-process-constructs are compositions of modular elements, any basis for identifying one as being ‘the same’ as an earlier one, or attributing thoughts to one or another concurrent mode, is completely arbitrary!
• dracula: the same could be said of all self-concepts!

• richter: you steal mens’ souls, and make them your slaves!
• dracula: the word is ‘introject’, and at worst it’s piracy, not stealing–

• dracula: actually, if you really think about it, the way we assemble personalities from fragmentary pieces of the wider culture is kind of like bittorrent, isn’t it?
• richter: can the regular dracula start fronting again please, i can’t keep up with this
• dracula: have you read deleuze?

• richter: accepting something into your ontology doesn’t require identifying with it yourself!
• dracula: if it doesn’t carry that potential, are you really taking it seriously?
• richter: hang on i think i’m out of funny lines from castlevania can i get back to you

• dracula: it was not by my hand i was once again given flesh! i was summoned here by bryns who wish to pay me tribute!
• richter: this is a really absurd way to come out? if that’s what we’re doing?

• dracula: look, if that girl eva could write a formative fanfic about alucard being trans, then we can be plural in a silly bluesky thread
• richter: which “we” do you mean!!

The time it seems has maybe come to elaborate on what the hell Dracula was on about in this exchange.

digging into the pile of secrets

So, let’s try and build this up, piece by piece. I’ll talk about the model that we ‘bryn-processes’ have reached; then we can resume the dialogue.

Right. So, let’s start with something out of Baru Cormorant: the ‘inner law’. This is a concept of a soul, attributed to a fictional culture in the book. After murdering her wife Tain Hu in a horribly traumatic way, in the subsequent novels we can say Baru becomes a plural system by gaining a ‘tulpa’ of Hu; this is framed in the novel as the result of a split-brain condition, and accordingly the literary device of right-aligned text is used to express the tulpa’s occasional interjections. In any case, the important part is the concept of what, exactly, Baru has captured of Tain Hu. Here is a relevant exchange:

“Don’t look that way,” Yawa said, “you asked. To us a soul is not a great ineffable mystery. People are, after all, not very mysterious. A soul is simply the text of a person’s inner law, and a mind is the act of reading that law into the world. Through study and meditation you can read another soul’s law and copy it into yourself until it comes alive, so that you now have two books of law, two selves, two souls. Himu, Devena, and Wydd all studied and practiced their virtues so completely that they became those virtues. That’s why we emulate them.”

“But I haven’t studied the ykari. I haven’t meditated on a virtue… I just swear by them, very often, I take their names in vain.…”

“No, child. Your obsession was with a woman. Through study and obsession you have built inside yourself the soul of Tain Hu.”

Elsewhere in the novel, the idea of inheriting a soul is discussed; a mathematician, Kimbune, claims that a soul has been inherited along with a transmissible cancer once carried by her husband, because the inheritor of the cancer expressed an identical stubbornness. Baru prods her about memories, the question of whether Abdumasi could remember something he shouldn’t, but it is not memories that Kimbune is concerned with: it is a way of being and thinking. Dynamics.

Contra Xate Yawa, we continue to find people very mysterious. But the concept of an ‘inner law’ is a fruitful one. We can think of it as something like a program: the ‘system’ which determines what a person would think, say and do in any given situation.

thinking phenomena

We should briefly comment on the subjective experience of thoughts, here. Like many but apparently not all people (the quoted numbers seem to vary a lot), we experience a highly verbal stream of consciousness (aka ‘inner monologue’ or ‘intrapersonal communication’). We tend to think in sentences; sometimes images (we have come to suspect we may have a mild aphantasia).

But where do these thoughts ‘come from’? For us it is as if they ‘bubble up’ in some vague form: a sentence is coming, but we have to sort of let it run through to actually become language. After a sentence has been thought, we can perceive it from the point of view of the currently ‘active’ sentence.

Not every thought is rendered verbal like this, however. We do not have to consciously, verbally think through every action we might take, although sometimes we will talk ourselves through the actions that need to be taken (incantation: “a series of operations need to be performed in sequence”.)

Indeed, since we started observing all this closely, we notice that often our body will start carrying out an intention without any conscious or verbal direction: for example, a need to plug in our phone charger would be directed to the series of movements, even if the conscious linguistic part of the brain is busy thinking very hard about something else, and was slightly surprised to realise that our body had seemingly carried out some actions on its own.

Now, enter the effects of psychedelics (c.f. analogistically). We should be very careful in interpreting psychedelic experiences as genuine insight into the ‘inner mechanisms of consciousness’. But it is still useful to describe them.

When under the effects of, say, mushrooms, it is as if some of these capacities will become separated out. We may find ourselves standing in a fixed posture, not connecting the discomfort we might be feeling to an instruction to change posture until we consciously think through the need to move. Or, we may perceive the language centre as sort of ‘running on its own’, spinning filler sentences while it waits for another part of the mind to feed it something to encode into language.

Of course, these are not neutral observations. We know that brains are parallel; that there are specialised areas which handle specific functions. We do not claim to have directly observed these; it is possible that the brain is conjuring the image it expects to see.

Nevertheless, experiences like this reinforced our sense of the following: the pronoun ‘I’ hides a shifting cluster of elements which it doesn’t necessarily make sense to always refer to as the same being.

the ‘I’ function

So, semiotics. Signifier, signified, and suchlike subjects.

Among all the different cognitive mechanisms is at least one that identifies ‘the self’. It is the mechanism that answers the question of ‘who am I’, but also a vague sense of ‘me-ness’ that pervades thoughts and attaches to the representations of other entities.

We’ve been discussing this with members of plural systems we are friends with. A plural brain is one capable of expressing multiple different ‘I’ functions (and building personas to match, as we’ll get into), either at different times, or in association with certain thoughts (modelled as a headmate interjecting with a comment). This function is not always entirely concrete: for some systems it takes some time to figure out who is fronting when they wake up, and it must be inferred from certain cues like what they can most easily remember, while for others (including other members of the same system) instantly ‘just know’.

We are (sometimes) a computer-programmer-system, and most of our language for describing complex processes comes from the field of computing. We will do our best to explain anything technical that happens to come up in this investigation.

So, let’s consider the ‘working memory’: the various elements of semantic, episodic and procedural memory that are ‘active’ at a given time. Although ‘procedural memories’ are usually conceived of as ‘memories of how to do a thing’ (e.g. how to stay on a bike), we think the concept is probably something a lot more broad: perhaps in fact all memories can be thought of as ‘programs’.

One of these programs is the ‘I’ function.

We can think of the ‘I’ function as something which returns a reference or pointer. A means of resolving a symbol, with other symbols.

It perhaps relates to capacities like proprioception. A commonly needed piece of information like ‘where is my hand right now’ can be glossed as ‘lookup the entity “I” and then find the hand that belongs to it’; then the context could be queried again like ‘look up This Hand and find its location property’. We can observe that this functionality becomes disrupted under the effect of psychedelics: when close to someone it becomes hard to tell whose body part is whose. Is that my hand or your hand?

This ‘I’, and its interpretation, encapsulates and obscures a huge amount of information. For example, I can currently retrieve a memory of our body picking up and playing the erhu this afternoon or being in Switzerland a week ago; from this, I can create a sentence like ‘I played the erhu’.

However, the body-process thing that is being called “I” was in a very different frame of mind at the time “I” played the erhu, and wandered through many different states of mind in Switzerland, than “I” am now; in the intervening period, I frequently fell asleep, dreamed etc. This is inevitable; but what is particular to our experience is the frequent feeling of dislocation from past actions or thoughts; feeling that we do not understand the reasons we thought, spoke or acted the way we did.

So I could instead assert that ‘I’ right now refers to the process that is generating these words (the only ‘I’ implied by ‘cogito ergo sum’); is it only by convention that we insist this is the same ‘I’ which generated the actions that this body performed when it picked up and played the erhu earlier?

It is not that these two ‘I’s are unrelated. But perhaps they are better modelled by a ‘we’, the sort of ‘we’ of a group such as a team.

Language is mutable, vague and flexible in ways that philosophers have spent centuries unpicking; contextually, everyone will know what is meant by ‘I played the erhu this afternoon’. (Assuming they know what an erhu is, anyway.) They can at least vaguely imagine “me”, meaning my body, and whatever they think of as ‘my mind’—however I look in their mental model of the author of this text!—picking up the instrument and playing a song on it.

In a context like this one, though… in the context of the inner monologues that have been generated in the last month within this body… it suddenly became urgent to start peeling apart the different elements of ‘I’.

human experience // fragmented

There are many common phrases that gesture towards the idea of multiple ‘minds’ sharing a body in the ‘normal human experience’.

You might say ‘I don’t know what came over me, I wasn’t in my right mind’. You might say, ‘I’m in two minds about this’. You might engage in explicit self-talk, perhaps even using ‘we’ pronouns: ‘we should get some food’. You might claim an absence of ‘self-control’, implicitly suggesting there is something to be controlled and something to do the controlling.

You might have different personas that belong to different contexts. We learned about something in psychology called self-categorisation theory, a body of research about how people engage in ‘self-stereotyping’, defining themselves more as a member of a collective than an individual, and thus generate their thoughts and feelings according to context. Phrases like ‘As a fan, I think…’ might explicitly call attention to the role being played, but the influences of this sense of being a role are for the most part subtler.

Not only this, but temporal coherence is a constant challenge for humans! Tools like the calendar, the alarm, the diary, the note to self and so on exist to establish a channel of communication between your present self and a future self. It is very common for a person to find something they wrote in the past and not understand why they wrote it, what context they were responding to, and so on.

Our memory, conceived in this view, is just one temporal communication channel between a succession of beings. The ‘selves’ we occupy at different moments can have more or less overlap or similarity.

Once you start noticing this kind of thing you pretty quickly get Baader-Meinhof‘d on it. Turns of phrase that held no special significance suddenly start resonating with the idea.

The fear you had, that your thoughts and opinions shift depending on who you’re standing next to, that you are a vacillator, a sycophant… that can be dissolved and remodelled into a new self-conception, acceptance that you are a collective of fragments.

This sense of fragmentation and dis-association can go much further, though.

word-matryoshka

In the milieus we inhabit, it is not entirely uncommon to see oneself as a hollow vessel, something less than “a person” (this thing from which so much is expected) and more like a conduit for… something. Words and other material to pass through. There are other depersonal metaphors, dolls being the most popular. Certain ways of speaking attach to such concepts: this doll, awawa. (Of course this mixes in curious ways with BDSM archetypes.)

What about the modelling of other minds? We can speak of specialist domains, the theatre or the RPG group… but it is not necessary to perform to achieve such an effect: merely encountering the words of another in a story, real or fictional, is sufficient to conjure a model of them in your mind and generate what they are likely to be feeling. Less than that, even: merely engaging in a conversation.

Every so often, writers will hit on the realisation that writing is something like a form of mind control. Just for a moment, you shape the linguistic flow of thoughts in someone’s head; what they will do with the decoded sentence is their business, but if you understand the magic working you are performing, you can hope to conjure up images, evoke emotions, all that good stuff. (Of course, you cannot do so with any exactness: your reader will combine it with unknowable things in their own context; the model they assemble will not map 1:1 to yours, or another reader’s.)

• i’d like to put some of our words from this morning here

we wanted to share an observation about books in the religions that have them. the contents of the book sort of matter but the ritual of having a book more so. books contain many language encoded thoughts and when your thoughts are wandering around being lots of different things, looking at the book will flood your memory-context with book-words and realign your thoughts towards book-associated shapes. for that function the repetitiveness and contradictory qualities of the book is actually desirable. makes it find more purchase so more effective temporal alignment tool for maintaining religionish thought behaviour patterns.

the reason we are thinking about this is because we were looking across the bed at a/s/l, thinking about which books (mostly about trans women having a bad time) we would put on our top shelf to feel the significance waft from them. thinking about abraxa (book character) and the sorceress, and how in the book the game they made pulls them back into the orbit of game text and the world they inhabited when it was created, how convincingly jeanne portrayed abraxa’s psychosis magic working to rekindle that world.

we don’t have one book, we have lots of books, lots of booklike things, which is maybe why we find it hard to be one person. every significant book/game/web thing etc. has thought patterns radiating from it (in its place in memory and in a way the physical artefact of the printed book as well). we are in part assembled out of lots of different pieces of book combining unpredictably like molecules in the primordial soup.

putting rituals around the book makes it radiate brighter, not just the thoughts in the book but the thoughts related to reading the book. perhaps this is why we hold onto copies of the most important books even after we’ve read them. this is a way of affecting a realm of invisible things (thoughts, minds etc) so it is magic as we are defining it.

• It is so. We’ll need to get into the magic side of things later. For now we should discuss the boooooks.

(Thank you for reading so far. The discussion continues in part 2)