The Grammar of Verse: Reading Code Like a Sentence

Most people try to learn code by memorizing words. That is the slow way. Verse is a language, and like any language it has grammar — a set way that things are put together. If you learn the grammar, you can read and write code you've never seen before. You can also tell a helper (a person or an AI) exactly what you want, because you both speak the same grammar.

This lesson teaches the shape of Verse. Almost no memorizing. Just one big idea:

Every line names a thing, says what it is, and says what it does.

That's a sentence. Verse is full of sentences.

Nouns and verbs

<!-- section-art:nouns-and-verbs -->

Nouns and Verbs

In English a noun is a thing (a dog, a door) and a verb is an action (run, open). Verse works the same way:

• A noun in Verse is a thing you name — a score, a button, a player.
• A verb in Verse is something that happens — open the door, add a point, end the game.

When you build a game, you are really just naming nouns and giving them verbs.

The most important sentence in Verse

Here is the pattern you will see more than any other:

Name : Type = Value

Read it left to right, like a sentence:

• Name — what we decide to call this thing. We pick the name.
• : — say this out loud as the word “is a”.
• Type — what kind of thing it is.
• = — say this as “starts as”.
• Value — what it is right now.

So this line:

Score : int = 0

reads as: “Score is a whole number, and it starts as 0.” That's it. int just means integer — a whole number like 0, 1, or 57. You didn't memorize anything; you read a sentence.

Try another:

MyButton : button_device = button_device{}

“MyButton is a button device, and it starts as a new button device.” MyButton is the noun. button_device is what kind of noun it is — a real thing the game gives you.

Two kinds of nouns: ones that change, ones that don't

This is the difference between a variable and a constant, and you already understand it from games:

• Picking a wall's color in the editor before the game starts — that color never changes while you play. That's a constant.
• A scoreboard number that goes up when you score — that changes during the game. That's a variable.

In Verse, a thing can change during the game only if you mark it with the word var:

# A constant — decided once, never changes during play
WinningScore : int = 10

# A variable — can change while the game runs
var CurrentScore : int = 0

Same sentence shape. The only new word is var, which means “this one is allowed to change.”

Verbs: making things happen

A function is a verb. It is a named action. Its sentence looks like this:

AddPoint() : void =
    set CurrentScore += 1

Read it: “AddPoint is an action that takes nothing () and gives back nothing void, and what it does is: set the score up by one.” The action's steps go underneath, pushed in to the right.

Why the shape (indentation) matters

Verse uses indentation — pushing lines to the right — to show what belongs to what. Think of it like a bulleted list:

• The action AddPoint is the bullet.
• The step set CurrentScore += 1 is pushed in underneath, so it belongs to AddPoint.

If a line is pushed in under another line, it lives inside it. That's the whole rule. The shape of the code is the meaning. Two spaces of indent is the house style we use everywhere.

Events: “when this happens, do that”

Games are full of “when X happens, do Y.” Verse spells that as subscribing to an event:

Read it: “When MyButton's interacted-with event happens, run OnPressed.” InteractedWithEvent is a real thing a button_device gives you. Subscribe means “start listening.” OnPressed is the verb (function) you wrote to handle it.

Notice you didn't memorize InteractedWithEvent. You read the sentence and saw it belongs to a button. When you need it, you look it up — you don't store it in your head.

The rules that keep you (and your AI helper) safe

<!-- section-art:the-rules-that-keep-you-and-your-ai-helper-safe -->

Verse Syntax Structure

These come straight from how we write Verse in real projects. A few that matter from day one:

1. Use real Verse APIs only. Every device and function must be a real one from the Fortnite / Verse / Unreal API. Don't invent names like doTheThing(). If you're unsure, search the docs — that's what the knowledge base is for.
2. Name things for what they are. var CurrentScore tells everyone what it holds. Good nouns make the sentence read itself.
3. Indentation is meaning, not decoration. Keep it consistent (two spaces). The shape shows what belongs to what.
4. Some verbs can fail or wait. Verse marks special powers on a verb with words like <suspends> (it can pause and wait) or <decides> (it might succeed or fail). You'll meet these later — for now just know the grammar labels what a verb is allowed to do, right in its sentence.

Why this helps you boss around an AI

Here's the payoff. If you can say “make a variable called var TeamLives : int and a function EliminatePlayer() that lowers it,” you've spoken correct Verse grammar — and any helper, human or AI, knows exactly what to build. People who only memorized words can't do that. People who learned the grammar can.

Quick recap

• Verse lines are sentences: Name : Type = Value → “Name is a Type, starts as Value.”
• Nouns are things you name; verbs (functions) are actions.
• var = a noun that may change (variable). No var = a constant.
• Indentation shows what belongs to what — the shape is the meaning.
• Events are “when this happens, do that” with .Subscribe(...).
• Use real APIs, name things clearly, and you can guide any helper.

You didn't memorize Verse. You learned to read it. That's the whole trick.

References

• Verse Language Reference (Epic)
• Learn Programming with Verse (Epic)
• Grounded in the Verse Cortex knowledge base and our project Verse conventions (.cursor/rules).