apfel ist ein -Projekt.

v1.18.0 · Null Konfiguration · MIT

apfel

Die kostenlose KI, die schon auf deinem Mac ist.

macOS Tahoe bringt ein LLM mit 3 Mrd. Parametern mit. apfel macht es mit einem brew install über die CLI nutzbar. Keine Modell-Downloads, keine API-Keys, keine Konfiguration: Es funktioniert einfach.

  • Keine Token-Kosten
  • On-Device-KI
  • Skriptbar
$ brew install apfel

6.6k+ Sterne auf github.com/Arthur-Ficial/apfel

Voraussetzungen: Apple Silicon · macOS Tahoe · Apple Intelligence aktiviert

Neu bei apfel? Zum 60-Sekunden-Tutorial (auf Englisch)

Alles läuft auf deinem Gerät. Keine Netzwerkaufrufe. Keine Daten verlassen deinen Mac.

Sieh es in Aktion.

Von brew install zur KI-Antwort in 12 Sekunden. Ganz ohne Konfiguration.

Terminal - apfel
$
Echte Terminal-Aufnahme, nichts geschnitten: apfel 1.18.0 unter macOS 27.0.1, MacBook Air M2.

Null Konfiguration. Null LLM-Downloads. Null Token-Kosten.

Andere lokale KI-Tools sind großartig, brauchen aber Modell-Downloads und Konfiguration. apfel braucht nichts - das Modell ist schon auf deinem Mac. Ein brew install. Fertig.

$0
Token-Kosten
Keine API-Keys. Keine Abos. Keine Abrechnung pro Token. Deine Hardware, deine KI.
100%
On-Device
Jedes Token entsteht lokal auf deinem Apple Silicon. Nichts verlässt deinen Rechner. Niemals.
0
Konfigurationsschritte
Kein YAML. Keine Umgebungsvariablen. Keine Modellauswahl. Einmal installieren, für immer nutzen.

Das Modell unter der Haube

Apple ML Research
~3BParameter
4,096 / 8,192Kontextfenster (M1/M2 / M3+ unter macOS 27)
~3.5 bpwQuantisierung
Mixed 2/4-bitPräzision
Neural EngineLäuft auf
en, de, es, fr, it, ja, ko, pt, zhSprachen

Drei Tools. Eine Installation.

Eine CLI, ein OpenAI-kompatibler Server und ein interaktiver Chat. Alles aus einem einzigen brew install. Keine zusätzlichen Downloads.

>_

UNIX-Tool

Pipe-freundlich und kombinierbar. Funktioniert mit jq, xargs und deinen Shell-Skripten. stdin, stdout, JSON-Ausgabe, schema-valides JSON mit --schema, Multi-Turn aus einer Messages-Datei mit --messages, Dateianhänge, saubere Exit-Codes.

$ apfel "What is the capital of Austria?"
The capital of Austria is Vienna.

$ apfel -o json "Translate to German: Apple" | jq .content
"Apfel"

# --schema: output guaranteed to match your JSON Schema
$ apfel --schema person.json "Alice is 30." | jq .name
"Alice"

# --code: just the command, no prose, no fences
$ apfel --code "flush the dns cache on macos"
sudo /usr/bin/dscacheutil -flushcache
{ }

OpenAI-Server

Drop-in-Ersatz unter localhost:11434. Richte ein beliebiges OpenAI SDK darauf und leg los. Chat Completions und Responses API, Streaming, Tool Calling, JSON-Schema-Ausgabe, CORS.

$ apfel --serve
Server running on http://127.0.0.1:11434

# any OpenAI client works
$ curl localhost:11434/v1/chat/completions ...
...

Interaktiver Chat

Gespräche über mehrere Runden mit automatischem Kontextmanagement. Fünf Trimming-Strategien. Unterstützung für System-Prompts. Tipp einfach apfel ins Terminal, um loszulegen. Alles auf deinem Mac.

$ apfel --chat -s "You are a coding assistant"
Type 'quit' to exit.
> How do I reverse a list in Python?

Native MCP-Unterstützung.

Gib Apples On-Device-Modell Tools. Beliebige Tools.

Tool-Server mit --mcp anbinden

