Windows 11 auf dem iPhone: WindowsiOS Schritt für Schritt

Windows 11 auf dem iPhone klingt nach einem Witz, aber es bootet. WindowsiOS ist ein Open-Source-Projekt von Ammaar Reshi, das die echte ARM64-Version von Windows 11 Pro in einer iPhone-App laufen lässt. Ich habe es am 12. November 2026 auf meinem eigenen iPhone Duo eingerichtet. In diesem Guide gehst du alle Schritte durch: den Build auf dem Mac, Windows direkt von Microsoft, die Installation auf dem iPhone und den Start. Dazu bekommst du jedes Problem, über das ich gestolpert bin, mit Fix.

Kurz erklärt

Was es ist: eine iPhone-App, die sich wie ein kleiner ARM-PC verhält. Darin bootet Windows 11, vom Firmware-Logo bis zum Desktop.
Wie es funktioniert: Apple lässt normale Apps nicht an die eingebaute Virtualisierung des iPhones. Deshalb nutzt WindowsiOS einen JIT („just in time“-Übersetzer): Er übersetzt den Prozessor-Code von Windows live in Code, den das iPhone ausführen darf.
Warum jeder Start einen Debugger braucht: iOS erlaubt diesen JIT nur, solange ein Debugger verbunden ist (ein Entwickler-Tool, das sich an eine laufende App hängt). Entweder hängt ihn ein Script auf deinem Mac über das Kabel an, oder die App StikDebug erledigt das direkt auf dem iPhone. Beides lief auf meinem iPhone Duo. Der Debugger bleibt nur für den Start, dann löst er sich wieder.
Sideloading: Du installierst die App selbst, ohne App Store, signiert mit deinem Apple-Developer-Account.
Für wen: Du hast einen Mac mit Apple-Chip, ein iPhone Duo und einen bezahlten Apple-Developer-Account, und du kopierst Befehle ins Terminal, ohne nervös zu werden.

Bevor du loslegst: die ehrliche Version

Das brauchst du

Einen Mac mit Apple-Chip (M1 oder neuer). Ich hatte einen Mac mini M4 mit 16 GB RAM, macOS 27.2 und Xcode 27.2.
Etwa 45 GB verfügbaren Speicherplatz auf dem Mac während des Builds, plus den Platz für Xcode selbst.
Ein iPhone Duo. Der Entwickler hat WindowsiOS auf dem iPhone Duo (iPhone19,4, A20 Pro) getestet, und ich habe es nur auf meinem iPhone Duo mit iOS 27.2 getestet. Andere iPhones habe ich nicht ausprobiert, also verlass dich nicht darauf.
Platz auf dem iPhone: Die Windows-Datei ist 14,2 GB groß. Beim ersten Start entpackt die App sie in ein Disk-Image mit bis zu 32 GB und löscht danach die gepackte Datei. Plan für diesen Moment also rund 46 GB ein.
Einen bezahlten Apple-Developer-Account. Den habe ich genutzt. Eine normale Apple-ID ohne bezahlte Mitgliedschaft habe ich nicht getestet, dazu kann ich dir nichts sagen.
Ein USB-C-Kabel zwischen Mac und iPhone.

So lange dauert es

Der Build selbst hat auf meinem Mac mini etwa 45 Minuten gedauert. Dazu kommen die Downloads: Xcode, rund 4,5 GB für Windows und rund 836 MB für den Netzwerk-Treiber.
Das Kopieren aufs iPhone lief bei mir mit etwa 36 MB/s, also rund 7 Minuten.
Mit dem Mac-Script kostet jeder Windows-Start etwa eine Minute schwarzen Bildschirm, während der Debugger arbeitet. Den Start mit StikDebug habe ich nicht gestoppt.

Was (noch) nicht geht oder nicht getestet ist

Jeder Start braucht einen Debugger: entweder das Launch-Script am Mac mit Kabel (Schritt 15) oder StikDebug auf dem iPhone (Abschnitt „Windows ohne Mac starten“). Beides habe ich auf meinem iPhone Duo geprüft. Schließt du die App, startest du sie wieder über einen der beiden Wege. StikDebug braucht einmalig ein Setup mit dem Mac.
Das Bild startet mit 800 × 600. Mit einem Befehl in Windows bekommst du 1024 × 768, mehr kann diese Firmware nicht (Schritt 16).
Windows sieht 4,5 GB RAM, eine 32-GB-Disk und keine Grafikkarte.
Internet in Windows läuft auf meinem iPhone Duo (Edge hat Websites geladen, getestet am 12. November 2026), aber nur mit einem kleinen Patch von mir, der den Netzwerk-Treiber hinzufügt. In den Original-Scripts fehlt er. Wie du ihn ergänzt, zeigt dir Schritt 6.
Der Schritt, der vorinstallierte Apps entfernt, ist bei mir fehlgeschlagen. Edge und der Store bleiben also drauf. Windows läuft trotzdem.
Die Scripts tragen keinen Product Key ein, Windows ist also nicht aktiviert. Für die dauerhafte Nutzung brauchst du eine eigene Windows-11-Pro-Lizenz.
Ich habe nichts gebenchmarkt, deshalb gibt es hier keine Speed-Zahlen.
WindowsiOS ist ein junges, experimentelles Projekt (beim Build hatte es eine Handvoll Commits). Rechne mit etwas Gefummel.
Windows läuft auf Englisch (US), weil die Setup-Scripts dafür geschrieben sind.

Schritt 1: Den Mac vorbereiten

Alles läuft im Terminal (Programme > Dienstprogramme > Terminal). Kopier jeden Block, füg ihn ein, drück Enter und warte, bis er fertig ist, bevor du den nächsten startest.

Installier Xcode (Apples Entwickler-App) aus dem Mac App Store und öffne es einmal. Lass es seine zusätzlichen Komponenten installieren und achte darauf, dass die iOS-Plattform installiert ist (Xcode > Einstellungen > Komponenten).
Stell die Kommandozeilen-Tools auf das volle Xcode um. Sonst bekommst du später den Fehler xcodebuild requires Xcode. Der Befehl fragt nach deinem Mac-Passwort:

sudo xcode-select -s /Applications/Xcode.app/Contents/Developer
sudo xcodebuild -license accept

