It's a nautilus. If I remember correctly, the original idea came from `gyre -> spiral`, so I attached meaning to the spiral shape of its shell.

The reason gyre ended up in the name was that I had this idea that a world, or perhaps a program, keeps curling inward through layers.

At the time, I was studying state machines. Once you define a state machine, you also define its state space: how far that space can expand, what states are possible, and where its boundaries are.

But the more I programmed, the more I felt that software kept repeating the same structure inside itself. You establish an outer boundary, then inside that boundary you create another state space and another boundary, and then another one inside that.

So I started wondering whether a program is something that begins by defining an outer frame and then keeps spiraling inward.

When I first started designing the language, one of my biggest inspirations was D&D.

That's partly why I chose words like `ability` instead of `interface` or `trait`. The idea was closer to, "this subject must have this ability," rather than "this type implements this interface."

I like fantasy games, and most RPGs tend to describe their worlds using fairly similar concepts and vocabulary.

Around the same time, I was reading material about Simula 67. What interested me was the old question behind Simula: how do you represent a world using a programming language?

When humans describe worlds, we probably do it most extensively in fiction and games. So I thought: why not build a programming language using words humans already use when describing a world?

I started collecting those kinds of words and turning them into language concepts.

Originally it was just a small language with a C backend. Then AI arrived, I became more ambitious, and the project gradually grew much larger than I initially intended.

So there is a `World`, and inside the world there are `Zone`s. At first I considered using `Realm`, partly because of D&D, but in Korea people tend to use the word "zone" much more naturally for this kind of spatial division, so I ended up with `Zone`.

The project has grown quite a lot since then.

It's still incomplete. The source of truth for the semantics is not fully closed yet, and there are many rough edges, although I've confirmed that at least some of the basic ideas actually work.

I'm also trying to make it a memory-safe systems language without relying on a GC.

One of the inspirations was Vale, an experimental language that explored generational references. I took that idea and tried to expand it into something broader: in Pergyra, I think of a `Slot` as a resource identity, and the compiler tracks transitions in the state of that resource. (Vale itself seems to have moved away from that approach in its successor, Valen.)

The compiler pipeline is roughly:

`HIR -> DIR -> RIR -> MIR -> backend`

At the RIR level, memory accesses are interpreted as resource-state transitions, and resource operations are normalized there.

This does mean that Pergyra can carry more runtime machinery than some other systems languages when those checks cannot be eliminated. On the other hand, the same resource identity model has been useful for reasoning about parallel access and concurrency.

I still don't think I can honestly claim that the language is completely memory-safe yet, and I'm not even sure whether this approach will ultimately turn out to be the right one.

But as the design evolved, I noticed the same spiral structure appearing again:

`World -> Zone -> ... -> Slot`

The layers keep curling inward.

That's why I chose the nautilus.

There's another meaning I like as well: the nautilus is often described as a "living fossil," and in a way I'm taking an old question from Simula — how should a programming language represent a world? — and trying to revisit it from a different direction.

I don't really expect the language to become successful. I'm not even sure I've written the compiler particularly well. I'm currently using it in a few small projects to see whether the ideas survive contact with real software, but I don't know how far it will go.

Thank you for taking an interest in it.

My personal goal, though, is much simpler: I want to make a game in my own language.

I think that part is probably achievable within the next two years.