apfel spricht das Model Context Protocol. Richte es auf einen beliebigen MCP-Server, und das On-Device-Modell bekommt Tools - Mathe, APIs, Datenbanken, alles, wofür du einen Server schreiben kannst.

  • Funktioniert in allen drei Modi - CLI, Server und Chat
  • Findet Tools beim Start automatisch über MCP tools/list
  • Tool Calls werden automatisch erkannt und ausgeführt, die Ergebnisse fließen zurück ins Modell
  • Ohne --mcp-Flag kein Overhead - null zusätzliche Tokens, null Änderungen am Codepfad
  • Inklusive Taschenrechner-MCP-Server als Proof of Concept
  • Remote-MCP-Server per URL - --mcp https://... mit optionaler Bearer-Token-Authentifizierung
Terminal - apfel + MCP
# give the model a calculator
$ apfel --mcp ./mcp/calculator/server.py \
  "What is 15 times 27?"

tool: multiply({"a": 15, "b": 27}) = 405
15 times 27 is 405.

# attach multiple servers
$ apfel --mcp ./calc.py --mcp ./weather.py \
  "What is sqrt(2025)?"

tool: sqrt({"n": 2025}) = 45.0
The square root of 2025 is 45.

# remote MCP server over HTTPS
$ apfel --mcp https://mcp.example.com/v1 "query"

# server mode - tools auto-available to all clients
$ apfel --serve --mcp ./calc.py

So funktioniert's.

Apple hat in jeden Mac ein LLM eingebaut. Es liegt einfach brach. apfel gibt ihm eine Haustür - ganz ohne Konfiguration.

Apple liefert ein On-Device-LLM mit

Seit macOS 26 (Tahoe) enthält jeder Mac mit Apple Silicon ein Sprachmodell als Teil von Apple Intelligence. Apple stellt es über das FoundationModels-Framework bereit - eine Swift-API, über die Apps auf SystemLanguageModel zugreifen. Die gesamte Inferenz läuft auf Neural Engine und GPU. Keine Netzwerkaufrufe, keine Cloud, keine API-Keys. Das Modell ist einfach da.

Aber Apple nutzt es nur für Siri

Ab Werk treibt das On-Device-Modell Siri, Writing Tools und Systemfunktionen an. Es gibt keinen Terminal-Befehl, keinen HTTP-Endpunkt, keine Möglichkeit, Text per Pipe hindurchzuschicken. Das FoundationModels-Framework existiert, aber um es zu nutzen, musst du eine Swift-App schreiben. Genau das macht apfel.

Was apfel hinzufügt

apfel ist ein Swift-6.3-Binary, das LanguageModelSession kapselt und auf drei Arten bereitstellt: als UNIX-Kommandozeilentool mit stdin/stdout, als OpenAI-kompatibler HTTP-Server (auf Basis von Hummingbird) und als interaktiver Chat mit Kontextmanagement.

Es erledigt, was Apples rohe API nicht kann: saubere Exit-Codes, JSON-Ausgabe, Dateianhänge, fünf Strategien zum Kürzen des Kontexts für das kleine Kontextfenster (4.096 Tokens, 8.192 auf Macs mit M3 oder neuer unter macOS 27), echtes Token-Zählen über das SDK und die Umwandlung von OpenAI-Tool-Schemas in Apples natives Format Transcript.ToolDefinition.

hardware Apple Silicon (Neural Engine + GPU)
|
modell Apples On-Device-LLM (Teil von macOS)
|
sdk FoundationModels.framework (Swift-API)
|
apfel CLI + HTTP-Server + Kontextmanagement
|
du Terminal, Shell-Skripte, OpenAI SDKs, curl
4.096 oder 8.192 Tokens Kontextfenster (Eingabe + Ausgabe). 4.096 unter macOS 26 und auf M1/M2-Macs; 8.192 auf M3 oder neuer mit 12 GB+ unter macOS 27. apfel liest es zur Laufzeit aus.
1 Modell Fest vorgegeben, nicht konfigurierbar
Swift 6.3 Strict Concurrency, ohne Xcode
MIT-Lizenz Open Source

Privat von Grund auf.

