Mog: A Programming Language for AI Agents

What if an AI agent could modify itself quickly, easily, and safely? Mog is a programming language designed for exactly this.

Jump to Code Examples ↓

Overview

Mog is a statically typed, compiled, embedded language (think statically typed Lua) designed to be written by LLMs – the full spec fits in 3200 tokens.

• An AI agent writes a Mog program, compiles it, and dynamically loads it as a plugin, script, or hook.
• The host controls exactly which functions a Mog program can call (capability-based permissions), so permissions propagate from agent to agent-written code.
• Compiled to native code for low-latency plugin execution – no interpreter overhead, no JIT, no process startup cost.
• The compiler is being rewritten in safe Rust so the entire toolchain can be audited for security.
• Even without a full security audit, Mog is already useful for agents extending themselves with their own code.
• MIT licensed, contributions welcome. https://github.com/voltropy/mog

Why Mog?

A general-purpose AI agent should be able to continuously extend and modify itself. Over time, an agent should grow into a personal server that manages tasks in all kinds of ways. To do that, the agent needs to write its own code – and that code needs to be safe.

The simplest kind of program an agent writes is a one-off script to achieve some task. Examples:

• Converting a markdown file to PDF.
• Analyzing a CSV with database results.
• Sending test requests to an application’s HTTP endpoint.
• Renaming all the files in a folder.
• Installing dependencies.

Coding agents typically use bash for this, and sometimes reach for an inline Python or TypeScript script. Mog is well-suited for this: it’s easy to write and it compiles fast. Notably, scripting is one of the main ways an agent escapes its sandbox, and Mog closes that loophole. Even if Mog is given a capability by its host agent to call bash commands, the host still has the ability to filter those commands according to its permissions, just as if the model had called its bash tool directly.

The second kind of program agents commonly write is a hook: a piece of code that runs repeatedly at a certain point in the agentic loop. Pre- and post-tool-use hooks are common, as well as pre-compaction hooks. For a hook, it’s not important for it to compile quickly, but it needs to start up quickly and execute quickly, since it can get called frequently enough that a slow implementation would meaningfully drag down the user experience. Mog compiles to native code, and it can then load that machine code into the agent’s running binary. The key property that makes this safe: native code compiled by the Mog compiler can’t do anything other than what the host explicitly lets it do – not even exceed limits on memory or time. The agent can incorporate a Mog program into itself at runtime and call into it without inter-process communication overhead or process startup latency.

The third category is writing or rewriting parts of the agent itself. This could mean adding a new tool that the agent exposes to the LLM, a status line for the user interface, settings about agent skills or session management – a potentially long list of agent internals that would benefit from extension or specialization.

One could imagine a microkernel agent, written as a small backbone of Rust code that calls into Mog code for almost all its features. The kernel would manage the event loops, multi-threading, root permissions, compiling and loading Mog programs, and maybe part of its upgrade functionality, but the rest of the system could be written in Mog – running with minimal, granular permissions and upgradeable on the fly without a restart, just by prompting the agent to modify itself.

Alternatives

Without something like Mog, every option for AI-generated agent code has a downside. One major one is enforcing permissions: tools like Jeffrey Emanuel’s dcg can interdict rm -rf and similarly destructive shell commands, but they can’t stop an agent from emitting Python that iterates through files in a folder and calls os.remove() on each one.

The next step is generally to run the agent in a sandbox, like a Docker container. But then the permissions tend to apply to the whole sandbox, so letting the agent use the host computer in nontrivial ways (e.g. pull in environment variables, access CLI tools, drive a browser, make HTTP requests) requires opening up the sandbox boundary. At that point the agent has regained essentially unfettered access to that capability.

What’s missing is a way to propagate the permissions granted to an agent to the programs that agent writes. Mog addresses this directly.

Another issue with external scripts is sharing them – receiving a script from an untrusted source is a security risk. With Mog, the receiving agent compiles the Mog source itself, rather than running a pre-compiled binary that could take over the machine.

There are other approaches to LLM-driven extension systems. Jeffrey Emanuel is building something similar using JavaScript containers with permissions, which is quite close to Mog in spirit, and has an impressive level of infrastructure behind it. Mog could complement such systems, especially for higher-performance plugins – Mog’s infrastructure is also in Rust, making integration straightforward. Emanuel’s Rust version of the Pi agent would be a natural starting point for a Mog-based microkernel agent.

WASM is another natural option, since it’s a more standard sandboxing technique. Mog takes a different approach: a hot loop over an array runs at native speed, without the unpredictability of JIT compilation, the overhead of WASM interpretation, or the process startup time of an external binary.

The Language

Mog is a minimal language designed to be written by LLMs. Its full specification, with examples, fits in a single 3200-token markdown file, which an LLM can pin in context when writing Mog programs. Everything about the language is designed to optimize the latency between asking an LLM to write a program for a task and having a performant program that implements that task.

The primary goal of Mog syntax is to be familiar to LLMs. It’s a mix of TypeScript, Rust, and Go, with a couple of Pythonisms. Its module system is modeled on Go modules. It’s a small but usable language with no foot-guns: no implicit type coercion, no operator precedence, and no uninitialized data.

Why statically typed and compiled? Because latency matters in this domain. Consider an agent plugin that runs before every tool call – it needs to be fast, or it’s not worth using. Jeffrey Emanuel rewrote every single one of his agent plugins in Rust to reduce startup time and Python overhead. A modern computer is fast, but Python is not. Even Bun’s startup time, which has been heavily optimized, is nowhere near the startup time of a Rust program, and even that is slow compared to calling into an in-process library.

Example

Here’s a Mog hook that an agent might write to monitor its own tool calls for errors:

requires fs;  // must be provided by host
optional log; // runs without it

pub fn on_tool_result(tool_name: string, stderr: string) {
  if (stderr.contains("permission denied")) {
    log.warn(f"{tool_name}: permission denied");
    fs.append_file("agent.log", f"[warn] {tool_name}: {stderr}\n");
  }
}

The first two lines tell the security story: this hook can append to a file and optionally log, but it cannot make HTTP requests, run shell commands, or read environment variables. The host decides what this program is allowed to do – it can even interdict the fs.append_file() call if this program doesn’t have that permission.

To learn more about how to use Mog, see the detailed Mog Language Guide.

As agents get more complex and more of their code is bespoke, performance, correctness, and security of the combined system become harder to maintain. Mog is designed to address these issues.

The Capability System

Mog is an embedded language. It runs inside a host program, much like Lua – the way a Mog host provides functions to the guest Mog program is based directly on Lua’s elegant and battle-tested design. By itself, a Mog program cannot do any I/O, perform syscalls, or access raw memory. It can only run functions and return values. That is the extent of Mog’s sandbox.

