Run a Mac Coding Class Using Remote Desktops

Students who do not own a Mac still need to run Xcode, build Swift packages, and test on macOS. Renting cloud Macs and handing each student an isolated login solves the hardware gap without asking anyone to buy anything. This guide covers the account setup, credential handoff, and teardown for a one-day workshop or short course.

Direct recommendation: for a Swift or iOS workshop, request Figment M-series Macs from $95/month each and share 3–4 students per Mac; for budget classes doing shell, scripting, or Intel-only toolchain work, the $29 virtual Intel macOS plan (2 vCPU, 8 GiB RAM, 80 GiB disk, browser-console access, no Apple silicon, no GPU) is usable per student. Billing is monthly, so a one-day class pays the monthly rate. Physical Mac plans are request-based; the exact chip, RAM, and disk are confirmed in the quote. Start a configuration request when you know your headcount.

Single-host vs per-student: cost worksheet for 12 students

Before scripting anything, decide between packing many student accounts onto one or two Macs (shared compute) and giving each student their own environment (full isolation). The worksheet uses Figment's listed entry prices; exact physical specs are set in the quote.

The $29 virtual Intel macOS runs a real macOS desktop in your browser; Intel Xcode 26 or earlier can cross-compile arm64 iOS and universal macOS binaries there, per Apple's porting guide. Executing ARM-only binaries, Xcode 27, and visionOS tooling require Apple silicon. If your exercises run or debug on-device arm64, choose an M-series plan.

A note on concurrent sessions: macOS supports multiple users logged in at once with Fast User Switching, each with their own Screen Sharing view. With 12 simultaneous Xcode builds on one machine, shared CPU and RAM — not Screen Sharing — are the limit. 3–4 students per M-series Mac is a comfortable ratio for active development; one Mac for 12 only works when sessions are sequential or exercises are light.

Bulk account creation script

This script creates N standard student accounts with random passwords, adds each to the Screen Sharing access group, writes a credential sheet with locked-down permissions, and schedules automated deletion. Run it as an admin user on each rental Mac. Account types come from Apple's users, guests, and groups guide. This is an unexecuted example: test it on your rental with a small count before running for the full class.

#!/usr/bin/env bash
# student-setup.sh — bulk student accounts with scheduled cleanup
# Usage: sudo bash student-setup.sh <count> <cleanup-time YYYYMMDDHHmm>
# Example: sudo bash student-setup.sh 4 202611101800
# Requires: macOS admin session; atd enabled

set -euo pipefail

COUNT="${1:?Provide student count}"
CLEANUP_TIME="${2:?Provide cleanup time as YYYYMMDDHHmm}"

# Restrictive perms BEFORE any secret is written
umask 077

STAMP="$(date +%Y%m%d%H%M%S)-$$"
CRED_FILE="/var/root/student-credentials-${STAMP}.txt"
CLEANUP_SCRIPT="/var/root/student-cleanup-${STAMP}.sh"

printf '# Student credentials — distribute through a secure channel, then delete.\n\n' > "$CRED_FILE"

cat > "$CLEANUP_SCRIPT" <<'HEADER'
#!/bin/bash
set -e
HEADER

for i in $(seq 1 "$COUNT"); do
    USER="student$(printf '%02d' "$i")"
    PASS=$(openssl rand -hex 8)   # 16 hex chars

    # Create a standard (non-admin) user
    sysadminctl -addUser "$USER" -fullName "Student $i" -password "$PASS" 2>/dev/null \
        || echo "WARN: $USER may already exist, skipping create"

    # Grant Screen Sharing access via the local access group
    dseditgroup -o edit -n /Local/Default \
        -a "$USER" -t user com.apple.access_screensharing 2>/dev/null || true

    printf 'Username: %-20s  Password: %s\n' "$USER" "$PASS" >> "$CRED_FILE"

    cat >> "$CLEANUP_SCRIPT" <<CLEANUP
/usr/sbin/sysadminctl -deleteUser ${USER} 2>/dev/null || true
/bin/rm -rf /Users/${USER}
CLEANUP
done

chmod 700 "$CLEANUP_SCRIPT"

# Schedule teardown with atd. Enable atd first if needed:
#   sudo launchctl load -w /System/Library/LaunchDaemons/com.apple.atrun.plist
echo "bash $CLEANUP_SCRIPT" | at -t "$CLEANUP_TIME" \
    || echo "NOTE: atd job not scheduled — run manually: sudo bash $CLEANUP_SCRIPT"

echo ""
echo "=== $COUNT student accounts created ==="
echo "Credentials file : $CRED_FILE  (mode 600, root-owned)"
echo "Cleanup script   : $CLEANUP_SCRIPT"
echo "Cleanup scheduled: $CLEANUP_TIME"

After you hand out credentials, remove the file:

# Plain rm is enough on APFS; -P was an HFS+ overwrite hint and does not
# reliably scrub APFS blocks.
sudo rm -f "$CRED_FILE"

Enabling Screen Sharing for each account

The script adds every student to the com.apple.access_screensharing group. Confirm the Sharing pane matches:

1. Open System Settings › General › Sharing › Screen Sharing and turn it on.
2. Set Allow access for to Only these users.
3. Confirm student01…studentN appear in the list.

Share the Mac's reachable address (from your Figment dashboard) with each student alongside their username and password. The connection URL is vnc://<address>; students connect with macOS Screen Sharing, RealVNC Viewer, or Screens, each landing in their own desktop session.

If you also want a single viewer-level password on top of per-account logins, set it under Screen Sharing › Computer Settings › "VNC viewers may control screen with password". Use it only when every student needs the same entry phrase.

Distributing credentials securely

A plaintext list of 12 passwords sent to a shared channel is a liability. Options by increasing security:

• Password-manager share links — 1Password, Bitwarden, or similar, one view-once link per student.
• Ephemeral messages — Signal disappearing messages for one-to-one handoff.
• In-person QR codes — generate one per row and reveal individually at the student's seat.
• LMS private assignments — a per-student encrypted attachment if the platform supports it.

Avoid bulk email, shared docs, and open chat channels that persist past the class.

Monitoring the class with Apple Remote Desktop

Apple Remote Desktop observes several student sessions in one window, sends text messages to one or all screens, and can lock screens in a group — useful for "pens down, look at me" moments. For a lighter view from the Mac's own Terminal, who and w list who is logged in and active.

Post-class cleanup

If the atd job fires at the scheduled minute, accounts are removed automatically. For an immediate teardown:

sudo bash /var/root/student-cleanup-<stamp>.sh

Verify nothing remains:

ls /Users/
dscl . -list /Users | grep '^student' || echo "no student accounts left"

If you reuse the rental for another cohort, re-run student-setup.sh with the new count and new cleanup time; each run generates fresh usernames, passwords, and a fresh scheduled job.

Which Figment plan to request

For a Swift or iOS workshop, request M-series Macs from $95/month each. M-series is required for executing ARM-only binaries, Xcode 27, and visionOS. For four students sharing one Mac, one rental is a reasonable starting point; confirm the chip, RAM, and disk for your specific exercises when you submit the quote. For 8–12 students in simultaneous Xcode builds, request two or three Macs and spread accounts across them.

For a pure shell, scripting, or Intel cross-compile class, the $29 virtual Intel macOS plan per student is the cheapest full-isolation option on this list. One-day classes still pay the monthly rate — there is no daily billing on these plans — so align your rental window with the course calendar. Request a configuration or start the signup once you have a headcount.

Related: Remote Mac setup for video editing · Mac remote desktop security hardening · Run GitHub Actions self-hosted runners on a Mac