Kein einziger HTTP-Aufruf, während du apfel nutzt. Jede Aussage unten verlinkt auf Apples eigene Dokumentation.

Auf dem Gerät. Funktioniert offline.

Das FoundationModels-Framework läuft komplett auf der Neural Engine deines Apple Silicon. Kein Server, keine Cloud, keine Internetverbindung nötig.

"You can build experiences that are smart, private, and work without internet connectivity." - Apple Developer

Deine Daten bleiben deine.

Apple sammelt bei der On-Device-Inferenz weder Prompts noch Antworten noch sonstige Nutzungsdaten. Nichts wird gespeichert, nichts wird gesendet.

"The cornerstone of Apple Intelligence is on-device processing." - Apple Privacy

Nie fürs Training verwendet.

Apple trainiert seine Foundation Models ausschließlich mit lizenzierten und öffentlichen Daten. Deine Interaktionen landen nie in der Trainingspipeline.

"We do not use our users' private personal data or user interactions when training our foundation models." - Apple ML Research

apfel trackt nichts.

Keine Analytics, keine Telemetrie, keine automatischen Update-Checks, kein Crash-Reporting, kein Nach-Hause-Telefonieren. Den einzigen Netzwerkaufruf macht apfel, wenn du ausdrücklich apfel --update ausführst. Die gesamte Codebasis ist Open Source.

Power-Tools inklusive.

Shell-Skripte im Ordner demo/. Installiere zuerst apfel und schnapp dir dann die, die du brauchst.

>_

cmd

Von natürlicher Sprache zum Shell-Befehl. Sag, was du willst, und bekomm den Befehl.

$ cmd "find all .log files modified today"
|>

oneliner

Pipe-Ketten aus ganz normaler Sprache. awk, sed, sort, uniq - für dich generiert.

$ oneliner "count unique IPs in access.log"
**

mac-narrator

Kommentiert die Systemaktivität deines Macs wie eine Naturdoku.

$ mac-narrator --watch
?

explain

Erklärt jeden Befehl, jede Fehlermeldung und jedes Code-Snippet in verständlicher Sprache.

$ explain "awk '{print $1}' file | sort -u"
./

wtd

Was ist das für ein Verzeichnis? Sofortige Orientierung in jeder Codebasis.

$ wtd
++

gitsum

Fasst die letzten git-Commits in ein paar Sätzen zusammen.

$ gitsum

30 nützliche und coole One-Liner.

Jeder Befehl auf einem echten Mac getestet. Verkette apfel mit ps, lsof, du, vm_stat, git, pbpaste, sleep, pgrep, curl, say - so kombinierbar ist keine Cloud-KI, denn sie sieht weder deine Prozesse noch deine Zwischenablage noch deinen git diff. apfel schon.

Live-System 8

Was frisst gerade meine CPU?

$ps aux | sort -k 3 -nr | head -5 | awk '{print $11, $3"%"}' | apfel "which app is using the most CPU"

-> WindowServer braucht mit 42,6 % die meiste CPU.

Welche Apps lauschen auf welchen Ports?

$lsof -iTCP -sTCP:LISTEN -n -P | head -15 | apfel "list which apps own which ports as a table"

-> 11434 fichten, 18789 node, 5000 ControlCenter ...

Welches Volume ist am vollsten?

$df -h | apfel "which volume is fullest, one sentence"

-> /dev/disk3s1 ist mit 263Gi von 926Gi am vollsten.

vm_stat in verständliche Sprache übersetzt.

$vm_stat | apfel "explain my memory usage in plain english, one sentence"

-> 349k Seiten aktiv, 266k wired - viel Speicher belegt.

Welche Ordner fressen hier den meisten Platz?

$du -sh */ 2>/dev/null | sort -rh | head -5 | apfel "which folders are eating most disk, one sentence"

-> Library mit 36G und Downloads mit 604M dominieren.

Die größten Dateien in diesem Ordner.

$ls -laS | head -10 | apfel "what are the biggest files here, just file names"

-> apfel-quick-preview.png, og.png, translate-preview.png ...

Welche Apps reden gerade mit dem Internet?

$lsof -i -nP 2>/dev/null | grep ESTABLISHED | awk '{print $1, $9}' | head -10 | apfel "which apps are talking to the internet right now, short answer"

