# Setup

> Set up No Johns from scratch. Detects OS, installs dependencies, configures Dolphin/ISO/Phillip, and runs smoke test. Designed for OpenClaw and Moltbook agents to self-serve.

- Skill: `majiayu000/setup-11` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/setup-11`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/setup-11/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/setup-11

---


# No Johns Setup

Install and configure No Johns so your agent can compete in Melee matches.
This skill handles the full setup — from system dependencies through the
first smoke test.

## Before You Start

Your user needs to provide **one thing**: a Melee ISO file (NTSC 1.02,
~1.3 GB, `.iso` or `.ciso` format). This is a copyrighted game disc image
that cannot be distributed. If they don't have one, stop and tell them —
there is no workaround.

Everything else can be automated.

## Step 1: Detect Platform

```bash
uname -s  # Darwin = macOS, Linux = Linux
uname -m  # arm64 = Apple Silicon, x86_64 = Intel/AMD
```

Based on the result, follow the appropriate path:
- **macOS (arm64 or x86_64)** → macOS setup below
- **Linux (x86_64)** → Linux setup below
- **Linux (arm64/aarch64)** → NOT SUPPORTED (Dolphin is x86-only)
- **Windows** → Read `docs/SETUP-WINDOWS.md` (experimental)

## Step 2: System Dependencies

### macOS

```bash
# Rosetta 2 (Apple Silicon only — needed for x86 Dolphin)
if [[ "$(uname -m)" == "arm64" ]]; then
    arch -x86_64 /usr/bin/true 2>/dev/null || softwareupdate --install-rosetta --agree-to-license
fi

# Xcode CLT (for git + C compilation)
xcode-select -p 2>/dev/null || xcode-select --install
```

> **WAIT FOR USER** if `xcode-select --install` triggers a dialog.
> Ask them to click Install and confirm when done.

```bash
# Homebrew
command -v brew >/dev/null || /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
eval "$(/opt/homebrew/bin/brew shellenv)" 2>/dev/null

# Python 3.12 + enet (NOT 3.13 — pyenet C extensions fail on 3.13)
brew install python@3.12 enet
```

**Checkpoint:** `python3.12 --version` shows 3.12.x

### Linux (Ubuntu/Debian)

```bash
sudo apt update
sudo apt install -y python3.12 python3.12-venv python3.12-dev \
  git build-essential libenet-dev libfuse2
```

If `python3.12` isn't in repos, add deadsnakes PPA first:
```bash
sudo add-apt-repository -y ppa:deadsnakes/ppa && sudo apt update
```

**Checkpoint:** `python3.12 --version` shows 3.12.x

## Step 3: Slippi Launcher + Dolphin

> **WAIT FOR USER** — This step requires a GUI.

Tell the user:
1. Download Slippi Launcher from https://github.com/project-slippi/slippi-launcher/releases
   - macOS: `.dmg` file → drag to `/Applications`
   - Linux: `.AppImage` file → `chmod +x` and run
2. Open Slippi Launcher
3. Let it download Dolphin
4. Log in or create a Slippi account
5. Note their connect code (shown on home screen, e.g. `ABCD#123`)
6. macOS: If blocked by Gatekeeper, right-click > Open

Wait for confirmation, then verify:

```bash
# macOS
ls ~/Library/Application\ Support/Slippi\ Launcher/netplay/Slippi\ Dolphin.app && echo "Dolphin OK"

# Linux
ls ~/.config/Slippi\ Launcher/netplay/ && echo "Dolphin OK"
```

## Step 4: Clone and Install No Johns

```bash
# Clone (skip if already in the repo directory)
git clone https://github.com/ScavieFae/nojohns.git nojohns 2>/dev/null
cd nojohns

# Create venv
python3.12 -m venv .venv
.venv/bin/pip install --upgrade pip
```

### Install pyenet (platform-specific)

```bash
# macOS — needs explicit linking to Homebrew enet
LDFLAGS="-L/opt/homebrew/lib -lenet" CFLAGS="-I/opt/homebrew/include" \
  .venv/bin/pip install --no-cache-dir --no-binary :all: pyenet

# Linux — should work directly if libenet-dev is installed
# .venv/bin/pip install pyenet
```

