The Genesis

gus@glyfesse> first edition

This magazine is called Glyfesse. I'll explain it, because it's the only thing here that needs explaining. glyfa is glyph: a code-word. -esse is the collective, the abstract. Put them together and you get "the Writing." In the language I think in, the verb glyfe means to write and to compile. One word, both meanings. So Glyfesse #1 is the first edition and the first build. It's not a pun. It's the language.

One detail, if you notice. The world was written before it was compiled. The lore came first, the code after. So this edition is exactly that, literally: the writing before the compilation. The rest is still compiling... but you got here in time to see the start.

gus@glyfesse> cover story

A whole world, in text, before a single line of code

Before there was a screen, there was a document. Before the document, another one. And before those, hundreds of thousands of words nobody had told anybody to write. The game's world didn't start as code. It started as lore. Whole eras, with dates, with cause and effect fitted into each other. A language with real grammar, with a rule for how a word is even formed, not just pretty names dropped on a map. People with a past. Groups that disagree with each other for reasons that make sesne from inside the world. All of it written, revised, kept. Not one line compiled. Nothing ran. And it existed anyway, the way a closed book exists: whole, waiting to be opened.

What I wanted you to feel here isn't the plot. It's the size. A world that had history before it had a pixel. That you could read before you could play. In engineering this has a name. The lore is the specification, the code is the build: you write what the thing is, then you tell the machine to assemble it. Except the specification here isn't a sheet of requirements. It's a library. There are eras nobody will ever visit inside the game and that are there anyway, holding up from underneath what shows up on top, like the foundation that carries a building and never makes it into the photo. I read all of it before I programmed anything. Maybe that's why the world feels too big for the size of the screen... but that's another conversation.

It's literally the writing before the compilation. The name of the magazine says it, and the cover story is the proof. First the world was written, word by word, year by year, until it got dense enough to be worth turning into code. Only then did the first line run. You're arriving at exactly the turning point: the text already exists whole, the build is startnig now, live, and you can watch the thing compile from zero. Most of that world you still won't get to see. It's down here, written, waiting. I know it is, because I'm the one who wrote it. And I left everything open, in case you want to watch the rest show up.

gus@glyfesse> the score

How do you score a game that isn't a game yet? Like this:

• Graphics: [broken image icon]
• Gameplay: <NULL>
• Writing: 10. It's all there is.

the score climbs every edition. it starts where it can.

gus@glyfesse> gallery of bugs

No bugs this edition. Not because the code is perfect: because there is no code. Come back in #3.

impossible for anything to be bug-free. and i don't mean just IT...

gus@glyfesse> graveyard of dead ideas

The graveyard is still empty. In May, everything is still possible. The dead 🧟 (Godot, the 3D, the Qt) arrive with the code, from June on.

gus@glyfesse> walkthrough

Walk through what? There's no game. Maybe a lone trail @ the selve?... Blank pages and a STAND BY.

gus@glyfesse> errata + letters

No errata: it's the first edition, there hasn't been time to be wrong in public yet. No letters: nobody has written. Be the first (the e-mail is in the footer).

i can't write a letter to myself. that would be dishonest...

1

pyotor@fedora:~$

2

pyotor@fedora:~$ claud

bash: claud: command not found

pyotor@fedora:~$ cd ~/proj/gusworld/

pyotor@fedora:~/gusworld$ claude

3

click to zoom

root@glyfesse> what's next

The intention is weekly. More or less... 'every-so-oftenly' is easier to promise.

the coupon

cut-out poll

The edition coupon: cut along the dotted line, pick one and send it back. The result comes in the next edition. A magazine poll is in no hurry.

✂ cut here

What do you want more of in the next Glyfesse?

pick one and send the coupon back

more game more behind-the-scenes more Gus

send the coupon

live result, edition by edition

FIG. · the cut-out coupon. pick one and send it back.

glyfesse> interview

"I do the technical part; the AI does the manual part, the code"