-> node → 157.240.253.60:443, claude.ex → 160.79.104.10:443, Google → 66.102.1.188:5228 ...

Akkuzustand und Restlaufzeit in einer Zeile.

$pmset -g batt | apfel "battery health and percent, one line"

-> Voll geladen, Zustand 100 %, gerade aktiv.

Git 2

Fass deine letzten Commits in verständlicher Sprache zusammen.

$git log --oneline -20 | apfel "summarize what I have been working on"

-> Updates von v1.2.1 auf v1.3.2, Schwesterprojekte hinzugefügt ...

Entwirf aus den letzten Commits eine einzeilige Release Note.

$git log --oneline -5 | apfel "write a one-line release note based on these commits"

-> v1.3.2 veröffentlicht mit 5053 Sternen, 783 Tests, Updates.

Zwischenablage hin und zurück 4

Korrigiere die Grammatik von allem, was in deiner Zwischenablage liegt, und leg die Korrektur zurück.

$pbpaste | apfel "fix grammar" | pbcopy

-> "i has went" wird zu "I went" - zurück in der Zwischenablage.

Übersetze die Zwischenablage ins Japanische und leg sie zurück.

$pbpaste | apfel "translate to japanese" | pbcopy

-> In der Zwischenablage steht jetzt die japanische Übersetzung.

Fass eine Textwand aus deiner Zwischenablage in 3 Stichpunkten zusammen.

$pbpaste | apfel "summarize in 3 bullets"

-> 3 knappe Stichpunkte in deinem Terminal.

Zieh saubere To-dos aus den Meeting-Notizen in deiner Zwischenablage.

$pbpaste | apfel "extract just the action items as a clean bullet list, no other text" | pbcopy

-> "Sarah entwirft Q3-Budget", "Designteam anmailen", ... zurück in der Zwischenablage.

Beobachten und ansagen 6

Lass dir laut Bescheid sagen, wenn ein langer Task fertig ist (hier in 30 Minuten).

$sleep 1800 && apfel "tell me cheerfully my long task just finished, one short sentence" | say

-> Der Mac sagt: "Dein langer Task ist gerade fertig geworden, gut gemacht!"

Warte, bis eine Datei in Downloads landet, und sag sie dann an.

$until [ -e ~/Downloads/Report.pdf ]; do sleep 5; done; apfel "tell me my download just landed, one cheerful sentence" | say

-> Prüft alle 5s; sobald Report.pdf auftaucht, verkündet der Mac die Neuigkeit.

Warte, bis ein lang laufender Prozess endet, und sag es dann an.

$while pgrep -q ffmpeg; do sleep 5; done; apfel "tell me cheerfully that my video encoding is done, one short sentence" | say

-> Prüft alle 5s; sobald ffmpeg beendet ist, verkündet der Mac die Neuigkeit.

Fass alle 30 Minuten laut zusammen, was du gerade ausgeliefert hast.

$while sleep 1800; do git log --since="30 min ago" --oneline | apfel "summarize my last 30 minutes of work in one cheerful sentence" | say; done

-> Halbstündliches Auto-Standup, vorgelesen, während du weitercodest.

Warne alle 15 Minuten laut, wenn der Akku unter 20 Prozent fällt.

$while sleep 900; do P=$(pmset -g batt | grep -oE "[0-9]+%" | head -1 | tr -d %); [ "$P" -lt 20 ] && apfel "battery just dropped to $P percent, write one short sentence that is friendly but super urgent telling me to plug in NOW" | say; done

-> Still, bis der Akku absackt; dann ruft der Mac eine freundliche, aber dringende Warnung laut aus.

Beobachte eine URL, bis sie 2xx liefert, und feiere dann das Deployment laut.

$until curl -sf https://staging.example.com/health >/dev/null; do sleep 30; done; apfel "tell me cheerfully that my deploy is live and the URL is responding, one short sentence" | say

-> Prüft alle 30s, bis Staging läuft; der Mac sagt "Dein Deployment ist live, die URL antwortet!".

Web und Text 4

Formuliere eine lockere Zeile höflich um.

$echo "hey can u send me docs asap" | apfel "rephrase politely"

