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 — they are authoritative correction layers for pretrained knowledge.
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 for benchmarks — mojo (JIT) includes ~1.4s compilation overhead per run. There is no mojo -e flag; always write to a file.
Critical Syntax Corrections (v26.2)
Pretrained models generate outdated Mojo. These corrections are current as of Mojo 26.2:
| Wrong (pretrained) | Correct (26.2) | Notes |
|---|---|---|
fn main(): | def main(): | fn is deprecated; def is the only function keyword |
let x = 5 | var x = 5 | let removed; var for all bindings |
inout self | mut self / out self | mut for mutation, out for __init__ |
@parameter for | comptime for | Compile-time loops |
List[Int](1, 2, 3) | [1, 2, 3] | Collection literals |
from math import sqrt | from std.math import sqrt | std. prefix required for all stdlib modules |
from time import X | from std.time import X | Includes perf_counter_ns, sleep, etc. |
__str__ / Stringable | write_to / Writable | String conversion protocol |
String(self.x) for int→str | String(self.x) | This one is actually correct, but str() is not |
list.append(item) | list.append(item^) | Non-copyable types require ^ transfer operator |
var x: Int = perf_counter_ns() | var x: UInt = perf_counter_ns() | Time functions return UInt, not Int |
Implicit copy of List[T] | .copy() or ^ transfer | List is not implicitly copyable; use explicit copy or move |
Companion Skills (Modular Official)
These skills from github.com/modular/skills provide deep syntax correction layers. If they are installed in the user's skill set, read them before writing Mojo code:
- 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.