Installier Homebrew, den Paketmanager, über den die meisten Mac-Entwickler ihre Kommandozeilen-Tools holen. Der Befehl stammt von brew.sh. Am Ende zeigt Homebrew unter „Next steps“ zwei oder drei Zeilen an. Führ die auch aus, damit der Befehl brew funktioniert:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Installier die Build-Tools. python liefert das python3, das die Scripts aufrufen, qemu brauchst du nur für seine UEFI-Firmware-Datei, wimlib liest den Windows-Download, llvm und lld bauen ein kleines Windows-Tool, und libimobiledevice plus ideviceinstaller sprechen per USB mit dem iPhone:

brew install python meson ninja pkgconf wimlib libslirp glib qemu llvm lld xcodegen libimobiledevice ideviceinstaller

Check: xcodebuild -version zeigt Xcode 27, und brew --version gibt eine Versionsnummer aus.

Schritt 2: Den Code holen

Damit landet das Projekt im Ordner WindowsiOS in deinem Benutzerordner. Der zweite Clone ist Husk, ein Projekt, auf dem WindowsiOS aufbaut. Das Build-Script braucht daraus einen Patch.

git clone https://github.com/ammaarreshi/WindowsiOS.git ~/WindowsiOS
cd ~/WindowsiOS
git checkout 0a46e3f
mkdir -p work/refs
git clone https://github.com/Leviidev/Husk.git work/refs/Husk
git -C work/refs/Husk checkout 29abb51

git checkout 0a46e3f pinnt genau die Version, die ich gebaut habe. Neuere Versionen können die Scripts ändern, dann passen die Schritte unten eventuell nicht mehr. Git meldet dabei etwas von „detached HEAD“. Das ist so gewollt. Die letzte Zeile pinnt die Husk-Version, die ich genutzt habe.

Check: git log --oneline -1 beginnt mit 0a46e3f, und ls work/refs/Husk/patches listet libslirp-v4.9.1.patch.

Schritt 3: Engine und iOS-Library bauen

Der erste Befehl kompiliert drei Libraries (libffi, glib, libslirp) fürs iPhone. Der zweite baut den Emulator für den Mac, den Image-Packer und die iPhone-Library und lässt die eingebauten Tests laufen.

cd ~/WindowsiOS
HUSK_REF="$PWD/work/refs/Husk" ./scripts/build_ios_deps.sh
make -j8 all ios-lib test-core
ls -l build/winvm build/hvsparse build/ios/libwinvm.a

Check: Der letzte Befehl listet alle drei Dateien auf. Schlägt ein Test fehl, bricht make mit einem Fehler ab.

Schritt 4: Das Windows-Hilfstool bauen

Das Optimizer-Script in Schritt 8 braucht ein winziges Windows-Programm namens opt_hive_arm64.exe. Der Quellcode liegt im Repo, ein Build-Script dafür aber nicht. Das hier ist das, das ich benutzt habe:

cd ~/WindowsiOS
mkdir -p work/guest_tools/obj
cat > work/guest_tools/kernel32.def <<'EOF'
LIBRARY kernel32.dll
EXPORTS
  GetCurrentProcess
  GetStdHandle
  WriteFile
  ExitProcess
  GetCommandLineW
  GetModuleFileNameW
  GetTempPathW
  GetFileAttributesW
  WideCharToMultiByte
  MultiByteToWideChar
  CreateFileW
  CloseHandle
  CreateProcessW
  CreateThread
  WaitForMultipleObjects
  Sleep
  GetTickCount64
  GetProcessHeap
  HeapAlloc
  HeapFree
EOF
cat > work/guest_tools/advapi32.def <<'EOF'
LIBRARY advapi32.dll
EXPORTS
  OpenProcessToken
  LookupPrivilegeValueW
  AdjustTokenPrivileges
  RegOpenKeyExW
  RegCreateKeyExW
  RegSetValueExW
  RegCloseKey
EOF
/opt/homebrew/opt/llvm/bin/llvm-dlltool -m arm64 -d work/guest_tools/kernel32.def -l work/guest_tools/obj/kernel32.lib
/opt/homebrew/opt/llvm/bin/llvm-dlltool -m arm64 -d work/guest_tools/advapi32.def -l work/guest_tools/obj/advapi32.lib
xcrun clang --target=aarch64-pc-windows-msvc -ffreestanding -fno-builtin -fno-stack-protector -mno-stack-arg-probe -O2 \
  -c tools/opt_hive_arm64.c -o work/guest_tools/obj/opt_hive_arm64.obj
/opt/homebrew/opt/lld/bin/lld-link /nologo /machine:arm64 /nodefaultlib /subsystem:console /entry:mainCRTStartup \
  work/guest_tools/obj/opt_hive_arm64.obj work/guest_tools/obj/kernel32.lib work/guest_tools/obj/advapi32.lib \
  /out:build/opt_hive_arm64.exe
ls -l build/opt_hive_arm64.exe

Check: Die letzte Zeile zeigt build/opt_hive_arm64.exe.

Schritt 5: Windows 11 ARM64 bei Microsoft runterladen

Die Scripts erwarten die Windows-Installationsdatei an einem festen Ort. Du holst sie aus Microsofts eigenem Download-Katalog, derselben Liste, die auch das offizielle Media Creation Tool nutzt. Die Datei ist eine ESD, ein komprimiertes Windows-Installations-Image.

Dieser Block lädt den Katalog, sucht die englische (US) ARM64-Datei raus, lädt sie herunter (rund 4,5 GB) und prüft sie gegen die SHA1-Prüfsumme, einen Fingerabdruck, den Microsoft im Katalog mitliefert:

cd ~/WindowsiOS
mkdir -p work/downloads
cd work/downloads
curl -L --fail -o products.cab "https://go.microsoft.com/fwlink/?LinkId=2156292"
tar -xf products.cab
python3 - > esd.txt <<'EOF'
import xml.etree.ElementTree as ET
for f in ET.parse("products.xml").iter("File"):
    if f.findtext("Architecture") == "ARM64" and f.findtext("LanguageCode") == "en-us" and f.findtext("Edition") == "Professional":
        print(f.findtext("FilePath")); print(f.findtext("Sha1")); break
EOF
cat esd.txt
curl -L --fail -o Win11_24H2_ARM64_en-us.esd "$(sed -n 1p esd.txt)"
echo "$(sed -n 2p esd.txt)  Win11_24H2_ARM64_en-us.esd" | shasum -a 1 -c
cd ~/WindowsiOS

Check: Die Zeile vor dem cd lautet Win11_24H2_ARM64_en-us.esd: OK.

