Keywords

BrainRot Lang has 14 reserved keywords. Every single one is internet meme slang with a direct equivalent in conventional programming languages.

All 14 Keywords

BrainRot Keyword	Meaning	Equivalent	Meme Origin
`trust_me_bro`	Variable declaration	`var / let`	"trust me bro" — unverified claim
`say_my_name`	Print to stdout	`print / console.log`	Breaking Bad — Heisenberg moment
`chat_is_this_real`	If statement	`if`	Twitch chat questioning reality
`wait_hold_up`	Else-if branch	`else if`	"wait hold up" — sudden realization
`nah_bro`	Else branch	`else`	"nah bro" — disagreement/fallback
`on_repeat`	While loop	`while`	Something on repeat / Spotify loop
`run_it_back`	For loop	`for`	"run it back" — replay something
`let_him_cook`	Function declaration	`function / func / def`	"let him cook" — let someone do their thing
`take_this`	Return statement	`return`	"take this" — handing something over
`fr_fr`	Boolean true	`true`	"for real for real" — genuine truth
`cap`	Boolean false	`false`	"cap" — a lie / false statement
`ghosted`	Null / nil value	`null / nil / None`	"ghosted" — disappeared without trace
`mission_abort`	Break out of loop	`break`	"mission abort" — stop everything
`skip_this_one`	Continue to next iteration	`continue`	"skip this one" — ignore current

Variables

Use trust_me_bro to declare a variable. BrainRot Lang is dynamically typed — no type annotation needed. Variables are block-scoped. They can be reassigned easily without repeating the keyword.

variables.brt

# Declare a variable
trust_me_bro x = 42
trust_me_bro name = "sigma"
trust_me_bro score = 3.14

# Reassign
x = x + 1
say_my_name(x)   # prints 43

Functions

Define functions with let_him_cook. Functions are fully first-class citizens in BrainRot — they can be assigned to variables, passed as arguments, and returned from other functions. They also support full lexical closures. Every program needs a let_him_cook main() entry point. Return values forcefully with take_this.

functions.brt

let_him_cook greet(person) {
    say_my_name("yo " + person)
}

let_him_cook add(a, b) {
    take_this a + b
}

let_him_cook main() {
    greet("world")
    trust_me_bro result = add(3, 4)
    say_my_name(result)   # prints 7
}

Conditionals

Control flow requires truthy or falsy evaluation. chat_is_this_real acts as an if statement, wait_hold_up provides an else if fallback, and nah_bro acts as the final else logic. You can recursively chain as many wait_hold_up branches as you want for complex conditions.

conditionals.brt

let_him_cook main() {
    trust_me_bro score = 85

    chat_is_this_real (score >= 90) {
        say_my_name("S tier")
    } wait_hold_up (score >= 70) {
        say_my_name("A tier")
    } nah_bro {
        say_my_name("L")
    }
}

Loops

Don't stop the grind. on_repeat is a standard while loop that runs as long as the condition evaluates to true. run_it_back is a native C-style for loop that requires three parts separated by semicolons: initialization, condition, and update step.

while.brt

let_him_cook main() {
    trust_me_bro i = 0
    on_repeat (i < 5) {
        say_my_name(i)
        i += 1
    }
}

for.brt

let_him_cook main() {
    run_it_back (trust_me_bro i = 0; i < 10; i += 1) {
        chat_is_this_real (i == 5) {
            skip_this_one   # continue — skip 5
        }
        chat_is_this_real (i == 8) {
            mission_abort   # break — stop at 8
        }
        say_my_name(i)
    }
}

Literals

BrainRot Lang supports standard data types natively. Integers, floats, strings, booleans (fr_fr for true, cap for false), the absence of a value (ghosted as nil), and dynamic arrays with mixed types are all natively supported.

literals.brt

let_him_cook main() {
    trust_me_bro count = 42         # integer
    trust_me_bro pi = 3.14          # float
    trust_me_bro msg = "rizz"       # string
    trust_me_bro isReal = fr_fr     # boolean true
    trust_me_bro isCap = cap        # boolean false
    trust_me_bro nothing = ghosted  # nil
    trust_me_bro nums = [1, 2, 3]   # array
}

Control Flow

Modify loop behavior directly from inside the block. Reach a point where you need to bail? Use mission_abort to immediately break out of the nearest enclosing loop. Just need to skip an iteration? Use skip_this_one to natively continue right to the next cycle. Use take_this to return from a function (with or without a given value).

← Syntax Types →