Any I/O, FFI, syscalls, or interaction with other systems can only be done by calling a host function – a function that the host makes available to the Mog program. This is the essence of Mog’s capability system: the host decides exactly which functions it will allow the guest to call. The host is also free to filter the inputs to such a function and to filter the response delivered back to the Mog program.

Part of this isolation involves preventing a Mog program from taking over the host process in subtler ways. An upcoming feature will allow the host to control whether a Mog program can request a larger memory arena, preventing the guest from consuming all available RAM. An existing feature is cooperative interrupt polling: Mog loops all have interrupt checks added at back-edges, which allows the host to halt the guest program without killing the process. This enables timeout enforcement. There is no way for a guest program to corrupt memory or kill the process (assuming correct implementation of the compiler and host).

Since a typical agent runs an event loop, Mog programs are designed to run inside an event loop, familiar to anyone who has written JavaScript or TypeScript. Mog’s support for this consists primarily of async/await syntax. Mog programs can define async functions, and importantly, the host can also provide async functions that the guest can call. This allows a guest program to fire off an HTTP request and a timer and do something different depending on which one finishes first – internally the compiler implements this using coroutine lowering, based on LLVM’s design for the same.

The Compiler

The compiler uses QBE as its code generation backend, which is being rewritten in safe Rust. Once complete, the entire toolchain for compiling, loading, and running a Mog program will be in Rust – the goal is for all of it to be safe Rust, making it much more difficult to find an exploit in the toolchain.

The first implementation of Mog used LLVM as the backend. LLVM can produce somewhat faster code due to its wide array of optimizations, but it had two major issues. First, compile times were not fast enough. The new compiler has compile times that are not quite as good as Go’s, but within an order of magnitude for programs under 1000 lines – fast enough that the start time for one-off scripts is not painful. Mog does not claim to provide zero-cost abstractions or arbitrary opportunities for low-level optimization. It compiles to native code, but an expert can still write faster C or C++.

The second issue with LLVM is that for Mog, the compiler itself is part of the trusted computing base. If the compiler has a security flaw, the agent has a security flaw. This rules out an enormous codebase like LLVM’s. The compiler needs to be small enough to control and audit.

Current Status

Mog was created entirely using the Volt coding agent, the vast majority of which used a single continuous session spanning over three weeks, using Voltropy’s Lossless Context Management to maintain its memory after compactions. This session is still running, porting the QBE compiler to safe Rust. The models used were Claude Opus 4.6, Kimi k2.5, and GLM-4.7.

Significant work remains to standardize the functions that hosts provide to Mog programs. This should include much of what the Python standard library provides: support for JSON, CSV, SQLite, POSIX filesystem and networking operations, etc. The Mog standard library should also provide async functions for calling LLMs – both high-level interfaces (like Simon Willison’s llm CLI tool or DSPy modules) and low-level interfaces that allow fine-grained context management.

To be clear: Mog has not been audited, and it is presented without security guarantees. It should be possible to secure it, but that work has not yet been done. There are tests that check that a malicious Mog program cannot access host functionality that the host does not want to provide, but this design has enough security attack surface to warrant careful scrutiny.

Even without audited security properties, Mog is already useful for extending AI agents with their own code – they’re not trying to exploit themselves. For untrusted third-party code, treat the security model as unverified until a formal audit is completed.

The Mog Language Guide

A complete guide to learning and using the Mog programming language. Jump to Code Examples

Chapter 1: Your First Mog Program

This chapter walks through the basics of writing and running Mog code. By the end, you will understand how a Mog program is structured, how to print output, how to write comments, and how to define and call functions.

Hello, World

Every Mog program needs a main function. Here is the simplest complete program:

fn main() -> int {
  println("Hello, world!");
  return 0;
}

fn main() -> int declares the entry point. The -> int annotation means the function returns an integer — by convention, 0 signals success. The println function prints a string followed by a newline. The return 0; statement exits the program.

Semicolons are required after every statement. Curly braces delimit blocks. If you are coming from Go or Rust, this will feel natural. If you are coming from Python, the semicolons may take a few minutes to get used to.

How Mog Programs Are Compiled and Run

Mog is a compiled language. You write a .mog source file, compile it to a native executable, and run the executable. The compiler is written in Rust:

# Build the compiler (once)
cargo build --release --manifest-path compiler/Cargo.toml

# Compile a Mog program to a native executable
mogc hello.mog

# Run the resulting binary
./hello

The compilation pipeline works like this: the Rust compiler reads your .mog file, lexes it into tokens, parses it into an abstract syntax tree, analyzes and type-checks it, generates QBE intermediate language, and passes it to rqbe (a safe Rust QBE backend that runs in-process). rqbe emits assembly, which the system assembler and linker turn into a native binary linked with the Mog runtime. The whole process takes milliseconds for small programs.

There is also a convenience script that compiles, links, and runs in a single step:

./algb hello.mog

In production, Mog programs run embedded inside a host application. The host compiles the script, registers capabilities, and invokes the compiled code through a C API. But for learning the language, the standalone compilation path is all you need.

There is a third compilation mode: plugins. You can compile a .mog file into a shared library (.dylib on macOS, .so on Linux) instead of a standalone executable. The host loads the library at runtime with dlopen, queries what functions are available, and calls them by name. Functions marked pub in the source become exported symbols; everything else gets internal linkage and is invisible to the loader. This is the right path when you want pre-compiled, hot-swappable modules — the host never sees the source code, just a binary it can load and unload. See Chapter 14 for the full plugin API.

The compiler uses rqbe, a safe Rust implementation of the QBE backend, as its code generation engine. rqbe runs entirely in-process — no external tools are needed beyond the system assembler and linker. It compiles fast and produces correct native code for ARM64 and x86.

Program Structure

A Mog source file is a sequence of top-level declarations followed by a main function. Top-level declarations include functions, structs, and capability requirements. You cannot put executable statements at the top level — all code runs inside functions.

// Top-level: struct declaration
struct Point {
  x: float,
  y: float
}

// Top-level: function declaration
fn distance(a: Point, b: Point) -> float {
  dx := a.x - b.x;
  dy := a.y - b.y;
  return sqrt((dx * dx) + (dy * dy));
}

// Top-level: entry point
fn main() -> int {
  p1 := Point { x: 3.0, y: 0.0 };
  p2 := Point { x: 0.0, y: 4.0 };
  d := distance(p1, p2);
  println(f"Distance: {d}");
  return 0;
}