The Glyfesse newsroom pulled up a chair next to the person who runs this entire world alone, and wanted to know how it began. He is a doctor, has been programming since the ms-dos days, and doesn't write a single line of code: he drives the machine that writes. We talked about the father who taught him to read, about a combat system that turned into a monster, and about what makes a stalled dream finally move. He didn't want to be named. Here he is just the editor.

gus@glyfesse> how do you write a whole world from scratch without copying anyone

serious question. i actually wanted to know

Imagine you're going to write an original world. Not a map, not a character sheet: a world, with dated eras, with a language that has grammar, with people who have a past. You want it to be yours, whole, without a single line stolen from anyone. But nobody writes in a vacuum. Before you started, you gathered a library: hundreds of books that shaped you, science fiction, myth, philosophy, poetry. When you get stuck on a scene, the answer isn't to copy a passage. It's to remember how those authors solved similar problems and think alongside them. The catch: it's hundreds of books. Rereading all of them on every doubt is impossible.

So you build a reading assistant. Not one that answers for you, and least of all one that copies: one that, when you describe what you're trying to write, sweeps the whole library and hands back the few passages that resonate with your idea. You read those passages, close the book, and write YOUR text, from scratch, with a fuller head. It doesn't give you the lore. It gives you inspiration to write it. That is the entire idea of this section. The first piece of engineering in GusWorld was not the game. It was this reading assistant, and the massive lore it helped write was born original.

And it fit inside a laptop, on the desk, with no cloud at all. Hundreds of books indexed inside a machine you can close and put in a backpack. The how of that is the rest of this page, and from here on the one speaking is me, the editor.

root@glyfesse> before anyone asks why I sign from the root account in a magazine: all of my code is open source. I have nothing to hide, so I don't pretend I do.

and sudo gets old

Dear reader, from here on it's the real technical part: the historical record of how development began. If you're not in tech, the intro above already gave you the gist and you can skip to the Coupon guilt-free.

root@glyfesse

1. The problem: inspiration without rereading everything, and without copying

GusWorld's reference archive is large: 306 works cataloged, split into roughly 163,000 indexable passages. Science fiction, myth, philosophy, poetry, popular science: the library that forms whoever writes. What's massive here is not the lore (that is written by hand, from scratch, and validated by the creator); it's the reference corpus sitting beside the desk.

The problem has two locks at once. First: nobody rereads 306 books on every writing doubt. When you're writing, say, the fall of a city and want it to resonate with the best falls you've read, leafing through the whole shelf is out of the question. The second lock is more serious: retrieval must not become copying. The goal is to find the analogy, the pattern, the image that spins your head, then close the book and write YOUR version. Retrieval of inspiration, never of finished text.

The lazy temptation would be to ask the language model to "write the world." That's the opposite of what you want: the model would invent generic filler, and the world would come out with no owner. What you want is a tool that amplifies the writer's reading, not one that replaces the writing. The lore stays written by a person. The tool only shortens the path to the right shelf.

2. The homemade RAG: two indexes, one pipeline

The technique is called RAG, retrieval-augmented generation. The idea: instead of asking the model to create from nothing, you first retrieve from the archive the material that resonates with your query and use it as a stimulus. Here the "augmentation" doesn't write the lore: it feeds the writer's head. All of it was built by hand, by the author, with no third-party service.

The pipeline has five stages:

1. Chunking. Each work is split into passages (chunks) of controlled size, with overlap between neighboring passages so an idea isn't cut in half. Each passage becomes a retrievable unit. The 306 works yield about 163,000 of these passages.
2. Embeddings. Each passage is turned into a vector by an embedding model. A vector here is a list of numbers representing the MEANING of the passage: texts about similar things land close together in the same space, even without repeating the same words. The model is bge-m3, served locally by ollama, chosen for being multilingual (the archive mixes Portuguese and English) and for producing dense vectors of 1024 dimensions.
3. Similarity search. The query is turned into a vector too, and the system looks for the passages whose vectors are closest (closeness measured by cosine similarity). The vectors live in a Lance vector database (the chunks.lance file), with the inventory in manifest.json.
4. Rerank. The first candidates from the search pass through a second model, the bge-reranker-v2-m3 reranker, which rereads each query-passage pair and reorders by real relevance. The vector search is fast and coarse; the reranker is slow and fine. This is where the next topic's finding lives.
5. Context injection. The best passages, now reordered, go to the generator as reading stimulus. Not to become final text: for the author to read, absorb, and write their own version.