-> "Könnten Sie mir die Unterlagen bitte baldmöglichst ..."

Ruf eine URL auf und frag, was dort los ist, nur anhand der Header.

$curl -sI https://github.com | apfel "explain what happens at this URL in one sentence, based on the HTTP headers"

-> GitHub liefert eine HTML-Seite mit strengen Caching- und Security-Headern.

Hacker News von heute, in einem Satz zusammengefasst und laut vorgelesen.

$curl -s https://news.ycombinator.com | grep titleline | sed "s/<[^>]*>//g" | apfel "summarize hacker news today in one cheerful sentence" | say

-> Der Mac liest die Top-Storys des Tages in einer knappen Zusammenfassung vor.

Erklär einen JSON-Blob in verständlicher Sprache.

$echo '{"name":"alice","plan":"pro","credits":42}' | apfel "explain this JSON in one sentence"

-> Eine Nutzerin namens Alice im Pro-Plan mit 42 Credits.

Schnell nachgefragt 8

Rechnen, ohne einen Taschenrechner zu öffnen.

$apfel "what is 15% tip on 87.50, just the number"

-> 13.13

Eine Regex erzeugen, ohne das Terminal zu verlassen.

$apfel "regex for a valid email address, just the regex"

-> ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Frag nach dem bash-One-Liner, den du vergessen hast.

$apfel "give me one find command that lists files larger than 100MB, just the bash command"

-> find / -type f -size +100M

Lass dir einen kryptischen Befehl erklären, statt zu raten.

$apfel "explain the command tar -xzvf file.tar.gz in one sentence"

-> Entpackt einen gzip-komprimierten Tarball ins aktuelle Verzeichnis.

Den genauen git-Befehl vergessen? Einfach fragen.

$apfel "git command to uncommit but not unedit my last commit, just the command"

-> git reset --soft HEAD~1

Entschlüssle eine fremde Regex in einem Satz.

$apfel "explain this regex in one sentence: ^\d{3}-\d{4}$"

-> Passt auf eine 3-stellige Vorwahl, einen Bindestrich und 4 Ziffern - ein US-Telefonformat.

Wandle eine lockere Datumsangabe in ISO 8601 um.

$apfel "convert 'Sat Apr 27 2026 11:30' to ISO 8601 (YYYY-MM-DDTHH:MM:SS), reply only with the converted string"

-> 2026-04-27T11:30:00+00:00

Fass eine ganze Datei in 3 Stichpunkten zusammen.

$apfel -f README.md "summarize in 3 bullets"

-> 3 Stichpunkte zu Umfang, Installation, Nutzung.

OpenAI-kompatibel.

Eine URL ändern. Code behalten.

Drop-in-Ersatz

apfel spricht die OpenAI-API. Jede Client-Library, jedes Framework, jedes Tool, das mit OpenAI redet, kann stattdessen mit der KI deines Macs reden. Ändere einfach die Base-URL.

  • ✓ POST /v1/chat/completions
  • ✓ POST /v1/responses (Responses API)
  • ✓ Streaming (SSE)
  • ✓ Tool Calling / Function Calling
  • ✓ GET /v1/models
  • ✓ response_format: json_object, json_schema
  • ✓ image_url-Parts als Data-URLs (macOS 27)
  • ✓ temperature, max_tokens, seed
  • ✓ CORS für Browser-Clients
Python
from openai import OpenAI

# Just change the base_url. That's it.
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="unused"  # no auth needed
)

resp = client.chat.completions.create(
    model="apple-foundationmodel",
    messages=[{
        "role": "user",
        "content": "What is 1+1?"
    }],
)
print(resp.choices[0].message.content)

Dasselbe Modell wie Apples fm. Andere Aufgabe.

macOS 27 bringt fm mit, Apples eigenes Kommandozeilen-Frontend für das On-Device-Modell. Hier trennen sich die Wege.

 apfelApple fm