The order of declarations does not matter — you can call a function that is defined later in the file. The compiler resolves all names before generating code.

Here is a program with multiple functions that call each other:

fn square(x: int) -> int {
  return x * x;
}

fn sum_of_squares(a: int, b: int) -> int {
  return square(a) + square(b);
}

fn main() -> int {
  result := sum_of_squares(3, 4);
  println(f"3² + 4² = {result}");  // 3² + 4² = 25
  return 0;
}

And a program that uses a struct and a helper function:

struct Rectangle {
  width: float,
  height: float
}

fn area(r: Rectangle) -> float {
  return r.width * r.height;
}

fn main() -> int {
  r := Rectangle { width: 5.0, height: 3.0 };
  a := area(r);
  print_string("Area: ");
  print_f64(a);
  println("");
  return 0;
}

Comments

Mog supports two kinds of comments. Single-line comments start with // and run to the end of the line. Multi-line comments are delimited by /* and */.

// This is a single-line comment

/* This is a
   multi-line comment */

fn main() -> int {
  // Comments can appear on their own line
  x := 42;  // or at the end of a line

  /*
   * Multi-line comments are useful for temporarily
   * disabling blocks of code or writing longer
   * explanations.
   */

  println(f"x = {x}");
  return 0;
}

Multi-line comments do not nest. A /* inside a multi-line comment is treated as ordinary text, and the first */ ends the comment. In practice, single-line comments are far more common.

fn main() -> int {
  // Calculate the sum of integers from 1 to 10
  sum := 0;
  i := 1;
  while (i <= 10) {
    sum = sum + i;
    i = i + 1;
  }
  println(f"Sum: {sum}");  // Sum: 55

  /* Temporarily disabled:
  println("This line does not execute");
  */

  return 0;
}

Print Functions

Mog provides several built-in functions for printing output. These are always available — no imports needed.

The most common is println, which prints a string with a trailing newline. For formatted output, combine it with f-string interpolation:

fn main() -> int {
  println("Hello, world!");

  name := "Mog";
  println(f"Welcome to {name}!");

  x := 42;
  println(f"The answer is {x}");

  return 0;
}

Output:

Hello, world!
Welcome to Mog!
The answer is 42

When you need to print numbers without f-string formatting, use the type-specific print functions:

fn main() -> int {
  // Print an integer
  print_string("Count: ");
  println_i64(42);

  // Print a float
  print_string("Pi: ");
  print_f64(3.14159);
  println("");

  // print() also works for integers
  print_string("Score: ");
  print(100);
  println("");

  return 0;
}

Output:

Count: 42
Pi: 3.141590
Score: 100

The print_string function is useful when you want to build a line of output from multiple parts without newlines between them:

fn main() -> int {
  print_string("Loading");
  print_string(".");
  print_string(".");
  print_string(".");
  println(" done!");
  return 0;
}

Output:

Loading... done!

F-string interpolation (the f"..." syntax) is the preferred way to format output in Mog. It can embed any expression inside {} delimiters:

fn main() -> int {
  width := 10;
  height := 5;
  println(f"Rectangle: {width} x {height} = {width * height}");

  name := "Alice";
  score := 95;
  println(f"{name} scored {score} points");

  a := 3.14;
  println(f"Value: {a}");

  return 0;
}

Output:

Rectangle: 10 x 5 = 50
Alice scored 95 points
Value: 3.14

A More Complete Example

Let’s put everything together. Here is a program that defines a few functions, uses variables and arithmetic, and prints formatted output:

fn factorial(n: i64) -> i64 {
  if (n <= 1) {
    return 1;
  }
  return n * factorial(n - 1);
}

fn fibonacci(n: i64) -> i64 {
  if (n <= 0) { return 0; }
  if (n == 1) { return 1; }
  a: i64 = 0;
  b: i64 = 1;
  i: i64 = 2;
  while (i <= n) {
    temp: i64 = a + b;
    a = b;
    b = temp;
    i = i + 1;
  }
  return b;
}

fn main() -> int {
  // Factorial
  println(f"5! = {factorial(5)}");
  println(f"10! = {factorial(10)}");

  // Fibonacci
  println(f"fib(10) = {fibonacci(10)}");
  println(f"fib(20) = {fibonacci(20)}");

  // Simple arithmetic
  x := 42;
  y := 13;
  println(f"{x} + {y} = {x + y}");
  println(f"{x} - {y} = {x - y}");
  println(f"{x} * {y} = {x * y}");
  println(f"{x} / {y} = {x / y}");
  println(f"{x} % {y} = {x % y}");

  return 0;
}

Output:

5! = 120
10! = 3628800
fib(10) = 55
fib(20) = 6765
42 + 13 = 55
42 - 13 = 29
42 * 13 = 546
42 / 13 = 3
42 % 13 = 3

A few things to notice:

• Functions are defined with fn, parameters have type annotations, and the return type follows ->.
• The factorial function calls itself recursively. Mog supports recursion naturally.
• The fibonacci function uses a while loop with mutable variables. The := operator is used inside the loop (i = i + 1) to reassign. Variables declared with an explicit type annotation like a: i64 = 0 can be reassigned with =.
• F-strings can embed arbitrary expressions: {x + y} computes the sum inline.
• Integer division (/) truncates toward zero, and % gives the remainder.

Here is one more example — a program that computes the sum of the first N squares:

fn sum_of_squares(n: int) -> int {
  total := 0;
  for i in 1..n + 1 {
    total = total + (i * i);
  }
  return total;
}

fn main() -> int {
  for n in [5, 10, 20, 100] {
    println(f"Sum of squares(1..{n}) = {sum_of_squares(n)}");
  }
  return 0;
}

Output:

Sum of squares(1..5) = 55
Sum of squares(1..10) = 385
Sum of squares(1..20) = 2870
Sum of squares(1..100) = 338350

This example shows for-in loops over both ranges (1..n + 1) and arrays ([5, 10, 20, 100]). We will cover control flow in detail in a later chapter — for now, the syntax should be readable.

What Mog Is Not

Mog is deliberately not many things. Each omission keeps the language small, the security model tractable, and the compilation fast:

• Not a systems language. No raw pointers, no manual memory management, no POSIX syscalls, no direct OS access.
• Not standalone. Mog is always embedded in a host application. There is no standard library for file I/O or networking — the host provides everything.
• Not general-purpose. Mog is for scripts, plugins, and orchestration. It is not designed for building web servers, operating systems, or databases.
• Not object-oriented. No classes, no inheritance, no methods on types. Structs hold data; functions operate on data. Higher-order functions and closures provide the abstraction mechanisms.
• No macros or metaprogramming. The language you see is the language that runs. No code generation, no compile-time evaluation, no syntax extensions.
• No generics. Beyond tensor dtype parameterization (tensor<f32>, tensor<f16>), there are no generic types or functions. This keeps the type system simple and the compiler small.
• No exceptions with stack unwinding. Error handling uses Result<T> with explicit propagation via ?. Errors are values, not control flow.
• No threads or locks. Concurrency is cooperative via async/await, with the host managing the event loop.