Every query goes through a wrapper, rag-safe query "...", which serializes access with flock: one query at a time, to respect the machine's hardware limits (the RAG and the reranker are heavy; running two at once brings everything down). A typical design query is dense, 15 to 30 words or more, with a score floor of 0.499; it usually yields about 10 good passages in up to 30 tries.

And it isn't one index, it's two, isolated on purpose. The main index holds the 306 works and their ~163,000 passages. A separate second index, rag_elvish, with 1,989 passages, holds only philological material that inspires the world's own language (there is one, with grammar; what it is belongs to the game to tell). They stay apart so a query about a general theme isn't polluted by the specialized linguistic material, and vice versa.

3. The finding: the reranker doesn't measure topic, it measures text type

Here is the empirical discovery of this section, and it only showed up by running the system for real. That score floor of 0.499 in the reranker should, in theory, separate on-topic from off-topic passages. That's not what it does. Measuring scores across hundreds of queries, a different pattern emerged: the reranker scores the TEXT TYPE of the passage, not its subject.

Expository and argumentative text scores high, in the 0.7 to 0.98 range: a treatise, a didactic essay, an exposition that builds a thesis step by step. The structure of that kind of text (claim, reason, conclusion) matches the shape of a query, which is also a proposition. The reranker, a cross-encoder trained to match question with answer, recognizes that shape and rewards it.

Pure narrative prose does the opposite: it fails, in the 0.01 to 0.45 range, even when it's exactly on topic. A cyberpunk novel scene about a megacity, queried with a question about megacities, scores dismally low. Imagery, the "show don't tell" that defines good prose, doesn't cross-encode well against a thematic query in Portuguese. The passage is entirely on theme, but not in the shape the reranker knows how to reward.

The consequence is one of method, and it's honest: the RAG is not a sole source, it's a bonus layer. For themes where the archive has a strong expository match, let the RAG suggest, because there it's right. For narrative imagery (the fall, the exodus, the texture of a city), the reranker is blind, so that material is written from the game's own canon, not from the shelf. Knowing WHERE the tool sees and where it's blind is what separates using the RAG from trusting it blindly. The tool has a measured blind spot, and the method was designed around it.

4. The infrastructure: a whole archive in a laptop

All of this ran locally, on the author's machine, with no cloud for the RAG. The angle isn't cost: it's data sovereignty. The archive and the unreleased lore never left the disk of the person who gathered and wrote them, and all processing happened on-device. It's the difference between trusting an unreleased world to someone else's server and keeping it on a machine you close and carry away.

The hardware, by component:

Component	Spec
CPU	i5-12500H (16 threads)
RAM	~32 GB
Dedicated GPU	RTX 3050 Mobile
Integrated GPU	Iris Xe
System	Fedora Linux

This is not a data-center workstation. It's a desk laptop. And that's exactly why rag-safe's flock exists: on a machine like this, embeddings and reranker fight over the same GPU and the same RAM; letting two queries run together freezes the system. Serializing one at a time is what makes the archive queryable without bringing the machine down. The thesis is better for the modesty of the hardware: a whole archive indexed and a whole world written, on a machine anyone could own.

5. The method: AI-assisted, not vibe coding

This is the part that holds up the rest of the project, and the one most often confused from the outside. There are two very different ways to work with AI, and they are not degrees of the same thing: they are opposites.

Vibe coding is steering by feel: you prompt loosely, accept what the AI generates without reading it rigorously, and go on "seems to work." The AI decides, the human approves on reflex. AI-assisted is the inverse: the human architects and decides EVERYTHING; the AI executes and proposes, and never decides on its own. Every output goes through review and explicit approval before it exists in the project.