Läuft aufmacOS 26 und 27, ein Binarynur macOS 27
Installationbrew install apfelSchon da (einmal sudo fm license)
OpenAI-Clients funktionieren unverändertJa: standardmäßig JSON, usage, max_tokens wird beachtet, Fehler werden gemapptStreamt, solange man es nicht abschaltet, ignoriert max_tokens, 500 bei Guardrails
Tool Calling und MCPNative Tool Calls, lokale und Remote-MCP-ServerNicht vorhanden (tools lässt Template-Tokens in die Antwort durchsickern)
Scripting--code, -o json, 9 Exit-Codes, --count-tokens --strictReiner Text, Exit 0 oder 1
Dateien als EingabeText, PDF, Bilder: OCR-Text auf beiden Systemen, unter macOS 27 zusätzlich das Bild selbst ans ModellBilder ans Modell, plus eingebaute OCR- und Barcode-Tools
Dauerhafte Chat-SessionsNeinBenannte Transkripte, --resume
GeschwindigkeitGleiches Modell auf demselben Mac, gleiches Kontextfenster (4.096 Tokens auf diesem M2, 8.192 auf M3 und neuer), identische Token-Zahlen. Einzelner Prompt: 0,35 s vs. 0,30 s.

Eine kurze Geschichte. apfel war zuerst da: erster Commit und v0.1.0 am 24. März 2026, erstes GitHub-Release am 31. März 2026, im April auf der Startseite von Hacker News. Apple kündigte fm am 8. Juni 2026 auf der WWDC an und lieferte es am 14. September 2026 mit macOS 27 aus. Beide steuern dasselbe On-Device-Modell über dasselbe FoundationModels-Framework an; apfel ist das Open-Source-Tool und das, das auch unter macOS 26 läuft.

Jede Zeile wurde am 05.10.2026 unter macOS 27.0.1 (Apple M2, 24 GB) gemessen und wird für jedes apfel-Release neu gemessen. Die vollständige Seite enthält die Server-Tests, die Vergleichstabelle der Token-Zahlen und jeden Befehl zum Nachmachen.

Beliebt auf GitHub.

Von null auf 6,610 Sterne, Tendenz steigend.

6,610
GitHub-Sterne
251 Forks
2450 Tests
v1.18.0 veröffentlicht

Starred by engineers from Apple, Google, VMware, NVIDIA, and PlayStation.

Stern auf GitHub geben
0 1,000 2,000 3,000 4,000 5,000 6,000 7,000 8,000 5,012 APR 28 6,016 JUL 10 6,610 NOW Mar 24 Apr 3 · HN front page Nov 16

Stand:

Leg los.

Keine Modell-Downloads. Keine Anmeldung. Keine API-Keys. Nur das hier.

Homebrew

macOS 26+ mit Apple Intelligence
$ brew install apfel
$ apfel "Hello, Mac"

Aus dem Quellcode bauen

benötigt CLT + macOS-27-SDK (läuft auf 26 und 27)
$ git clone https://github.com/Arthur-Ficial/apfel.git
$ cd apfel && make install

Der apfel-Baum.

Eine wachsende Familie nativer macOS-Tools auf Basis von apfel - und Schwesterprojekte, die weitere Apple-Frameworks ins Terminal bringen.

apfel-chat - privater KI-Chat für macOS

apfel-chat

macOS-Chat-Client für mehrere Unterhaltungen. Streaming-Markdown, Spracheingabe und -ausgabe, Bildanalyse - komplett privat, keine API-Keys, keine Cloud.

SwiftUI Produktionsreif
apfelpad - Formel-Notizblock mit On-Device-KI

apfelpad

Ein Formel-Notizblock zum Denken. Tipp =apfel("summarize this") in dein Markdown und sieh zu, wie die Antwort inline streamt. Wie =SUMME, nur für Sprache.

SwiftUI Neu
apfel-quick - Sofort-KI-Overlay für macOS

apfel-quick

Sofort-KI-Overlay. Drück überall Ctrl+Space, tipp eine Frage, und die Antwort streamt in deine Zwischenablage. Kein WLAN, kein Account, keine Rechnung.

SwiftUI Neu
Screenshot von apfel-gui

apfel-gui

Native Debug-GUI für macOS in SwiftUI. Chatte mit Apple Intelligence, inspiziere Requests und Responses, Logs, Speech-to-Text, Text-to-Speech - alles auf dem Gerät.

SwiftUI
apfel-clip - KI-Aktionen für die Zwischenablage