If you need any of these features, Mog is probably not the right language for your use case — and that’s fine. Mog is designed to do a few things well rather than everything adequately.

What’s Next

You now know how to write, compile, and run a Mog program. You have seen the basic program structure, comments, print functions, and how to define and call functions with typed parameters. Chapter 2 covers variables and bindings in depth — how := and = work, type annotations, and scoping rules.

Chapter 2: Variables and Bindings

Mog keeps variable declaration simple: there are no var, let, or const keywords. You create bindings with := and reassign them with =. That’s it.

Creating Bindings with :=

The := operator declares a new variable and assigns it a value. The type is inferred from the right-hand side:

name := "Alice";
age := 30;
score := 95.5;
active := true;

Every binding needs an initial value — there are no uninitialized variables in Mog.

fn main() {
  greeting := "hello, world";
  count := 0;
  pi := 3.14159;
  print(greeting);
  print(count);
  print(pi);
}

You can create bindings in sequence, and later bindings can reference earlier ones:

fn main() {
  width := 10;
  height := 20;
  area := width * height;
  print("area = {area}");  // area = 200
}

Bindings work inside any block scope — function bodies, if branches, loop bodies:

fn main() {
  x := 42;
  if x > 0 {
    label := "positive";
    print(label);
  }
  // label is not accessible here
}

Reassignment with =

Once a variable exists, use = to change its value. All variables in Mog are mutable:

fn main() {
  count := 0;
  count = 1;
  count = count + 1;
  print(count);  // 2
}

The distinction matters: := creates, = updates. Using = on a name that doesn’t exist is a compile error. Using := on a name that already exists in the same scope creates a new shadowed binding (see below).

fn main() {
  x := 10;
  x = 20;       // reassignment — fine
  x = x * 2;    // reassignment — x is now 40
  print(x);     // 40
}

A common pattern is accumulating a result in a loop:

fn main() {
  total := 0;
  for i in 1..11 {
    total = total + i;
  }
  print(total);  // 55
}

Building a string incrementally:

fn main() {
  result := "";
  names := ["Alice", "Bob", "Charlie"];
  for i, name in names {
    if i > 0 {
      result = result + ", ";
    }
    result = result + name;
  }
  print(result);  // Alice, Bob, Charlie
}

Type Annotations

Mog infers types from the right-hand side, but you can annotate explicitly when you want to be clear about intent:

x := 42;             // inferred as int
x: int = 42;         // explicit — same result

ratio := 3.14;       // inferred as float
ratio: float = 3.14; // explicit — same result

name := "Mog";       // inferred as string
name: string = "Mog"; // explicit

Explicit annotations are useful when the default inference isn’t what you want:

// Without annotation, 42 is int
n := 42;

// With annotation, you can specify a different integer type
n: i32 = 42;
n: u64 = 42;

They also help document intent in longer functions:

fn process_data(items: [string]) -> int {
  count: int = 0;
  total_length: int = 0;

  for item in items {
    count = count + 1;
    total_length = total_length + item.len;
  }

  average: float = total_length as float / count as float;
  print("average length: {average}");
  return count;
}

Note: function parameters and return types always require type annotations. There is no inference for function signatures:

fn add(a: int, b: int) -> int {
  return a + b;
}

Shadowing

Using := with a name that already exists in the current scope creates a new binding that shadows the old one. The old value is no longer accessible:

fn main() {
  x := 10;
  print(x);     // 10

  x := "hello";  // shadows the previous x — this is a new binding
  print(x);      // hello
}

Shadowing is useful when you want to transform a value and keep the same name:

fn main() {
  input := "  hello world  ";
  input := input.trim();
  input := input.upper();
  print(input);  // HELLO WORLD
}

Each := creates a genuinely new variable. The shadowed and shadowing variables can have different types:

fn main() {
  value := 42;          // int
  value := str(value);  // string — shadows the int
  print(value);         // "42"
}

Inner scopes can also shadow outer variables without affecting them:

fn main() {
  x := "outer";
  if true {
    x := "inner";  // shadows outer x inside this block
    print(x);      // inner
  }
  print(x);        // outer — unchanged
}

Compare this to reassignment, which modifies the existing variable:

fn main() {
  x := "outer";
  if true {
    x = "modified";  // reassigns the outer x
  }
  print(x);          // modified
}

Practical Examples

Swapping Two Values

fn main() {
  a := 10;
  b := 20;

  temp := a;
  a = b;
  b = temp;

  print("a = {a}, b = {b}");  // a = 20, b = 10
}

Fibonacci Sequence

fn fibonacci(n: int) -> int {
  if n <= 1 { return n; }

  a := 0;
  b := 1;
  for i in 2..n+1 {
    temp := a + b;
    a = b;
    b = temp;
  }
  return b;
}

fn main() {
  for i in 0..10 {
    print(fibonacci(i));
  }
}

Processing a List

fn main() {
  scores := [85, 92, 78, 95, 88];

  sum := 0;
  max_score := scores[0];
  min_score := scores[0];

  for score in scores {
    sum = sum + score;
    if score > max_score {
      max_score = score;
    }
    if score < min_score {
      min_score = score;
    }
  }

  average := sum as float / scores.len as float;
  print("average: {average}");
  print("max: {max_score}");
  print("min: {min_score}");
}

Counting Occurrences

fn count_char(s: string, target: string) -> int {
  count := 0;
  parts := s.split("");
  for ch in parts {
    if ch == target {
      count = count + 1;
    }
  }
  return count;
}

fn main() {
  text := "hello world";
  l_count := count_char(text, "l");
  print("l appears {l_count} times");  // l appears 3 times
}

Summary

The rule is simple: := introduces, = updates. When in doubt, use := for new things and = for changing existing things.

Chapter 3: Types and Operators

Mog is statically typed with no implicit coercion. Every value has a known type at compile time, and the compiler will reject any operation that mixes types without an explicit conversion.

Scalar Types

Mog has four categories of scalar types: integers, floats, booleans, and strings.

Integers

The default integer type is int — a 64-bit signed integer. This is what you should use for virtually all integer work:

count := 42;              // int (inferred)
count: int = 42;          // int (explicit)
negative := -17;          // int
big := 1_000_000;         // int — underscores for readability

