Mojo Development in Claude.ai Containers

Mojo is a systems programming language from Modular that combines Python-like syntax with C-level performance. This skill handles container setup and execution. For language syntax and semantics, defer to Modular's official skills at

github.com/modular/skills

Installation

Install once per session (~20s via uv, ~500MB). Skip if already installed.

if mojo --version 2>/dev/null; then
  echo "Mojo already installed"
else
  # Compiler binary without ML extras (~350MB saved)
  uv pip install --system --break-system-packages modular --no-deps 2>&1 | tail -5
  # Entry points + base deps (numpy, pyyaml, rich)
  uv pip install --system --break-system-packages mojo max 2>&1 | tail -5
  mojo --version
fi

Verify:

echo 'def main(): print("Mojo ready")' > /tmp/_verify.mojo && mojo /tmp/_verify.mojo

Running Mojo Code

Quick tests (write to temp file):

cat > /tmp/test.mojo << 'EOF'
def main():
    print("hello")
EOF
mojo /tmp/test.mojo

File execution (JIT compile + run, ~1.4s overhead):

cat > /home/claude/example.mojo << 'EOF'
def main():
    print("Hello from Mojo")
EOF
mojo /home/claude/example.mojo

Build binary (for benchmarking — ~6s cold compile, but binary runs at native speed):

mojo build /home/claude/example.mojo -o /home/claude/example
/home/claude/example

Use

mojo build

mojo

mojo -e

Critical Syntax Corrections (v26.2)

Pretrained models generate outdated Mojo. These corrections are current as of Mojo 26.2:

fn main():

def main():

fn

def

let x = 5

var x = 5

let

var

inout self

mut self

out self

mut

out

__init__

@parameter for

comptime for

List[Int](1, 2, 3)

[1, 2, 3]

from math import sqrt

from std.math import sqrt

std.

from time import X

from std.time import X

perf_counter_ns

sleep

__str__

Stringable

write_to

Writable

String(self.x)

String(self.x)

str()

list.append(item)

list.append(item^)

^

var x: Int = perf_counter_ns()

var x: UInt = perf_counter_ns()

UInt

Int

List[T]

.copy()

^

List

Companion Skills (Modular Official)

These skills from

github.com/modular/skills

• mojo-syntax — Comprehensive syntax corrections, type system, ownership model. Always use when writing any Mojo code.
• mojo-python-interop — Calling Python from Mojo, type conversion, extension modules. Use when mixing Mojo and Python.
• mojo-gpu-fundamentals — GPU programming (no CUDA syntax — Mojo has its own model). Reference only in Claude.ai containers (no GPU available).
• new-modular-project — Project scaffolding with Pixi or uv. Use when starting a new Mojo/MAX project locally.

If companion skills are not installed, the correction table above covers the most common pretrained errors. For deeper work, fetch the skill content directly:

curl -sL -H "Authorization: token $GH_TOKEN" \
  -H "Accept: application/vnd.github.v3.raw" \
  "https://api.github.com/repos/modular/skills/contents/mojo-syntax/SKILL.md?ref=main"

Container Constraints

• No GPU: Claude.ai containers are CPU-only. GPU skills are reference material for generating code the user will run locally.
• Session-ephemeral: Mojo installation doesn't persist across conversations. Reinstall each session.
• Build artifacts: Store in

  /home/claude/

  . Copy final outputs to

  /mnt/user-data/outputs/

  .
• Timeout: Long compilations or benchmarks may hit the ~200s bash timeout. Break work into smaller units.

Benchmarking Pattern

Compare Mojo vs Python on the same algorithm:

# Python baseline
python3 -c "
import time
def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a
# Warmup + timed runs
fib(90)
times = []
for _ in range(100):
    start = time.perf_counter()
    fib(90)
    times.append((time.perf_counter() - start) * 1e6)
import statistics
print(f'Python: median={statistics.median(times):.1f} µs, min={min(times):.1f} µs')
"

# Mojo version
cat > /home/claude/fib.mojo << 'EOF'
from std.time import perf_counter_ns

def fib(n: Int) -> Int:
    var a = 0
    var b = 1
    for _ in range(n):
        var tmp = a
        a = b
        b = tmp + b
    return a

def main():
    # Warmup
    _ = fib(90)
    
    # Timed runs
    var total_ns: UInt = 0
    var min_ns: UInt = 999999999
    for _ in range(100):
        var start = perf_counter_ns()
        _ = fib(90)
        var elapsed = perf_counter_ns() - start
        total_ns += elapsed
        if elapsed < min_ns:
            min_ns = elapsed
    print("Mojo: mean =", total_ns // 100, "ns, min =", min_ns, "ns")
EOF
mojo build /home/claude/fib.mojo -o /home/claude/fib
/home/claude/fib

Expected: Mojo is ~50x faster than CPython on tight numeric loops. SIMD and parallelism widen the gap further but require mojo-syntax and mojo-gpu-fundamentals skills for correct usage.