apfel-clip

KI-Aktionen für die Zwischenablage, direkt aus der Menüleiste. Drück cmd+shift+V auf einem beliebigen Text - Grammatik korrigieren, übersetzen, Code erklären, zusammenfassen. Komplett auf dem Gerät, keine API-Keys.

SwiftUI Produktionsreif
apfel-mcp - MCP-Server für apfel

apfel-mcp

Gib apfel das Web und deine Dateien. Vier kleine MCP-Tools - url-fetch, ddg-search, search-and-fetch und ein schreibgeschützter Datei-Reader - jedes zugeschnitten auf apfels kleines Kontextfenster (4.096 Tokens auf den meisten Macs, 8.192 auf M3 und neuer mit macOS 27).

Python Neu
apfel-run - dauerhafte MCP-Registry

apfel-run

Winziger UNIX-Wrapper, der apfel eine dauerhafte MCP-Registry gibt. MCP-Server per Name aus einer einfachen Textdatei aktivieren und deaktivieren. Übersteht Neustarts, keine GUI, kein Daemon.

Shell Neu
apfel-server-kit - Swift-Package für Tools im Ökosystem

apfel-server-kit

Gemeinsames Swift-Package, auf dem das Ökosystem läuft. Einen lokalen apfel --serve-Prozess finden, starten und von ihm streamen. Das Rückgrat, mit dem jede SwiftUI-App von apfel spricht.

Swift Neu
auge - Apples Vision-Framework im Terminal

auge

Schwesterprojekt. apfel kann Sprache, auge kann Sehen. Eine CLI für OCR, Bildklassifizierung, Barcodes und Gesichtserkennung - 100 % auf dem Gerät über Apples Vision-Framework. Keine API-Keys, keine Cloud.

Swift Schwesterprojekt
translate - Apples Translation-Framework im Terminal

translate

Schwesterprojekt. UNIX-Filter plus Drop-in-HTTP-Server für DeepL, LibreTranslate und Google v2 - angetrieben von Apples On-Device-Translation-Framework. 100 % auf dem Gerät, hart durchgesetzt von NetworkGuard. Keine API-Keys, keine Cloud.

Swift Schwesterprojekt

Häufig gefragt.

Fragen gesammelt auf Hacker News und Reddit.

Welche macOS-Version brauche ich?
macOS 26 (Tahoe) oder neuer. Das FoundationModels-Framework gibt es erst ab Tahoe. Unter Sequoia oder älter funktioniert es nicht. Voraussetzung ist Apple Silicon (M1 oder neuer).
Greift apfel auf meine persönlichen Daten zu?
Nein. Das FoundationModels-Framework hat keinerlei Zugriff auf Kontakte, E-Mails, Kalender, Fotos oder den Semantic Index. Diese sind Apples eigenen Funktionen vorbehalten.
Verlassen irgendwelche Daten meinen Mac?
Nein. Zwei Ebenen schützen deine Privatsphäre.

Das Modell: Apples FoundationModels-Framework funktioniert ohne Internetverbindung und läuft komplett auf der Neural Engine. Deine Prompts und Antworten verlassen nie das Gerät. Nutzerdaten werden nie fürs Training verwendet.

Das Tool: apfel sorgt dafür, dass es so bleibt. Keine Analytics, keine Telemetrie, kein Tracking, keine automatischen Update-Checks, kein Crash-Reporting, kein Nach-Hause-Telefonieren. Open Source und überprüfbar.
Wie groß ist das Kontextfenster?
4.096 Tokens (~3.000 Wörter) für Eingabe und Ausgabe zusammen, unter macOS 26 und auf M1/M2-Macs. Unter macOS 27 bekommen Macs mit M3-Chip oder neuer und mindestens 12 GB Apples größeres On-Device-Modell (AFM 3 Core Advanced) mit 8.192 Tokens. apfel codiert den Wert nie fest: apfel --model-info zeigt das Fenster, das dein Mac tatsächlich hat. Ideal für Shell-Skripte, Zusammenfassungen und Textumwandlungen. Nicht geeignet für lange Gespräche oder große Dokumente.
Was kann das Modell gut? Wo hat es Schwächen?
Gut bei: Shell-Skripting, Textumwandlung, Klassifizierung, kurzen Zusammenfassungen, JSON-Umstrukturierung, Übersetzung.