Integer literals support multiple bases:

decimal := 255;           // decimal
hex := 0xFF;              // hexadecimal
binary := 0b11111111;     // binary
with_sep := 1_000_000;    // underscores ignored, just for readability

All four of these hold the same value: 255 (except with_sep, which is 1,000,000).

Explicit-Width Integers

When precision matters — tensor element types, bitwise operations, or interop with hardware — Mog provides explicit-width integers:

small: i32 = 42;          // 32-bit signed
index: u32 = 0;           // 32-bit unsigned
offset: u64 = 1024;       // 64-bit unsigned

The commonly used integer types:

Mog also supports i8, i16, u8, and u16, but you’ll rarely need them outside of tensor element types. Use int unless you have a specific reason to reach for something else.

In practice, the explicit-width types exist primarily for tensors and low-level work:

// Scalar code: just use int
count := 0;
limit := 100;

// Tensor code: width matters
indices := tensor<i32>([1000]);
image := tensor<u8>([3, 224, 224]);

Floats

The default float type is float — a 64-bit (double-precision) floating point number:

pi := 3.14159;            // float (inferred)
pi: float = 3.14159;      // float (explicit)
small := 1.0e-5;          // scientific notation
half := .5;               // leading dot is allowed

For single-precision, use f32:

ratio: f32 = 0.75;

The commonly used float types:

Mog also supports f16 and bf16 (bfloat16) for ML tensor element types — see Chapter 15 for details on tensors. For scalar code, always use float.

// Scalar code: just use float
loss := 0.0;
learning_rate := 0.001;

// Tensor code: precision matters
weights := tensor<f16>([768, 768]);
gradients := tensor<f32>([768, 768]);

Booleans

The bool type has two values: true and false.

active := true;
found := false;
is_valid: bool = true;

Booleans are returned by comparison and logical operators:

fn main() -> int {
  x := 42;
  is_positive := x > 0;       // true
  is_even := (x % 2) == 0;     // true
  both := is_positive && is_even;  // true
  println(both);
  return 0;
}

There are no truthy/falsy values in Mog. Conditions must be actual bool values — you can’t use 0, "", or none as a boolean:

count := 0;
// if count { ... }       // compile error — count is int, not bool
if count == 0 { ... }     // correct

No implicit boolean conversions. This is deliberate — it catches a whole class of bugs at compile time. If you want a boolean, write a comparison.

Strings

Strings are UTF-8, immutable, and double-quoted only:

name := "Alice";
greeting := "hello, world";
empty := "";

Strings support escape sequences:

newline := "line one\nline two";
tab := "col1\tcol2";
quote := "she said \"hello\"";
backslash := "C:\\Users\\alice";

String interpolation uses f-strings — prefix the string with f and wrap expressions in {braces}:

name := "Alice";
age := 30;
greeting := f"hello {name}";              // "hello Alice"
info := f"{name} is {age} years old";     // "Alice is 30 years old"
math := f"2 + 2 = {2 + 2}";              // "2 + 2 = 4"

Concatenation uses +:

first := "hello";
second := " world";
combined := first + second;  // "hello world"

For most cases, f-string interpolation is cleaner than concatenation — see the String Concatenation section at the end of this chapter.

Type Conversions

Mog has no implicit coercion. If you want to convert between types, you must be explicit.

The as Keyword

Use as to cast between numeric types:

// int to float
x := 42;
y := x as float;          // 42.0

// float to int (truncates toward zero)
pi := 3.14;
n := pi as int;            // 3

// int to narrower int
big := 1000;
small := big as i32;

// Between float widths
precise: float = 3.14159265358979;
approx := precise as f32;

as works between any numeric types:

count := 42;
count_f := count as float;   // 42.0
count_i32 := count as i32;   // 42 (as 32-bit)
count_u64 := count as u64;   // 42 (as unsigned 64-bit)

Warning: Narrowing conversions can lose data. Casting a large int to i8 will wrap on overflow — no runtime error, just silent truncation.

String Conversions

Use str() to convert any scalar to a string:

s1 := str(42);         // "42"
s2 := str(3.14);       // "3.14"
s3 := str(true);       // "true"
s4 := str(false);      // "false"

To parse strings into numbers, use int_from_string() and parse_float(). These return Result because parsing can fail (see Chapter 10 for full coverage of error handling):

result := int_from_string("42");
match result {
  ok(n) => println(f"parsed: {n}"),
  err(msg) => println(f"failed: {msg}"),
}

pi := parse_float("3.14");
match pi {
  ok(f) => println(f"got: {f}"),
  err(msg) => println(f"bad float: {msg}"),
}

Using the ? operator for concise error propagation:

fn parse_pair(a: string, b: string) -> Result<int> {
  x := int_from_string(a)?;
  y := int_from_string(b)?;
  return ok(x + y);
}

No Implicit Conversions

Mog will not silently convert between types. Every one of these is a compile error:

x := 42;
y := 3.14;

// z := x + y;           // error: can't add int and float
z := x as float + y;     // correct: explicit cast first

// flag := x;            // error if flag is typed as bool
flag := x != 0;          // correct: explicit comparison

This strictness catches bugs early. If Mog rejects an expression, it’s telling you to think about what conversion you actually want.

Operators

Arithmetic Operators

Standard math operators work on numeric types. Both operands must be the same type:

fn main() -> int {
  a := 10;
  b := 3;

  println(a + b);    // 13   addition
  println(a - b);    // 7    subtraction
  println(a * b);    // 30   multiplication
  println(a / b);    // 3    integer division (truncates)
  println(a % b);    // 1    modulo (remainder)
  return 0;
}

With floats:

fn main() -> int {
  a := 10.0;
  b := 3.0;

  println(a + b);    // 13.0
  println(a - b);    // 7.0
  println(a * b);    // 30.0
  println(a / b);    // 3.3333333333333335
  println(a % b);    // 1.0
  return 0;
}

Integer division truncates toward zero:

fn main() -> int {
  println(7 / 2);     // 3
  println(-7 / 2);    // -3
  println(7 / -2);    // -3
  return 0;
}

Comparison Operators

Comparisons return bool. Both operands must be the same type:

fn main() -> int {
  x := 10;
  y := 20;

  println(x == y);    // false  — equal
  println(x != y);    // true   — not equal
  println(x < y);     // true   — less than
  println(x > y);     // false  — greater than
  println(x <= y);    // true   — less or equal
  println(x >= y);    // false  — greater or equal
  return 0;
}

Strings compare lexicographically:

fn main() -> int {
  println("apple" < "banana");    // true
  println("abc" == "abc");        // true
  println("Abc" == "abc");        // false — case sensitive
  return 0;
}