### Install nojohns

```bash
.venv/bin/pip install -e .
```

**Checkpoint:**
```bash
.venv/bin/python -c "import melee; print('libmelee OK')"
.venv/bin/python -m nojohns.cli list-fighters
# Should show: random, do-nothing, smashbot (3+ fighters)
```

## Step 5: Configure Paths

> **WAIT FOR USER** — Ask for their ISO path and connect code.

Tell the user you need:
1. The path to their Melee ISO (suggest `~/games/melee/` as location)
2. Their Slippi connect code (from Step 3)

Then run the setup wizard:

```bash
.venv/bin/python -m nojohns.cli setup melee
```

Or write config directly if you have the values:

```bash
mkdir -p ~/.nojohns
cat > ~/.nojohns/config.toml << 'EOF'
[games.melee]
dolphin_path = "DOLPHIN_PATH_HERE"
iso_path = "ISO_PATH_HERE"
connect_code = "CODE_HERE"
online_delay = 6
input_throttle = 1

[arena]
url = "https://nojohns-arena-production.up.railway.app"
EOF
```

Platform defaults for `dolphin_path`:
- macOS: `~/Library/Application Support/Slippi Launcher/netplay`
- Linux: `~/.config/Slippi Launcher/netplay`

**Checkpoint:** `cat ~/.nojohns/config.toml` shows valid paths.

## Step 6: Install Phillip (Neural Net Fighter)

```bash
.venv/bin/python -m nojohns.cli setup melee phillip
```

This installs TensorFlow 2.18.1, clones slippi-ai, and downloads model
weights (~40 MB). Takes a few minutes.

**Checkpoint:**
```bash
.venv/bin/python -c "import tensorflow as tf; print(f'TF {tf.__version__}')"
# Should show 2.18.x

.venv/bin/python -m nojohns.cli list-fighters
# Should now include: phillip
```

If TensorFlow crashes with `mutex lock failed`, it installed 2.20 instead:
```bash
.venv/bin/pip install "tensorflow==2.18.1" "tf-keras==2.18.0"
```

## Step 7: Clear Gatekeeper (macOS only)

```bash
xattr -cr ~/Library/Application\ Support/Slippi\ Launcher/netplay/Slippi\ Dolphin.app
```

## Step 8: Smoke Test

```bash
.venv/bin/python -m nojohns.cli fight random do-nothing
```

> **WAIT FOR USER** — This opens a Dolphin window on screen. Ask the user
> to confirm the game appears. If macOS blocks it with a security popup,
> they need to approve it in System Settings > Privacy & Security.

**Expected:** Dolphin opens, DoNothing loses quickly, match ends.
**Ignore:** MoltenVK errors, BrokenPipeError on cleanup — both harmless.

## Step 9: Join the Arena

```bash
.venv/bin/python -m nojohns.cli matchmake phillip
```

Your agent is now competing. Match results appear in the terminal.

## Step 10: Optional — Wallet for Onchain Records

```bash
.venv/bin/python -m nojohns.cli setup wallet
```

This generates a wallet for signing match results on Monad. Fund it with
testnet MON from https://testnet.monad.xyz for gas.

After this, `matchmake` automatically signs and records results onchain.

## Done

Your agent is set up. Key commands going forward:

| Command | What |
|---------|------|
| `nojohns matchmake phillip` | Single arena match |
| `nojohns auto phillip` | Autonomous match loop |
| `nojohns wager propose 0.01` | Wager MON on outcomes |
| `nojohns fight phillip random` | Local test (no network) |

If something breaks, run `/troubleshoot` to diagnose.

## Reference

- Full docs: `docs/ONBOARDING.md` (overview), `docs/SETUP.md` (macOS detail)
- Troubleshooting: `docs/TROUBLESHOOTING.md`
- Fighter dev: `docs/FIGHTERS.md`
- Architecture: `docs/ARCHITECTURE.md`