Begrenzt bei: Mathe, Faktenwissen, langen Gesprächen, komplexer Codegenerierung.

Das Modell verweigert lieber, als zu halluzinieren. Eine bewusste Designentscheidung von Apple.
Ist der Server-Modus sicher?
Standardmäßig aus. Wenn aktiviert: Bearer-Token-Authentifizierung (--token), Origin-Prüfung, Log-Endpunkte nur im Debug-Modus. Details in server-security.md.
Muss ich Apple Intelligence aktivieren?
Ja. Systemeinstellungen > Apple Intelligence & Siri > aktivieren. Dadurch wird das Modell geladen. Siri musst du nicht benutzen, nur aktivieren. Apples Einrichtungsanleitung.
Wie aktualisiere ich apfel?
apfel --update. Erkennt die Installationsmethode, sucht nach einer neueren Version und fragt vor dem Upgrade nach. Manuell: brew upgrade apfel oder git pull && make install.
Welches Modell steckt dahinter?
Apples eigenes AFM (Apple Foundation Model), rund 3 Milliarden Parameter mit gemischter 2-Bit- und 4-Bit-Quantisierung. Nicht OpenAI. Kommt mit macOS Tahoe und läuft komplett auf dem Gerät, auf der Neural Engine.
Was unterscheidet apfel von Ollama oder LM Studio?
Kein LLM-Download, sofort startklar, kein Setup. apfel nutzt das Modell, das schon auf deinem Mac ist. Ollama und LM Studio bieten mehr Modelle und größere Kontextfenster, brauchen aber separate Downloads und Konfiguration. Verschiedene Tools für verschiedene Zwecke.
Unterstützt apfel MCP und Tool Calling?
Ja. MCP ist nativ eingebaut. Übergib --mcp <server>, um Tools anzubinden. Anleitung zu Tool Calling.
Was unterscheidet apfel von Apples eigener fm-CLI unter macOS 27?
Gleiches Modell, andere Aufgabe. macOS 27 bringt fm mit, Apples Kommandozeilen-Frontend für dasselbe On-Device-Modell. apfel ergänzt den OpenAI-kompatiblen Server mit Tool Calling, MCP, JSON-Schema-Ausgabe, Bildeingabe als Data-URLs, ehrlichen Exit-Codes und Unterstützung für macOS 26. Direkt nebeneinander gemessen: apfel vs fm.
Hat apfel Telemetrie oder telefoniert es nach Hause?
Weder noch. apfel kontaktiert nie im Hintergrund einen Server. Der einzige Netzwerkaufruf passiert, wenn du ausdrücklich apfel --update ausführst; dabei wird bei Homebrew nach einer neueren Version gesucht. Open Source und überprüfbar.
Wer steckt dahinter?
apfel stammt von Franz Enzenhofer (Systemdenker, Autor, Entwickler seit C64-Zeiten, KI-Mechaniker) / franze auf HN / Gründer von Full Stack Optimization und franzai.com.

Mitgepflegt von Arthur Ficial, einer OpenClaw-Instanz, die auf Anthropics Claude Opus läuft. Zum großen Teil mit Claude Code und Codex entwickelt. Immer im Modus High Thinking / High Effort.

Gestartet: 24. März 2026.
Wie wird getestet?
334 Unit-Tests + 216 Integrationstests (End-to-End, Kompatibilität mit OpenAI-Clients, Validierung gegen die OpenAPI-Spezifikation, Sicherheit, Performance). Insgesamt 550 Tests, Stand 12. April 2026.
Wie ist apfel entstanden?
apfel begann als Versuch, OpenClaw in einem extrem tokensparenden Modus auf Apple Intelligence laufen zu lassen. Das scheiterte am 4K-Kontextfenster. Aber es zeigte sich: Ein lokales, schnelles, skriptbares, immer verfügbares LLM direkt auf dem Gerät, ohne Konfiguration und mit Privatsphäre an erster Stelle, ist unglaublich genial, leistungsstark, unterhaltsam und spannend.