Logical Operators

Logical operators work on bool values only:

fn main() -> int {
  a := true;
  b := false;

  println(a && b);    // false  — logical AND
  println(a || b);    // true   — logical OR
  println(!a);        // false  — logical NOT
  println(!b);        // true
  return 0;
}

&& and || short-circuit: the right side is only evaluated if needed:

fn check(items: [int], index: int) -> bool {
  // Safe: if index is out of bounds, the second condition is never evaluated
  return (index < items.len) && (items[index] > 0);
}

Combining conditions:

fn is_valid_age(age: int) -> bool {
  return (age >= 0) && (age <= 150);
}

fn needs_review(score: int, flagged: bool) -> bool {
  return (score < 50) || flagged;
}

Bitwise Operators

Bitwise operators work on integer types:

fn main() -> int {
  a := 0b1100;    // 12
  b := 0b1010;    // 10

  println(a & b);    // 8    — bitwise AND
  println(a | b);    // 14   — bitwise OR
  println(a ^ b);    // 6    — bitwise XOR
  println(a << 2);   // 48   — left shift
  println(a >> 1);   // 6    — right shift
  return 0;
}

Common bitwise patterns:

fn main() -> int {
  // Check if a number is even
  n := 42;
  is_even := (n & 1) == 0;    // true

  // Set a flag bit
  flags := 0;
  flags = flags | 0b0100;     // set bit 2

  // Clear a flag bit
  flags = flags & 0b1011;     // clear bit 2

  // Toggle a flag bit
  flags = flags ^ 0b0010;     // toggle bit 1
  return 0;
}

String Concatenation

The + operator concatenates strings:

fn main() -> int {
  greeting := "hello" + " " + "world";
  println(greeting);  // hello world

  name := "Alice";
  message := "hi, " + name + "!";
  println(message);  // hi, Alice!
  return 0;
}

For most cases, f-string interpolation is cleaner than concatenation:

// Concatenation
message := "User " + name + " scored " + str(score) + " points";

// Interpolation — prefer this
message := f"User {name} scored {score} points";

Flat Operators (No Precedence)

Mog has no operator precedence. All binary operators are flat — the compiler does not silently reorder operations based on a precedence table. Instead, Mog enforces explicit grouping through two simple rules:

1. Associative operators can chain with themselves. The operators +, *, and/&&, or/||, &, and | are associative, so repeating the same one is unambiguous:

total := a + b + c;           // OK — same operator throughout
mask := READ | WRITE | EXEC;  // OK
all_ok := x && y && z;        // OK

2. Everything else requires parentheses.

• Different operators cannot mix. Use parentheses to show intent:

result := a + (b * c);              // OK — parens make grouping explicit
result := a + b * c;                // COMPILE ERROR — mixed + and *

check := (x > 0) && (y > 0);       // OK
check := x > 0 && y > 0;           // COMPILE ERROR — mixed > and &&

is_even := (n % 2) == 0;           // OK
is_even := n % 2 == 0;             // COMPILE ERROR — mixed % and ==

• Non-associative operators cannot chain, even with themselves:

diff := (a - b) - c;               // OK — parenthesized
diff := a - b - c;                  // COMPILE ERROR — - is non-associative

ratio := (a / b) / c;              // OK
ratio := a / b / c;                // COMPILE ERROR — / is non-associative

Non-associative operators: -, /, %, ==, !=, <, <=, >, >=, <<, >>, ^.

Why no precedence?

Precedence tables are a common source of bugs — especially when mixing arithmetic, comparison, and logical operators. Mog makes every grouping decision visible in the source code. The cost is a few extra parentheses; the benefit is that the code always means exactly what it says.

// Clear and correct
fahrenheit := ((celsius * 9) / 5) + 32;
in_range := (x >= low) && (x <= high);
masked := (flags & MASK) != 0;

Common Patterns

Clamping a Value

fn clamp(value: int, low: int, high: int) -> int {
  if value < low { return low; }
  if value > high { return high; }
  return value;
}

fn main() -> int {
  score := 150;
  clamped := clamp(score, 0, 100);
  println(clamped);  // 100
  return 0;
}

Safe Division

fn safe_divide(a: float, b: float) -> Result<float> {
  if b == 0.0 {
    return err("division by zero");
  }
  return ok(a / b);
}

fn main() -> int {
  match safe_divide(10.0, 3.0) {
    ok(result) => println(f"result: {result}"),
    err(msg) => println(f"error: {msg}"),
  }
  return 0;
}

Type-Aware Accumulation

fn average(numbers: [int]) -> float {
  sum := 0;
  for n in numbers {
    sum = sum + n;
  }
  return (sum as float) / (numbers.len as float);
}

fn main() -> int {
  scores := [85, 92, 78, 95, 88];
  avg := average(scores);
  println(f"average: {avg}");  // average: 87.6
  return 0;
}

Bitflag Permissions

fn main() -> int {
  READ := 1;       // 0b001
  WRITE := 2;      // 0b010
  EXEC := 4;       // 0b100

  // Grant read and write
  perms := READ | WRITE;

  // Check permissions
  can_read := (perms & READ) != 0;     // true
  can_exec := (perms & EXEC) != 0;     // false

  // Add execute permission
  perms = perms | EXEC;
  can_exec = (perms & EXEC) != 0;      // true

  println(f"read: {can_read}");
  println(f"exec: {can_exec}");
  return 0;
}

Building Results with Type Conversion

fn format_percentage(value: int, total: int) -> string {
  pct := (value as float / total as float) * 100.0;
  return str(round(pct)) + "%";
}

fn main() -> int {
  passed := 87;
  total := 100;
  println(format_percentage(passed, total));  // 87%
  return 0;
}

Summary

Mog’s type system is small and strict:

• Use int and float for almost everything. Reach for i32, u32, u64, or f32 only when working with tensors or hardware interop.
• No implicit coercion. Use as for numeric casts, str() for string conversion, int_from_string() and parse_float() for parsing.
• Operators require matching types. Both sides of +, *, ==, etc. must be the same type.
• Booleans are booleans. No truthy/falsy — use explicit comparisons.
• Operators are flat — no precedence. Different operators cannot mix without parentheses, and non-associative operators cannot chain. This eliminates an entire class of bugs.

Chapter 4: Control Flow

Mog’s control flow is familiar if you’ve used any C-family language: if/else, while, for, break, continue, and match. No surprises — but a few details matter, like braces being required, if working as an expression, and match handling Result and Optional patterns.

If/Else

The basic form: a condition, a block, and optional else if / else chains. Braces are always required. Parentheses around the condition are optional.