Gut zu wissen:

Der Download-Link im Katalog ist einfaches http. Das ist bei Microsofts Download-Servern normal (mit https bekam ich einen Zertifikatsfehler). Der SHA1-Check stellt sicher, dass die Datei echt und vollständig ist.
Ich habe Build 26100.4349 bekommen, SHA1 c78fd344e845d3b17cb91c40bf4a856459da1b6c. Hat Microsoft den Katalog inzwischen aktualisiert, bekommst du einen neueren Build. Dann mach den Check unten: Die Scripts nehmen Image Nummer 6 aus der Datei, und das muss Windows 11 Pro sein.

wimlib-imagex info work/downloads/Win11_24H2_ARM64_en-us.esd 6 | grep "^Name"

Bleib bei Englisch (US): Die Setup-Scripts sind dafür geschrieben.

Schritt 6: Den Netzwerk-Treiber hinzufügen (für Internet in Windows)

Ohne diesen Schritt hat Windows kein Internet. Der virtuelle PC hat eine VirtIO-Netzwerkkarte (eine Standard-Netzwerkkarte für virtuelle Maschinen, die viele Emulatoren nutzen), und Windows braucht dafür einen Treiber namens NetKVM. Die Setup-Scripts aus dem Repo installieren diesen Treiber nie. Ich habe einen kleinen Patch ergänzt, der das erledigt, und damit hat Edge in Windows auf meinem iPhone Duo Websites geladen (getestet am 12. November 2026). Ohne den Patch kann ich dir zum Netzwerk nichts sagen, weil ich diese Kombination auf dem iPhone nie laufen hatte.

Der Treiber stammt aus Red Hats Open-Source-Projekt virtio-win. Du brauchst drei Dinge: den Treiber-Download, den ARM64-Treiber für Windows 11 im Projektordner und den Patch.

Lade virtio-win 0.1.302 herunter, die Version, die ich genutzt habe (rund 836 MB). Das Projekt veröffentlicht für diese Datei keine Prüfsumme, also vergleich deine mit dem SHA256 von meiner: 303f7ae40dad495d6ae474fdc571df58958a4dbc5c37a522d80f9a203867949d.

cd ~/WindowsiOS/work/downloads
curl -fL -o virtio-win-0.1.302.iso https://fedorapeople.org/groups/virt/virtio-win/direct-downloads/archive-virtio/virtio-win-0.1.302-1/virtio-win-0.1.302.iso
shasum -a 256 virtio-win-0.1.302.iso
cd ~/WindowsiOS

Kopier den Windows-11-ARM64-Treiber nach work/drivers/NetKVM. Der erste Befehl hängt den Download (ein ISO-Disk-Image) schreibgeschützt ein, die letzten werfen ihn wieder aus:

cd ~/WindowsiOS
mkdir -p work/drivers/NetKVM
MNT=$(hdiutil attach -readonly -nobrowse -mountrandom /tmp work/downloads/virtio-win-0.1.302.iso | grep -o '/private/tmp/dmg\.[A-Za-z0-9]*' | head -1)
echo "$MNT"
cp "$MNT"/NetKVM/w11/ARM64/{netkvm.cat,netkvm.inf,netkvm.sys,netkvmco.exe,netkvmp.exe,Readme.md} work/drivers/NetKVM/
chmod u+w work/drivers/NetKVM/*
hdiutil detach "$MNT"
ls work/drivers/NetKVM

Check: Die Liste zeigt netkvm.cat, netkvm.inf, netkvm.sys, netkvmco.exe, netkvmp.exe und Readme.md.

Wende den Patch an. Er fügt nur Zeilen zu den zwei Setup-Scripts hinzu, sonst nichts:

Beide Scripts suchen nach work/drivers/NetKVM und kopieren den Ordner, falls vorhanden, auf die virtuelle Setup-Disk.
Während der Windows-Installation fügt DISM (Windows‘ eigenes Tool zum Bearbeiten von Installations-Images) den Treiber ins frische Windows ein.
Der Optimizer fügt ihn ein zweites Mal hinzu. Klappt das nicht, hinterlässt er einen einmaligen Befehl (RunOnce), der den Treiber beim nächsten Login mit pnputil installiert.

Kopier den ganzen Block, vom cd bis zur letzten Zeile:

cd ~/WindowsiOS
cat > work/netkvm.patch <<'EOF'
diff --git a/scripts/optimize_windows_lite.py b/scripts/optimize_windows_lite.py
index 315f242..5c68573 100755
--- a/scripts/optimize_windows_lite.py
+++ b/scripts/optimize_windows_lite.py
@@ -31,6 +31,7 @@ SRC_IMG = WORK / "windows11.img"
 LITE_IMG = WORK / "windows11_lite.img"
 PE_IMG = WORK / "_opt_pe.img"
 PE_VARS = WORK / "_opt_pe_vars.fd"
+NETKVM_DIR = WORK / "drivers" / "NetKVM"  # virtio-win NetKVM w11/ARM64 (optional)
 
 OPT_SYS_REG = r"""Windows Registry Editor Version 5.00
 
@@ -306,6 +307,20 @@ if "%WINDRV%"=="" (
 )
 
 echo [1/5] Found Windows 11 installation on %WINDRV%\ (ESP=%ESPDRV%) >> "%LOGFILE%"
+set "DRVSRC="
+for %%E in (C D E F G H I J K L M N O P Q R S T U V W Y Z) do (
+    if exist "%%E:\drivers\NetKVM\netkvm.inf" set "DRVSRC=%%E:\drivers\NetKVM"
+)
+set "NETKVM_FAIL=0"
+if not "%DRVSRC%"=="" (
+    echo [1b/5] Injecting NetKVM VirtIO network driver from %DRVSRC% >> "%LOGFILE%"
+    mkdir "%WINDRV%\Drivers\NetKVM" >nul 2>&1
+    xcopy /y /q "%DRVSRC%\*.*" "%WINDRV%\Drivers\NetKVM\" >> "%LOGFILE%" 2>&1
+    dism /Image:%WINDRV%\ /ScratchDir:X:\ /Add-Driver /Driver:"%DRVSRC%\netkvm.inf" >> "%LOGFILE%" 2>&1
+    if not "!errorlevel!"=="0" set "NETKVM_FAIL=1"
+)
+echo [1b/5] NetKVM DISM failed=!NETKVM_FAIL! >> "%LOGFILE%"
+
 echo [2/5] Stripping 25 consumer inbox Appx bloatware bundles... >> "%LOGFILE%"
 set /a REMOVED_COUNT=0
 for %%P in (
@@ -346,6 +361,10 @@ reg load HKLM\OFFSYS "%WINDRV%\Windows\System32\config\SYSTEM" >> "%LOGFILE%" 2>
 reg load HKLM\OFFSOFT "%WINDRV%\Windows\System32\config\SOFTWARE" >> "%LOGFILE%" 2>&1
 X:\Windows\System32\opt_hive_arm64.exe >> "%LOGFILE%" 2>&1
 reg import X:\Windows\System32\opt_soft.reg >> "%LOGFILE%" 2>&1
+if "!NETKVM_FAIL!"=="1" (
+    reg add "HKLM\OFFSOFT\Microsoft\Windows\CurrentVersion\RunOnce" /v InstallNetKVM /t REG_SZ /d "pnputil /add-driver C:\Drivers\NetKVM\netkvm.inf /install" /f >> "%LOGFILE%" 2>&1
+    echo [3b/5] Added RunOnce pnputil fallback for NetKVM >> "%LOGFILE%"
+)
 reg unload HKLM\OFFSOFT >> "%LOGFILE%" 2>&1
 reg unload HKLM\OFFSYS >> "%LOGFILE%" 2>&1
 
@@ -466,6 +485,10 @@ def build_opt_winpe():
             "opt_usr.reg": make_user_reg("OFFUSR"),
             "opt_def.reg": make_user_reg("OFFDEF"),
         }
+        if (NETKVM_DIR / "netkvm.inf").exists():
+            shutil.copytree(NETKVM_DIR, pe_root / "drivers" / "NetKVM", dirs_exist_ok=True)
+            subprocess.run(["dot_clean", "-m", str(pe_root / "drivers")], check=False)
+            print(f"Staged NetKVM driver from {NETKVM_DIR}", flush=True)
         opt_exe = ROOT / "build" / "opt_hive_arm64.exe"
         if not opt_exe.exists():
             raise RuntimeError(f"Missing {opt_exe}")
diff --git a/scripts/provision_windows_arm64.py b/scripts/provision_windows_arm64.py
index 1cf3868..3e88349 100755
--- a/scripts/provision_windows_arm64.py
+++ b/scripts/provision_windows_arm64.py
@@ -22,6 +22,7 @@ INST_IMG = WORK / "installer_v4.img"
 WIN_IMG = WORK / "windows11.img"
 CODE_FD = WORK / "code.fd"
 VARS_FD = WORK / "vars.fd"
+NETKVM_DIR = WORK / "drivers" / "NetKVM"  # virtio-win NetKVM w11/ARM64 (optional; injected if present)
 
 STARTNET_CMD = r"""@echo off
 wpeinit
@@ -69,6 +70,13 @@ if errorlevel 1 (
   exit /b 1
 )
 
+for %%l in (C D E F G H I J K L) do (
+  if exist %%l:\drivers\NetKVM\netkvm.inf (
+    echo [WIN11-PROVISION] Injecting NetKVM VirtIO network driver from %%l:\drivers\NetKVM
+    dism /Image:W:\ /ScratchDir:X:\ /Add-Driver /Driver:%%l:\drivers\NetKVM\netkvm.inf
+  )
+)
+
 echo [WIN11-PROVISION] Injecting unattend.xml and offline registry settings...
 mkdir W:\Windows\Panther
 copy /y X:\Windows\System32\unattend_panther.xml W:\Windows\Panther\unattend.xml
@@ -242,6 +250,10 @@ def build_two_partition_installer():
         # Export unsplit Windows 11 Pro (Index 6) directly onto ExFAT WINWIM!
         (wim_root / "sources").mkdir(parents=True, exist_ok=True)
         run(["/opt/homebrew/bin/wimlib-imagex", "export", ESD, "6", wim_root / "sources" / "install.wim", "--compress=LZX"])
+        if (NETKVM_DIR / "netkvm.inf").exists():
+            shutil.copytree(NETKVM_DIR, wim_root / "drivers" / "NetKVM", dirs_exist_ok=True)
+            subprocess.run(["dot_clean", "-m", str(wim_root / "drivers")], check=False)
+            print(f"Staged NetKVM driver from {NETKVM_DIR}", flush=True)
     finally:
         subprocess.run(["hdiutil", "detach", whole_disk], check=False)
 
EOF
git apply --check work/netkvm.patch && git apply work/netkvm.patch
grep -c NETKVM_DIR scripts/provision_windows_arm64.py scripts/optimize_windows_lite.py

Check: git apply gibt nichts aus, und grep zeigt bei beiden Dateien 4. Meckert git apply --check, bist du wahrscheinlich nicht auf Commit 0a46e3f (Schritt 2), oder du hast den Patch schon einmal angewendet.

Schritt 7: Deinen Windows-Account-Namen festlegen

Die Scripts richten Windows komplett automatisch ein, mit einer Unattend-Datei (den Antworten für das Windows-Setup, damit niemand durchklicken muss). Der Account-Name steht in zwei Scripts, im Original ist es der Name des Entwicklers, „Ammaar“. Ersetz ihn durch deinen. Nimm nur Buchstaben und Zahlen, keine Leerzeichen. Ersetz DeinName in beiden Zeilen durch deinen Namen:

cd ~/WindowsiOS
sed -i '' 's/Ammaar/DeinName/g' scripts/provision_windows_arm64.py scripts/optimize_windows_lite.py
grep -c "DeinName" scripts/provision_windows_arm64.py scripts/optimize_windows_lite.py

Check: Bei beiden Dateien steht eine Zahl größer als 0.

Der Account ist Administrator, hat kein Passwort und meldet sich automatisch an. Ein Passwort kannst du später in Windows setzen. Als Zeitzone ist US-Ostküste eingestellt. Für deutsche Zeit stellst du das vor Schritt 8 so um (oder später in den Windows-Einstellungen):

cd ~/WindowsiOS
sed -i '' 's/Eastern Standard Time/W. Europe Standard Time/' scripts/provision_windows_arm64.py

Schritt 8: Das Windows-Image bauen

Jetzt installiert der Mac Windows in eine virtuelle Disk, ohne Fenster und ohne dass du klicken musst. Drei Befehle: installieren, abspecken, packen.

Lass den Mac wach und am Strom, und häng währenddessen keine anderen Disk-Images oder USB-Sticks an. Die Scripts erstellen und partitionieren eigene Disk-Images mit diskutil und lesen das Gerät aus der Ausgabe von hdiutil aus.

cd ~/WindowsiOS
/opt/homebrew/bin/python3 scripts/provision_windows_arm64.py
/opt/homebrew/bin/python3 scripts/optimize_windows_lite.py
./build/hvsparse pack work/windows11_lite.img work/windows11.hvsparse
ls -lh work/windows11.hvsparse

Was dabei passiert:

provision_windows_arm64.py bootet den Windows-Installer im Mac-Emulator, installiert Windows 11 Pro nach work/windows11.img, erledigt das erste Setup und fährt sauber runter. Außerdem kopiert es die UEFI-Firmware (das „BIOS“ des PCs, hier TianoCore aus dem qemu-Paket) nach work/code.fd und speichert die sauberen Firmware-Einstellungen als work/vars_clean.fd.
optimize_windows_lite.py schaltet in einer Offline-Kopie, work/windows11_lite.img, Hintergrunddienste ab. Bei mir ist dabei das Entfernen der vorinstallierten Apps mit 0x80004002 fehlgeschlagen. Das ist harmlos (siehe Troubleshooting).
hvsparse pack packt die 32-GB-Disk in eine Sparse-Datei: Leere Bereiche werden nicht gespeichert, dadurch schrumpft sie auf rund 14 GB.

Check: Der letzte Befehl zeigt eine Datei mit rund 14 GB (bei mir 14,2 GB). Hast du Schritt 6 gemacht, steht in der Ausgabe der ersten beiden Befehle außerdem Staged NetKVM driver from ….

Wenn alles auf dem iPhone ist (Schritt 13), kannst du work/windows11.img und work/downloads/Win11_24H2_ARM64_en-us.esd löschen und bekommst Platz zurück.

Schritt 9: Optional ein Test-Boot auf dem Mac

Bevor du 14 GB aufs iPhone kopierst, kannst du prüfen, ob das Image bootet. Der Befehl startet Windows drei Minuten lang ohne Fenster auf dem Mac und speichert nach 170 Sekunden einen Screenshot. Er nutzt eine Kopie der Firmware-Einstellungen, damit die saubere Datei fürs iPhone unangetastet bleibt:

cd ~/WindowsiOS
cp work/vars_clean.fd /tmp/vars-test.fd
./build/winvm --headless --code work/code.fd --vars /tmp/vars-test.fd --disk work/windows11_lite.img \
  --cpus 4 --ram 4096 --screenshot /tmp/win11-test.png --screenshot-after 170 --timeout 180
open /tmp/win11-test.png

Check: Der Screenshot zeigt den Windows-11-Desktop.

Schritt 10: iPhone und Apple-Account vorbereiten

Verbinde das iPhone per Kabel mit dem Mac und entsperr es. Tipp bei „Diesem Computer vertrauen?“ auf Vertrauen und gib deinen Code ein. Fragt der Mac, ob das Zubehör sich verbinden darf, klick auf Erlauben.
Prüf, ob die USB-Tools mit dem iPhone sprechen. Du solltest SUCCESS: Validated pairing sehen. Falls nicht, führ idevicepair pair aus und tipp auf dem iPhone noch mal auf Vertrauen:

idevicepair validate

Schalte auf dem iPhone den Entwicklermodus ein: Einstellungen > Datenschutz & Sicherheit > Entwicklermodus (ganz unten). Das iPhone startet neu. Danach bestätigst du mit „Aktivieren“. Fehlt der Schalter noch, öffne Xcode einmal mit angeschlossenem iPhone und schau dann noch mal nach.
Such die zwei IDs deines iPhones raus. Die UDID ist die Hardware-ID des iPhones (sie beginnt mit 0000). Die CoreDevice-ID ist die ID, unter der die Xcode-Tools das iPhone kennen (sie sieht aus wie 1A2B3C4D-1A2B-1A2B-1A2B-1A2B3C4D5E6F):

idevice_id -l
xcrun devicectl list devices

Der erste Befehl gibt die UDID aus. Beim zweiten steht die CoreDevice-ID in der Spalte Identifier neben deinem iPhone. Schreib dir beide auf. Taucht das iPhone dort nicht auf oder nur mit einer langen Nummer (der ECID), zieh das Kabel ab und steck es wieder an.

Check: In xcrun devicectl list devices steht bei deinem iPhone als State available, nicht unavailable. Falls nicht, führ xcrun devicectl manage pair --device DEINE_UDID aus und tipp auf dem iPhone auf Vertrauen.

Registrier das iPhone bei Apple: Auf developer.apple.com/account gehst du zu Zertifikate, IDs & Profile > Geräte, klickst auf +, wählst iOS, vergibst einen Namen und fügst deine UDID ein.
Notier dir deine Team-ID: auf developer.apple.com/account unter den Mitgliedschaftsdetails. Sie hat 10 Zeichen, zum Beispiel ABCDE12345.
Melde dich in Xcode mit demselben Account an: Xcode > Einstellungen > Accounts > + > Apple Account.

Schritt 11: Die App bauen und signieren

Die Projektdatei ist auf den Apple-Account des Entwicklers eingestellt. Das überschreibst du in der Kommandozeile mit deiner Team-ID und deiner eigenen Bundle-ID, dem eindeutigen App-Namen im umgedrehten Domain-Stil, zum Beispiel com.deinname.windowsios. Xcode erstellt dir dann ein Provisioning Profile: Apples Erlaubnis-Datei, die sagt „diese App darf auf diesem iPhone laufen“.

Führ das im Terminal direkt am Mac aus, nicht per SSH von einem anderen Rechner (siehe Troubleshooting). Ersetz DEINE_TEAM_ID und com.deinname.windowsios:

cd ~/WindowsiOS
xcodegen generate --spec ios/project.yml
xcodebuild -project ios/WindowsiOS.xcodeproj -scheme WindowsiOS -configuration Debug \
  -destination "generic/platform=iOS" -derivedDataPath ios/DerivedData \
  -allowProvisioningUpdates -allowProvisioningDeviceRegistration \
  DEVELOPMENT_TEAM=DEINE_TEAM_ID CODE_SIGN_STYLE=Automatic CODE_SIGN_IDENTITY="Apple Development" \
  PROVISIONING_PROFILE_SPECIFIER="" PRODUCT_BUNDLE_IDENTIFIER=com.deinname.windowsios \
  build

Ein Unterschied zu meinem Run: Ich habe mit einem App-Store-Connect-API-Key signiert statt über die Anmeldung in Xcode. Die Anmeldung in Xcode (Schritt 10) ist Apples Standardweg und macht dasselbe, genau in dieser Form habe ich sie aber nicht ausprobiert.

Fragt macOS nach Zugriff auf deinen Schlüsselbund (den Passwort- und Zertifikatsspeicher des Macs), gib dein Mac-Login-Passwort ein und klick auf Immer erlauben.

Check: Die Ausgabe endet mit ** BUILD SUCCEEDED **.

Schritt 12: Die App installieren

Ersetz DEINE_UDID:

cd ~/WindowsiOS
ideviceinstaller -u DEINE_UDID install ios/DerivedData/Build/Products/Debug-iphoneos/WindowsiOS.app

Check: ideviceinstaller -u DEINE_UDID list | grep -i windowsios gibt eine Zeile mit deiner Bundle-ID aus.

Die App erscheint auf dem Home-Bildschirm als „Windows 11“. Öffne sie nicht von dort. Ohne einen Debugger (Schritt 15 oder StikDebug weiter unten) ist der JIT nicht freigeschaltet.

Schritt 13: Windows aufs iPhone kopieren

Die App sucht in ihrem eigenen Ordner unter Documents/Machines/Win11 drei Dateien: die Firmware code.fd, die Firmware-Einstellungen vars.fd und die gepackte Disk windows11.hvsparse. afcclient kopiert Dateien per USB direkt in den Ordner der App. Lass das iPhone dabei angeschlossen und entsperrt. Ersetz DEINE_UDID und com.deinname.windowsios:

cd ~/WindowsiOS
printf "mkdir Documents/Machines\nmkdir Documents/Machines/Win11\nput -f $PWD/work/code.fd Documents/Machines/Win11/code.fd\nput -f $PWD/work/vars_clean.fd Documents/Machines/Win11/vars.fd\nput -f $PWD/work/windows11.hvsparse Documents/Machines/Win11/windows11.hvsparse\nls -l Documents/Machines/Win11\nquit\n" \
  | afcclient -u DEINE_UDID --container com.deinname.windowsios
ls -l work/code.fd work/vars_clean.fd work/windows11.hvsparse

Achtung: vars_clean.fd landet auf dem iPhone als vars.fd. put -f überschreibt Dateien, die schon auf dem iPhone liegen. Das brauchst du, wenn du später ein neu gebautes Image rüberkopierst. Meldet mkdir, dass der Ordner schon existiert, ist das okay.

Check: Die Liste vom iPhone zeigt dieselben Dateigrößen wie die Liste von deinem Mac. Die große Datei braucht ein paar Minuten.

Schritt 14: Das Launch-Script auf dein iPhone einstellen

Das Launch-Script fragt die Xcode-Tools nach der CoreDevice-ID deines iPhones. Fehlt diese Antwort, nimmt es eine fest eingetragene ID: die vom iPhone des Entwicklers. Ersetz sie durch deine CoreDevice-ID aus Schritt 10 (statt DEINE_COREDEVICE_ID):

cd ~/WindowsiOS
sed -i '' 's/FB6341E2-5109-505C-9A11-CFF7BE9973C3/DEINE_COREDEVICE_ID/' scripts/launch_on_duo.sh
grep -n "DEINE_COREDEVICE_ID" scripts/launch_on_duo.sh

Klar: In beiden Zeilen tippst du deine echte ID ein. Check: grep gibt eine Zeile mit deiner ID aus.

Schritt 15: Windows starten

Lass das iPhone angeschlossen und entsperrt. Ersetz DEINE_UDID und com.deinname.windowsios:

cd ~/WindowsiOS
./scripts/launch_on_duo.sh DEINE_UDID com.deinname.windowsios

Das Script startet die App pausiert, hängt den Debugger LLDB an, schaltet den JIT-Speicher frei und löst sich wieder. Im Terminal siehst du Zeilen mit [txm-jit]. Bei mir war die wichtige Zeile Blessed 384 MiB RX region ... in 58.35s, am Ende kam SUCCESS: ... debugger detached!

Auf dem iPhone passiert Folgendes:

Etwa eine Minute schwarzer Bildschirm, während der Debugger arbeitet. Das ist normal.
Nur beim allerersten Start: „Unpacking Windows 11 NVMe image“ mit Fortschrittsbalken. Das passiert nur einmal.
Das TianoCore-Logo: Die Firmware des virtuellen PCs startet Windows.
Der Windows-Login, danach der Desktop.

Check: Öffne in Windows Settings > System > About. Dort stehen Windows 11 Pro und ein Apple A20 Pro.

Hast du in Schritt 6 den Netzwerk-Treiber ergänzt, öffne Edge und ruf eine beliebige Website auf.

Windows ohne Mac starten (StikDebug)

Das Launch-Script aus Schritt 15 braucht Mac und Kabel bei jedem Start. Einmal eingerichtet, gibt es einen zweiten Weg, der nur auf dem iPhone läuft: StikDebug, eine Open-Source-App, die direkt auf dem iPhone als Debugger arbeitet. Sie macht denselben Job wie LLDB auf dem Mac: Sie hängt sich kurz an WindowsiOS, schaltet den JIT frei und löst sich wieder.

Um an die Entwickler-Dienste des iPhones zu kommen, nutzt StikDebug LocalDevVPN aus dem App Store. Das ist ein „Loopback“-VPN: Der Tunnel führt vom iPhone zurück zum iPhone, dadurch kann StikDebug mit dem iPhone reden wie sonst der Mac über das Kabel.

Ich habe diesen Weg am 12. November 2026 auf meinem iPhone Duo mit iOS 27.2 getestet, mit StikDebug 3.2.2 aus dem offiziellen Repo. Den Mac brauchst du trotzdem einmal, um StikDebug zu bauen und zu installieren, und wieder, wenn die Signatur abläuft (siehe die Hinweise unten).

StikDebug bauen und installieren (einmal, am Mac)

StikDebug gibt es nicht mehr im App Store. Du baust es genauso wie WindowsiOS, signiert mit deinem eigenen Apple-Team. Version 3.2.2 braucht Xcode 27.

Hol den Code in der Version, die ich genutzt habe:

git clone https://github.com/StikDebug/StikDebug.git ~/StikDebug
cd ~/StikDebug
git checkout 3.2.2

Check: git log --oneline -1 beginnt mit 0393dca. Git meldet dabei etwas von „detached HEAD“. Das ist so gewollt.

Entfern die App Group. Das Projekt verlangt eine App Group (einen gemeinsamen Speicherbereich), die beim Apple-Team des ursprünglichen Entwicklers registriert ist, dein Team kann sie also nicht nutzen. Ich habe sie vor dem Build entfernt. Dieser Befehl löscht genau diesen Eintrag:

cd ~/StikDebug
/usr/libexec/PlistBuddy -c "Delete :com.apple.security.application-groups" StikDebug/StikDebug.entitlements
grep -c application-groups StikDebug/StikDebug.entitlements

Check: grep gibt 0 aus.

Bau StikDebug mit deiner Team-ID und deiner eigenen Bundle-ID, zum Beispiel com.deinname.stikdebug. Ersetz DEINE_TEAM_ID und com.deinname.stikdebug und führ es wie in Schritt 11 im Terminal direkt am Mac aus:

cd ~/StikDebug
xcodebuild -project StikDebug.xcodeproj -scheme StikDebug -configuration Release \
  -destination "generic/platform=iOS" -derivedDataPath build/DD \
  -allowProvisioningUpdates -allowProvisioningDeviceRegistration \
  DEVELOPMENT_TEAM=DEINE_TEAM_ID CODE_SIGN_STYLE=Automatic CODE_SIGN_IDENTITY="Apple Development" \
  PROVISIONING_PROFILE_SPECIFIER="" PRODUCT_BUNDLE_IDENTIFIER=com.deinname.stikdebug \
  build

Check: Die Ausgabe endet mit ** BUILD SUCCEEDED **. Wie in Schritt 11 habe ich mit einem App-Store-Connect-API-Key signiert statt über die Anmeldung in Xcode.

Installier es bei angeschlossenem, entsperrtem iPhone (ersetz DEINE_UDID):

cd ~/StikDebug
ideviceinstaller -u DEINE_UDID install build/DD/Build/Products/Release-iphoneos/StikDebug.app
ideviceinstaller -u DEINE_UDID list | grep -i stikdebug

Check: Der zweite Befehl gibt eine Zeile mit deiner StikDebug-Bundle-ID aus.

Auf dem iPhone einrichten (einmal)

Installier LocalDevVPN aus dem App Store, öffne es, erlaub das Hinzufügen der VPN-Konfiguration und schalte es ein. iOS lässt nur ein VPN gleichzeitig laufen, schalte Tailscale oder andere VPNs also vorher aus.
Erstell das Pairing-File: den Vertrauens-Eintrag, mit dem StikDebug die Entwickler-Dienste des iPhones nutzen darf, so wie das „Diesem Computer vertrauen“ mit deinem Mac. In StikDebug gehst du zu Settings > Pair a Device > Pair iPhone or iPad. Unter iOS 27 klappt das ohne Computer.
Öffne StikDebug einmal mit eingeschaltetem LocalDevVPN, während das iPhone im WLAN mit Internet ist, und lass es fertig verbinden. Beim ersten Mal lädt es das Developer Disk Image herunter und hängt es ein: Apples Paket mit Entwickler-Tools fürs iPhone, in dem der Debugger steckt.

Check: StikDebug zeigt „Device connected“, und „Windows 11“ steht unter Apps with get-task-allow (Apps, an die sich ein Debugger hängen darf, wie dein selbst gebautes WindowsiOS).

Windows vom iPhone aus starten (jedes Mal)

Schalte LocalDevVPN ein. Tailscale und andere VPNs müssen aus bleiben, während du den JIT freischaltest.
Öffne StikDebug. Es startet im Tab JIT mit dem Titel Enable JIT. Oben sollte „Device connected“ stehen.
Wähl in der Liste Apps with get-task-allow „Windows 11“, also deine WindowsiOS-App.
StikDebug startet WindowsiOS, schaltet den JIT frei und löst sich wieder. Danach kommt das TianoCore-Logo, und Windows startet.

Check: Windows bootet, ohne dass das iPhone an einem Computer hängt.

Gut zu wissen:

Von mir getestet: iPhone Duo, iOS 27.2, StikDebug 3.2.2, 12. November 2026. Andere Versionen und andere iPhones habe ich nicht ausprobiert.
Behalt das Pairing-File für dich. Es gibt vollen Zugriff auf dein iPhone: Apps installieren, Dateien lesen, Apps debuggen. Teil es nicht, lad es nirgends hoch und häng es an keinen Bug-Report. Laut der StikDebug-Doku wird es ungültig, wenn du den Gerätecode deines iPhones änderst oder zurücksetzt. Dann erstellst du in Schritt 2 ein neues.
Signaturen laufen ab. Selbst signierte Apps laufen nur, solange ihr Developer-Profil gültig ist, mit bezahltem Account etwa ein Jahr. Danach baust und installierst du StikDebug und WindowsiOS am Mac neu (für WindowsiOS Schritt 11 und 12, für StikDebug die Build- und Install-Schritte oben).
Andere Install-Wege für StikDebug gibt es auch: die AltSource https://stikdebug.xyz/index.json (eine App-Liste für die Sideloading-Apps SideStore oder AltStore) und die IPA-Datei (die gepackte App) auf der GitHub-Release-Seite. Die habe ich nicht getestet.
Der ENABLE-JIT-Button in WindowsiOS gibt ebenfalls an StikDebug weiter. Getestet habe ich nur den Start aus der Liste in StikDebug, wie oben beschrieben.

Schritt 16: Die Auflösung auf 1024 × 768 erhöhen

Windows startet mit 800 × 600. Eine Boot-Einstellung erlaubt ihm den höchsten Modus der Firmware, und das ist 1024 × 768:

Klick auf Start, tipp cmd, mach einen Rechtsklick auf Command Prompt und wähl Run as administrator. Bestätige mit Yes.
Führ diesen Befehl aus. Die Antwort sollte „The operation completed successfully.“ sein:

bcdedit /set {default} highestmode on

Starte Windows neu (Start > Power > Restart). Kommt Windows nicht von selbst zurück, schließ die App und starte sie wieder mit dem Launch-Script aus Schritt 15 oder aus StikDebug.

Check: Settings > System > Display > Advanced display zeigt 1024 × 768. Ich habe den Fix bei einem Test-Boot desselben Images auf dem Mac getestet.

Windows später wieder starten

Jedes Mal, wenn du Windows willst, startest du es auf einem von zwei Wegen: Du verbindest das iPhone mit dem Mac, entsperrst es und führst den Befehl aus Schritt 15 erneut aus, oder du schaltest LocalDevVPN ein und nutzt den Tab JIT in StikDebug (Abschnitt „Windows ohne Mac starten“). Windows behält seine Dateien zwischen den Starts, und das Entpacken vom ersten Start passiert nicht noch mal. Löschst du die App vom Home-Bildschirm, ist auch das Windows-Image darin weg.

Troubleshooting

`xcode-select: error: tool 'xcodebuild' requires Xcode`

Die Kommandozeile zeigt auf die kleinen Command Line Tools statt aufs volle Xcode. Führ sudo xcode-select -s /Applications/Xcode.app/Contents/Developer aus (Schritt 1).

Signieren schlägt fehl, wenn du per SSH baust

Per SSH ist der Login-Schlüsselbund des Macs gesperrt, xcodebuild kommt also nicht an dein Signing-Zertifikat. Bau im Terminal direkt am Mac, während du eingeloggt bist (Schritt 11).

Ein altes Zertifikat „Created via API“ blockiert das Signieren

Ein fehlgeschlagener Build kann ein „Apple Development“-Zertifikat hinterlassen, dessen privater Schlüssel nicht auf deinem Mac liegt. Öffne auf developer.apple.com die Zertifikate, such das mit „Created via API“, widerruf es und mach Schritt 11 noch mal. Xcode erstellt dann ein frisches Zertifikat.

Installation bricht ab mit „A valid provisioning profile for this executable was not found“

Dein iPhone ist nicht bei deinem Account registriert, oder Xcode nutzt noch ein altes, zwischengespeichertes Profil. Registrier die UDID unter Geräte (Schritt 10). Dann schieb die zwischengespeicherten Profile zur Seite und wiederhol Schritt 11 und 12:

mkdir -p ~/old-profiles
mv ~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/* ~/old-profiles/

Das iPhone taucht nicht auf oder die Installation wird abgelehnt

Das iPhone muss dem Mac vertrauen („Diesem Computer vertrauen?“) und den Entwicklermodus an haben (Schritt 10).

`xcrun devicectl list devices` zeigt nur eine lange Nummer (die ECID)

Zieh das Kabel ab und steck es wieder an. Das hat es bei mir gelöst. In Xcode 27 ist das Geräte-Fenster eine eigene App namens DeviceHub (in Xcode: Product > Destination > Manage Devices…).

Das Launch-Script nimmt das falsche Gerät oder scheitert bei `device select`

Das Script ist auf die CoreDevice-ID des Entwicklers zurückgefallen. Mach Schritt 14 mit deiner eigenen ID aus xcrun devicectl list devices.

Der Optimizer meldet den DISM-Fehler `0x80004002`

Bei mir ist damit das Entfernen der vorinstallierten Apps fehlgeschlagen. Edge und der Store bleiben drauf, alles andere läuft. Kannst du ignorieren.

Die App sagt „Place code.fd, vars.fd, and windows11.hvsparse in Documents/Machines/Win11“

Die Dateien fehlen oder liegen am falschen Ort. Wiederhol Schritt 13 und prüf die Bundle-ID: Es muss die aus Schritt 11 sein.

Die App zeigt „Waiting for TXM JIT“ und einen ENABLE-JIT-Button

Du hast die App vom Home-Bildschirm geöffnet, es hängt also kein Debugger dran. Schließ die App und starte sie mit dem Launch-Script aus Schritt 15 oder aus StikDebug (den Tab JIT öffnen, dann die App auswählen). Der ENABLE-JIT-Button in der App gibt ebenfalls an StikDebug weiter, getestet habe ich aber nur den Start aus der Liste in StikDebug.

StikDebug meldet Verbindungs- oder Heartbeat-Fehler

Der Heartbeat ist das regelmäßige Lebenszeichen zwischen StikDebug und iPhone. Prüf, ob LocalDevVPN an ist, ob das iPhone im WLAN ist und ob kein anderes VPN läuft. Das nennt die StikDebug-Doku als Erstes. Klappt es weiter nicht, erstell bei entsperrtem iPhone ein neues Pairing-File (Settings > Pair a Device).

Signieren von StikDebug meldet einen App-Group-Fehler

Der App-Group-Eintrag steht noch im Projekt. Führ den PlistBuddy-Befehl aus dem StikDebug-Abschnitt noch mal aus und bau dann neu.

Etwa eine Minute schwarzer Bildschirm nach dem Start

Da schaltet der Debugger den JIT frei. Warte ab. Danach kommt das TianoCore-Logo, dann Windows.

Kein Internet in Windows

Der Netzwerk-Treiber fehlt. Er kommt nur beim Bauen des Images in Windows rein, also mach Schritt 6, bau das Image neu (Schritt 8), kopier es rüber (Schritt 13) und starte es (Schritt 15). Beim nächsten Start entpackt die App das neue Image und ersetzt das alte. Alles, was du im alten Windows gespeichert hattest, ist dann weg. Hast du die ESD nach Schritt 8 gelöscht, lad sie vorher neu (Schritt 5).

Das Bild ist klein (800 × 600)

Das ist der Standard. Mach Schritt 16 für 1024 × 768.

Credits und Lizenz

WindowsiOS stammt von Ammaar Reshi: github.com/ammaarreshi/WindowsiOS, Lizenz GPL-2.0-or-later. Es baut auf Leviidevs Henge und Husk auf, auf dem JIT-Ansatz von StikDebug, der TianoCore-EDK2-Firmware und libslirp. Der NetKVM-Netzwerk-Treiber stammt aus Red Hats Projekt virtio-win. Laut README ist es mit Hilfe eines KI-Modells entstanden.

Vor dem Build habe ich den Code durchgesehen. Telemetrie oder Uploads deiner Daten habe ich nicht gefunden. Das Build-Script lädt libffi, glib und libslirp aus ihren öffentlichen Quellen, ohne Prüfsummen zu checken, und kopiert ein vorkompiliertes StikJIT-Framework aus dem Husk-Repo.

Mehr zum iPhone selbst: mein Unboxing und erster Tag mit dem iPhone Duo.

Hat dir der Guide geholfen? Dann spendier mir gern einen Kaffee auf Ko-fi. Damit bleibt MappleBox werbefrei.