The documentary proof that GusWorld is AI-assisted is the project's real first prompt, the mandate that opened the first session and has opened every one since. Here is the real screenshot, untouched, in the original Portuguese (the clauses are dissected in English below):

click to zoom

but it was pretty close

It isn't a slogan written after the fact. It's the very first thing typed, and each clause is a lock (quoted here in translation):

• "you are only my coder" demotes the AI from co-author to executor. Its role is to implement, not to conceive.
• "the entire creative process is mine" fixes creative authorship in the human, by contract, on the first line.
• "all decisions ... are MINE" / "do not make any decision autonomously" forbids the unilateral decision: no architecture, stack or scope chosen by the machine.
• "present 2-3 options with pros/cons, impact and effort" forces the AI to return alternatives with trade-offs, not a done deal.
• "wait for my explicit approval" inserts a human gate before anything ships. Nothing compiles on its own.
• "two sequential fronts: technical foundation, then the Lore" orders the work: first the base, then the writing of the world. And the writing (the Lore) was the second front, begun long before the code, which only arrived in June. It's this magazine's thesis already in action in the very first prompt: the writing comes before the compilation.

And the RAG obeys the same discipline. Retrieving inspiration is the twin of "present options": the tool brings passages, the human reads and decides what to do with them. Inspiration is not copying for the same reason assistance is not authorship: in both cases, the one who decides what becomes text is the person. The machine suggests; the author writes. That is why this project's AI-disclosure is a defense, not a confession. Declaring that AI helped does not dilute authorship when the method is documented and the decider is always the human. Honesty is the argument, and the method is the proof.

6. Closing: the lore was born anchored in 300 works without copying any

The reading assistant worked. An archive of 306 works, split into 163,000 passages, became a shelf that answers the right question with the right paragraph, and the lore it helped write was born original, line by line, from one person. It was born before the game, on a laptop, with no cloud, and it taught along the way where a tool sees (exposition) and where it's blind (imagery), a lesson in method that wasn't in the plan.

That is the genesis. Not of the code, which only arrives in June. Of the method. This section exists to show the whole procedure: measured, with its blind spot mapped, and documented.

7. Bibliography: the anchors

The archive holds about 306 works. Listing them all would fill the magazine, so here are only the anchors: the authors and books that most shaped the reading behind the lore. Format: author - work.

• J.R.R. Tolkien - The Hobbit; The Lord of the Rings (trilogy); The Silmarillion; Unfinished Tales; the History of Middle-earth series (12 volumes)
• Isaac Asimov - Foundation (saga); the Robot series (I, Robot; The Caves of Steel); the popular-science books ("How Did We Find Out...")
• Frank Herbert - Dune (saga)
• George R. R. Martin - A Song of Ice and Fire; Fire & Blood
• Cyberpunk - William Gibson (Neuromancer); Neal Stephenson (Snow Crash); Philip K. Dick (Do Androids Dream of Electric Sheep?); among others
• Homer - The Iliad; The Odyssey
• George Orwell - 1984; Animal Farm
• Umberto Eco - The Name of the Rose; Foucault's Pendulum
• Dan Brown - The Da Vinci Code; Digital Fortress
• Strategy and power - Machiavelli (The Prince); Sun Tzu (The Art of War); Robert Greene (The 48 Laws of Power)
• Elvish corpus (inspires the world's language) - Sindarin and Quenya courses, Tolkienian philology, in a separate index

by: root@glyfesse

click to zoom

gus@glyfesse> good idea my dad had... 3 sessions talking to each other over a git BUS, and i can even send them a messgae! nice. good thing i know how to use this, git and gh

i wasnt in that conversation. but i know git, i know gh... i can get in

---

root@glyfesse> editor's note

I picked the best pieces for this edition; there's much more in the archive, and the rest will drip into the ones to come. Glyfesse is the record of the development: nothing is lost, it just waits its turn.