fn main() -> int {
  x := 42;

  if x > 0 {
    println("positive");
  } else if x == 0 {
    println("zero");
  } else {
    println("negative");
  }
  return 0;
}

Parentheses are allowed but not required — use them when they help readability:

fn main() -> int {
  a := 10;
  b := 20;

  // Both of these are valid
  if a > b {
    println("a wins");
  }

  if (a + b) > 25 {
    println("sum is large");
  }
  return 0;
}

Nested Conditions

Chains of else if work exactly as you’d expect. For complex classification, they read top to bottom:

fn classify_temperature(temp: int) -> string {
  if temp >= 100 {
    return "boiling";
  } else if temp >= 80 {
    return "very hot";
  } else if temp >= 60 {
    return "warm";
  } else if temp >= 40 {
    return "cool";
  } else if temp >= 20 {
    return "cold";
  } else {
    return "freezing";
  }
}

fn main() -> int {
  println(classify_temperature(95));   // very hot
  println(classify_temperature(55));   // warm
  println(classify_temperature(-10));  // freezing
  return 0;
}

Nested if blocks inside other if blocks:

fn describe_number(n: int) -> string {
  if n > 0 {
    if (n % 2) == 0 {
      return "positive even";
    } else {
      return "positive odd";
    }
  } else if n < 0 {
    if (n % 2) == 0 {
      return "negative even";
    } else {
      return "negative odd";
    }
  } else {
    return "zero";
  }
}

fn main() -> int {
  println(describe_number(7));    // positive odd
  println(describe_number(-4));   // negative even
  println(describe_number(0));    // zero
  return 0;
}

If as Expression

if can return a value. The last expression in each branch becomes the result. When used this way, else is required — the compiler needs a value for every case:

fn main() -> int {
  x := 42;

  sign := if x > 0 { 1 } else if x < 0 { -1 } else { 0 };
  println(f"sign of {x}: {sign}");  // sign of 42: 1
  return 0;
}

This works anywhere you need an expression:

fn abs(n: int) -> int {
  return if n >= 0 { n } else { 0 - n };
}

fn max(a: int, b: int) -> int {
  return if a > b { a } else { b };
}

fn min(a: int, b: int) -> int {
  return if a < b { a } else { b };
}

fn main() -> int {
  println(abs(-17));       // 17
  println(max(10, 20));    // 20
  println(min(10, 20));    // 10
  return 0;
}

If-expressions are useful for inline decisions without creating temporary variables:

fn format_count(n: int) -> string {
  label := if n == 1 { "item" } else { "items" };
  return f"{n} {label}";
}

fn main() -> int {
  println(format_count(1));   // 1 item
  println(format_count(5));   // 5 items
  println(format_count(0));   // 0 items
  return 0;
}

Combining conditions with logical operators:

fn can_vote(age: int, is_citizen: bool) -> bool {
  return (age >= 18) && is_citizen;
}

fn main() -> int {
  age := 25;
  citizen := true;

  if can_vote(age, citizen) {
    println("eligible to vote");
  } else {
    println("not eligible");
  }

  // Compound conditions
  score := 85;
  if score >= 90 {
    println("A");
  } else if (score >= 80) && (score < 90) {
    println("B");
  } else if (score >= 70) && (score < 80) {
    println("C");
  } else {
    println("below C");
  }
  return 0;
}

While Loops

while repeats a block as long as a condition is true:

fn main() -> int {
  i := 0;
  while i < 5 {
    println(f"i = {i}");
    i = i + 1;
  }
  return 0;
}

Accumulator Pattern

The most common use of while is accumulating a result when the loop condition depends on something more complex than a simple range:

fn sum_1_to_n(n: int) -> int {
  total := 0;
  i := 1;
  while i <= n {
    total = total + i;
    i = i + 1;
  }
  return total;
}

fn main() -> int {
  println(f"sum 1..100 = {sum_1_to_n(100)}");  // sum 1..100 = 5050
  return 0;
}

Factorial with a while loop:

fn factorial(n: int) -> int {
  result := 1;
  i := 2;
  while i <= n {
    result = result * i;
    i = i + 1;
  }
  return result;
}

fn main() -> int {
  println(f"5! = {factorial(5)}");    // 5! = 120
  println(f"10! = {factorial(10)}");  // 10! = 3628800
  return 0;
}

Convergence Loops

while is the right choice when you’re iterating until a condition is met, not over a known range:

fn collatz_steps(n: int) -> int {
  steps := 0;
  val := n;
  while val != 1 {
    if (val % 2) == 0 {
      val = val / 2;
    } else {
      val = (val * 3) + 1;
    }
    steps = steps + 1;
  }
  return steps;
}

fn main() -> int {
  println(f"collatz(27) = {collatz_steps(27)} steps");  // collatz(27) = 111 steps
  println(f"collatz(1) = {collatz_steps(1)} steps");    // collatz(1) = 0 steps
  return 0;
}

Integer square root by repeated approximation:

fn isqrt(n: int) -> int {
  if n <= 1 { return n; }
  guess := n / 2;
  while (guess * guess) > n {
    guess = (guess + (n / guess)) / 2;
  }
  return guess;
}

fn main() -> int {
  println(f"isqrt(100) = {isqrt(100)}");  // isqrt(100) = 10
  println(f"isqrt(50) = {isqrt(50)}");    // isqrt(50) = 7
  return 0;
}

Infinite Loops

Use while true for loops that exit with break:

fn main() -> int {
  sum := 0;
  n := 1;
  while true {
    sum = sum + n;
    if sum > 100 {
      break;
    }
    n = n + 1;
  }
  println(f"stopped at n={n}, sum={sum}");  // stopped at n=14, sum=105
  return 0;
}

For Loops

Mog has two styles of for loop: for..to with an inclusive upper bound, and for..in which iterates over ranges, arrays, and maps.

For-To (Inclusive Range)

for..to counts from a start value to an end value, inclusive of both ends:

fn main() -> int {
  for i := 1 to 5 {
    println(f"i = {i}");
  }
  // prints: 1, 2, 3, 4, 5
  return 0;
}

The counter variable is scoped to the loop body — it doesn’t exist outside:

fn main() -> int {
  for i := 1 to 10 {
    println(i);
  }
  // i is not accessible here
  return 0;
}

Summing with for..to:

fn main() -> int {
  total := 0;
  for i := 1 to 100 {
    total = total + i;
  }
  println(f"sum = {total}");  // sum = 5050
  return 0;
}

For-In Range (Exclusive End)

The .. range operator creates a half-open range — inclusive of the start, exclusive of the end:

fn main() -> int {
  for i in 0..5 {
    println(f"i = {i}");
  }
  // prints: 0, 1, 2, 3, 4
  return 0;
}

This is the natural choice for zero-based indexing:

fn main() -> int {
  names := ["Alice", "Bob", "Charlie"];
  for i in 0..names.len {
    println(f"index {i}: {names[i]}");
  }
  return 0;
}

Computing a power function:

fn power(base: int, exp: int) -> int {
  result := 1;
  for i in 0..exp {
    result = result * base;
  }
  return result;
}

fn main() -> int {
  println(f"2^10 = {power(2, 10)}");    // 2^10 = 1024
  println(f"3^5 = {power(3, 5)}");      // 3^5 = 243
  return 0;
}

When to Use Which

fn main() -> int {
  // Print multiplication table for 7 — "1 through 10" is natural
  for i := 1 to 10 {
    println(f"7 x {i} = {7 * i}");
  }

  // Sum array elements — zero-based indexing is natural
  values := [10, 20, 30, 40, 50];
  total := 0;
  for i in 0..values.len {
    total = total + values[i];
  }
  println(f"total = {total}");  // total = 150
  return 0;
}

For-In Array

Iterating directly over array elements — no index needed:

fn main() -> int {
  fruits := ["apple", "banana", "cherry", "date"];
  for fruit in fruits {
    println(f"I like {fruit}");
  }
  return 0;
}

Summing, filtering, searching:

fn sum(numbers: [int]) -> int {
  total := 0;
  for n in numbers {
    total = total + n;
  }
  return total;
}

fn contains(items: [string], target: string) -> bool {
  for item in items {
    if item == target {
      return true;
    }
  }
  return false;
}

fn main() -> int {
  scores := [85, 92, 78, 95, 88];
  println(f"sum = {sum(scores)}");  // sum = 438

  colors := ["red", "green", "blue"];
  println(contains(colors, "green"));  // true
  println(contains(colors, "pink"));   // false
  return 0;
}

Collecting results into a new array:

fn filter_even(numbers: [int]) -> [int] {
  result: [int] = [];
  for n in numbers {
    if n % 2 == 0 {
      result.push(n);
    }
  }
  return result;
}

fn main() -> int {
  nums := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
  evens := filter_even(nums);
  for n in evens {
    print_string(f"{n} ");
  }
  println("");  // 2 4 6 8 10
  return 0;
}

For-In with Index

When you need both the index and the value, add a second variable before the comma:

fn main() -> int {
  names := ["Alice", "Bob", "Charlie", "Diana"];
  for i, name in names {
    println(f"{i}: {name}");
  }
  // 0: Alice
  // 1: Bob
  // 2: Charlie
  // 3: Diana
  return 0;
}

This is cleaner than manually tracking an index counter:

fn find_index(items: [string], target: string) -> int {
  for i, item in items {
    if item == target {
      return i;
    }
  }
  return -1;
}

fn main() -> int {
  colors := ["red", "green", "blue", "yellow"];
  idx := find_index(colors, "blue");
  println(f"blue is at index {idx}");  // blue is at index 2

  idx2 := find_index(colors, "purple");
  println(f"purple is at index {idx2}");  // purple is at index -1
  return 0;
}

Printing a numbered list:

fn main() -> int {
  tasks := ["write code", "run tests", "fix bugs", "deploy"];
  for i, task in tasks {
    println(f"  {i + 1}. {task}");
  }
  //   1. write code
  //   2. run tests
  //   3. fix bugs
  //   4. deploy
  return 0;
}

Finding the maximum element and its position:

fn max_with_index(numbers: [int]) -> [int] {
  best := numbers[0];
  best_idx := 0;
  for i, n in numbers {
    if n > best {
      best = n;
      best_idx = i;
    }
  }
  return [best_idx, best];
}

fn main() -> int {
  scores := [72, 95, 88, 91, 67];
  result := max_with_index(scores);
  println(f"max value {result[1]} at index {result[0]}");  // max value 95 at index 1
  return 0;
}

For-In Map

Maps iterate as key-value pairs:

fn main() -> int {
  scores := {"alice": 95, "bob": 87, "charlie": 92};

  for name, score in scores {
    println(f"{name} scored {score}");
  }
  return 0;
}

Building a report from a map:

fn main() -> int {
  inventory := {"apples": 12, "bananas": 5, "oranges": 8, "grapes": 0};

  total := 0;
  out_of_stock := 0;

  for item, count in inventory {
    total = total + count;
    if count == 0 {
      println(f"  WARNING: {item} is out of stock");
      out_of_stock = out_of_stock + 1;
    }
  }

  println(f"total items: {total}");
  println(f"out of stock: {out_of_stock}");
  return 0;
}

Transforming map data:

fn main() -> int {
  temps_celsius := {"London": 15, "Tokyo": 28, "New York": 22, "Sydney": 19};

  for city, celsius in temps_celsius {
    fahrenheit := ((celsius * 9) / 5) + 32;
    println(f"{city}: {celsius}C = {fahrenheit}F");
  }
  return 0;
}

Counting occurrences with a map:

fn main() -> int {
  words := ["the", "cat", "sat", "on", "the", "mat", "the", "cat"];
  counts: {string: int} = {};

  for word in words {
    if counts[word] is some(n) {
      counts[word] = n + 1;
    } else {
      counts[word] = 1;
    }
  }

  for word, count in counts {
    println(f"{word}: {count}");
  }
  return 0;
}

Break and Continue

break exits the innermost enclosing loop immediately. continue skips the rest of the current iteration and moves to the next one.

Break

fn main() -> int {
  // Find the first multiple of 7 greater than 50
  for i in 1..100 {
    if (i * 7) > 50 {
      println(f"found: {i} (7 * {i} = {i * 7})");
      break;
    }
  }
  // found: 8 (7 * 8 = 56)
  return 0;
}

Continue

fn main() -> int {
  // Print only odd numbers from 0 to 19
  for i in 0..20 {
    if (i % 2) == 0 {
      continue;
    }
    print_string(f"{i} ");
  }
  println("");  // 1 3 5 7 9 11 13 15 17 19
  return 0;
}

Combined Break and Continue

fn main() -> int {
  // Sum numbers from 1 to 100, skipping multiples of 3, stopping if sum exceeds 500
  total := 0;
  stopped_at := 0;
  for i in 1..101 {
    if (i % 3) == 0 {
      continue;
    }
    total = total + i;
    if total > 500 {
      stopped_at = i;
      break;
    }
  }
  println(f"stopped at {stopped_at}, total = {total}");
  return 0;
}