Wenn du mit einem leeren Projekt startest, legst du zuerst die Sprachbasis fest: Du wählst aus, welche Sprachen deine App unterstützen soll. Diese Auswahl ist nicht endgültig. Du kannst sie jederzeit anpassen und Sprachen später hinzufügen oder entfernen, je nachdem, wie sich dein Projekt entwickelt.

Danach definierst du die Standardsprache. Das ist deine Ausgangssprache, in der du Inhalte pflegst und von der aus Übersetzungen abgeleitet werden. BetterLocale Code verwendet diese Standardsprache als Referenz, um neue Einträge sauber anzulegen, fehlende Werte zuverlässig zu erkennen und Übersetzungen gezielt zu erzeugen, statt pauschal alles zu überschreiben. Das ist besonders bei laufender Weiterentwicklung hilfreich, weil du damit eine eindeutige Quelle für Formulierungen und Inhalt behältst.

Wenn du nicht bei Null anfängst, kannst du bestehende Sprachdateien importieren. Dabei lassen sich .strings, .xcstrings sowie komplette .lproj-Strukturen einlesen. Vorhandene Keys und Werte werden übernommen, sodass du nicht erneut mit einer leeren Liste startest. Anschließend kannst du Sprachen ergänzen, fehlende Übersetzungen nachziehen und Inkonsistenzen bereinigen, ohne Dateien mühsam in Xcode oder im Texteditor zusammensuchen zu müssen.

So kommst du schnell zu einem sauberen, konsistenten Sprach-Setup, egal ob du neu startest oder ein bestehendes Projekt aufräumen und weiterführen willst.

Als nächstes legst du deine Keys an und verwaltest sie zentral im Projekt. Bestehende Keys kannst du jederzeit bearbeiten, umbenennen oder auch löschen, je nachdem, was gerade ansteht.

Wenn du einen neuen Key erstellst, legt BetterLocale Code ihn automatisch in allen aktuell aktivierten Sprachen an. Die Werte sind zunächst leer, damit du nur dort Übersetzungen einträgst, wo du sie wirklich brauchst. Dadurch bleibt die Struktur über alle Sprachen hinweg von Anfang an sauber und identisch und du läufst später nicht in das Problem, dass ein Key in einer Sprache fehlt.

Du kannst sowohl den Key-Namen als auch die Werte pro Sprache ändern. Die Anpassungen werden direkt in die Projektstruktur übernommen, ohne dass du mehrere Dateien oder Ordner manuell pflegen musst. Wenn du einen Key löschst, wird er konsequent in allen Sprachen entfernt, damit keine veralteten Einträge im Projekt zurückbleiben.

Sobald deine Keys und Texte vollständig in BetterLocale Code stehen, kannst du Übersetzungen direkt über einen KI-Dienst erstellen lassen. Aktuell unterstützt die App OpenAI, DeepL, Gemini, Claude und Perplexity. Du kannst wahlweise alles übersetzen oder nur fehlende bzw. geänderte Einträge, damit du weder Zeit noch Kosten für bereits fertige Texte investierst.

Damit das klappt, brauchst du beim jeweiligen Anbieter ein Konto und einen API-Token. Diesen Token hinterlegst du in BetterLocale Code in den Einstellungen. Er wird ausschließlich lokal auf deinem Mac gespeichert und nicht an uns übertragen. Vor der ersten Nutzung lohnt sich ein Verbindungstest, damit du sofort siehst, ob Token, Modell-Auswahl und Zugriff passen. Scheitert der Test, liegt es in der Praxis meist an einem ungültigen Token, fehlenden Berechtigungen, einem falschen Endpunkt oder daran, dass beim Anbieter noch keine Zahlungsmethode hinterlegt ist.

Die Kosten unterscheiden sich je nach Anbieter und Modell teils stark, sind aber in vielen Fällen deutlich günstiger als klassische Übersetzungsbüros, besonders wenn du häufig Updates übersetzen musst. Manche Anbieter rechnen pro Zeichen oder „Units“ ab, andere über Tokens. Bei ChatGPT wird Text dafür in Token-Einheiten zerlegt, wobei je nach Sprache und Wortlänge schon wenige Wörter mehrere Tokens sein können. Zusätzlich werden Eingabe und Ausgabe getrennt berechnet: Du zahlst also sowohl für deinen Prompt inklusive Kontext als auch für die erzeugte Übersetzung. Praktisch heißt das: Mehr Kontext und längere Antworten erhöhen den Verbrauch.

Wenn du die Kosten klein halten willst, helfen ein paar einfache Punkte: Übersetze nur das, was neu oder leer ist, gib nur den Kontext mit, der wirklich nötig ist, und starte zum Test erst mit wenigen Einträgen, bevor du große Textblöcke durchlaufen lässt.

KI-API-Schlüssel erstellen und in der App eintragen

Damit du in der App automatisch übersetzen und den KI-Chat nutzen kannst, brauchst du einen API-Schlüssel von einem KI-Anbieter.
Du kannst dir das wie einen persönlichen Zugangscode vorstellen: Der Anbieter erkennt damit, dass die Anfrage von dir kommt, und rechnet die Nutzung über dein Konto ab.

Aktuell unterstützt die App: OpenAI, Claude, DeepL, Gemini und PerplexityAI.

Die Einrichtung ist bei allen Anbietern sehr ähnlich.

Was du vorher wissen solltest
• PI-Schlüssel = Zugangscode: Den gibst du in der App ein, damit sie in deinem Namen beim Anbieter anfragen darf.
• Kosten laufen über dich: Die App stellt die Anfragen, aber die Abrechnung passiert direkt bei deinem Anbieter-Konto.
• Billing ist oft Pflicht: Viele Anbieter lassen API-Anfragen erst zu, wenn eine Zahlungsart hinterlegt ist. Ohne Billing kommt sonst schnell eine Fehlermeldung oder du bleibst in sehr kleinen Limits hängen.

Schnellstart: in 5 Schritten zum fertigen Setup

1) Account anlegen oder einloggen

Geh zur Website deines Anbieters und melde dich an.

2) API-Key erstellen

Suche nach einem Bereich wie API, Developer, Dashboard oder API Keys und erstelle dort einen neuen Schlüssel.

3) Key kopieren und sicher speichern

Kopiere den Schlüssel direkt und speichere ihn sicher, am besten im Passwortmanager.
Wichtig: Viele Anbieter zeigen den Key nur einmal vollständig an.

4) Billing/Zahlung aktivieren

Hinterlege eine Zahlungsmethode oder aktiviere Billing. Sonst funktionieren API-Anfragen oft gar nicht oder nur eingeschränkt.

5) Key in der App eintragen

Öffne die App → Einstellungen → KI-Anbieter → Anbieter auswählen → API-Schlüssel einfügen → Speichern

Danach kannst du Übersetzungen starten und den KI-Chat nutzen.

Anbieter-Anleitungen (mit Direktlinks)

OpenAI (ChatGPT / OpenAI API)

1. OpenAI Dashboard öffnen:
https://platform.openai.com/
2. API Key erstellen:
https://platform.openai.com/settings/organization/api-keys
3. Billing/Zahlungsmethode einrichten:
https://platform.openai.com/settings/organization/billing/payment-methods

Tipp: Den Key siehst du oft nur einmal komplett, danach nur noch teilweise.

Claude (Anthropic)

1. Claude Console öffnen:
https://platform.claude.com/
2. In der Console zu Account Settings gehen und dort den API Key erstellen.
3. Billing in der Console aktivieren, damit du die API nutzen kannst.

Hinweis: Früher lief das teils über console.anthropic.com, inzwischen wird auf platform.claude.com umgestellt bzw. weitergeleitet.

Gemini (Google)

1. Google AI Studio öffnen (API Keys):
https://aistudio.google.com/app/apikey
2. Falls du noch kein Projekt hast: AI Studio legt oft automatisch ein Standard-Projekt an. Sonst wählst/importierst du ein Google-Cloud-Projekt.
3. API Key erstellen und kopieren.

Dokumentation zu Gemini API Keys:
https://ai.google.dev/gemini-api/docs/api-key

PerplexityAI

1. Account/Settings öffnen:
https://www.perplexity.ai/account
2. In den Settings den </> API-Tab öffnen und dort einen Key generieren („Generate API Key“).
3. Alternativ (je nach UI) das API Portal nutzen:
https://www.perplexity.ai/account/api

Optional: API Groups sind hilfreich, wenn du Keys getrennt halten willst (z. B. „Dev“ und „Prod“).

DeepL

1. DeepL öffnen und einloggen:
https://www.deepl.com/
2. Account → Tab API Keys & Limits öffnen.
3. Create key klicken, Namen vergeben, bestätigen und Key kopieren.
DeepL Hilfeartikel:
https://support.deepl.com/hc/en-us/articles/360020695820-API-key-for-DeepL-API

Hinweise zu Kosten und Datenschutz
• Die Nutzung der KI-API ist meist kostenpflichtig und wird direkt über dein Konto beim Anbieter abgerechnet. Üblicherweise nach Textmenge (Tokens).
• Die App sendet nur die Inhalte, die du auswählst (z. B. die zu übersetzenden Texte) plus deine Anweisung an den Anbieter.
• Dein API-Key wird nur lokal auf deinem Mac im Schlüsselbund (Keychain) gespeichert und nicht an Dritte weitergegeben.

Sicherheit

Behandle den API-Key wie ein Passwort:
• Nicht teilen und nicht in öffentliche Repos kopieren.
• Wenn du glaubst, der Key ist kompromittiert: im Anbieter-Dashboard deaktivieren und einen neuen erstellen.
• Wenn du mehrere Geräte oder Projekte nutzt: lieber einen eigenen Key pro Gerät/Projekt, damit du gezielt sperren kannst, ohne alles lahmzulegen.

BetterLocale Code bietet dir zwei Wege, um Texte zu übersetzen. In beiden Fällen arbeitest du mit Kontext, damit die Übersetzung nicht „blind“ entsteht, sondern zu Ton, Zielgruppe und dem Stil deiner App passt.

Wenn du ohnehin ein externes KI-Tool nutzt oder die Ergebnisse lieber selbst prüfst, nimmst du die Vorlagen-Variante. BetterLocale Code erzeugt aus den ausgewählten Einträgen eine saubere Übersetzungsanfrage im Format “Key” = “Value”;. Dazu kannst du Hinweise mitgeben, etwa gewünschter Ton (neutral, locker, technisch), Zielgruppe (Entwickler, Endnutzer), Produktname, UI-Stil (kurz, menüartig) sowie Regeln für Platzhalter. Diese Vorlage kopierst du in ein Tool deiner Wahl, zum Beispiel ChatGPT, Gemini oder DeepL. Anschließend fügst du die übersetzten Zeilen wieder in BetterLocale Code ein. Die App erkennt die Keys, ordnet die Werte korrekt zu und aktualisiert die passenden Einträge automatisch. Du musst nichts manuell zuordnen und nicht zwischen Dateien hin und her springen. Das ist ideal, wenn du maximale Kontrolle willst und ohne API-Account arbeiten möchtest.

Wenn du alles im gleichen Workflow halten willst, kannst du direkt in BetterLocale Code per API übersetzen. Auch hier gibst du Kontext wie Ton, Zielgruppe und optionale Zusatzhinweise vor, damit die Übersetzungen konsistent bleiben. Unterstützt werden OpenAI, DeepL, Gemini, Claude und Perplexity. Dafür brauchst du beim jeweiligen Anbieter einen API-Key, über den die Anfrage ausgeführt und abgerechnet wird. Du entscheidest außerdem, ob alle Texte übersetzt werden oder nur neue, geänderte beziehungsweise leere Einträge. Das spart Zeit, reduziert Copy-Paste und die Ergebnisse landen direkt in deinen Projektdaten, sodass du sofort weiterarbeiten kannst.

BetterLocale Code selbst berechnet keine Übersetzungskosten. Kosten entstehen ausschließlich bei deinem KI-Anbieter und hängen vom Tarif und vom übersetzten Textumfang ab. Dadurch bleibt es gut planbar, vor allem wenn du nur Änderungen statt „alles neu“ übersetzen lässt.

Bei der manuellen Übersetzung ist der Ablauf fast identisch zur API-Übersetzung, nur dass der eigentliche Übersetzungsschritt außerhalb der App stattfindet.

Sobald du „Manuell übersetzen“ startest, öffnet sich ein Dialog, in dem du den Rahmen definierst. Du kannst Kontext mitgeben, zum Beispiel gewünschte Tonalität (neutral, locker, formal), Zielgruppe, Produktbezug oder Hinweise wie „UI-Labels kurz halten“ oder „Du/Sie-Ansprache“. Danach legst du fest, welche Einträge übersetzt werden sollen: entweder alles, oder nur Felder, die leer sind bzw. neu oder geändert wirken. Damit steuerst du sehr präzise, wie viel Text wirklich rausgeht.

Nach dem Bestätigen erstellt BetterLocale Code automatisch eine fertige Übersetzungsanweisung inklusive deiner Vorgaben und einer Liste der zu übersetzenden Key-Value-Paare. Diese Anweisung wird direkt in die Zwischenablage kopiert, sodass du sie ohne Nacharbeit in ein beliebiges Tool einfügen kannst.

Anschließend öffnest du ChatGPT, DeepL, Gemini oder ein anderes Übersetzungstool, fügst die Anweisung ein und lässt übersetzen. Wichtig ist, dass das Ergebnis wieder im Format

“Key” = “Value”;

zurückkommt, also pro Zeile genau ein Eintrag. Die Keys dürfen dabei nicht verändert werden, damit BetterLocale Code die Übersetzungen eindeutig zuordnen kann.

Das komplette Ergebnis kopierst du danach in die Zwischenablage und fügst es in BetterLocale Code ein. Die App liest die Zeilen ein, gleicht sie mit deinen vorhandenen Schlüsseln ab und übernimmt die übersetzten Values in die richtigen Sprachen.

Der manuelle Weg dauert meistens etwas länger, ist dafür aber ideal, wenn du keinen kostenpflichtigen Dienst per API anbinden möchtest oder bewusst mit verschiedenen Tools arbeiten willst. Wenn beim Einfügen etwas nicht stimmt, etwa ein falsches Format, fehlende Anführungszeichen, doppelte Keys oder Zeilen, die nicht zugeordnet werden können, markiert BetterLocale Code die betroffenen Stellen als Fehler. So siehst du sofort, was korrigiert werden muss, und vermeidest, dass unbemerkt falsche Daten ins Projekt gelangen.

Bei der automatischen Übersetzung hast du in BetterLocale Code zwei Wege, je nachdem, wie breit du vorgehen möchtest. Wenn du den Übersetzungsbefehl an der Standardsprache startest, wird der Auftrag als Gesamtlauf verstanden und die App übersetzt alle ausgewählten Zielsprachen in einem Durchgang. Wenn du den Befehl dagegen direkt bei einer bestimmten Sprache ausführst, wird nur diese eine Sprache übersetzt, was sich gut eignet, wenn du einzelne Sprachen nachziehen oder gezielt prüfen willst.

Nach dem Start öffnet sich ein Dialog, in dem du der KI optional zusätzlichen Kontext mitgeben kannst, damit die Übersetzungen besser zu deinem Projekt passen. Du kannst dort zum Beispiel festlegen, ob die Formulierungen eher sachlich oder locker sein sollen, welche Zielgruppe du ansprichst und ob bestimmte Begriffe im Produktkontext gleich bleiben sollen. Zusätzlich kannst du steuern, ob nur leere Einträge übersetzt werden sollen, damit bereits vorhandene Übersetzungen nicht überschrieben werden. Sobald du den Dialog bestätigst, startet BetterLocale Code den Übersetzungsprozess und arbeitet die Einträge der Reihe nach ab, wobei die Zuordnung über die Keys erfolgt und der Fortschritt pro Sprache fortlaufend aktualisiert wird.

Wenn während der Übersetzung etwas schiefgeht, etwa durch fehlende API-Berechtigungen, eine ungültige Konfiguration, Netzwerkprobleme oder ein unerwartetes Antwortformat, bricht die App nicht einfach kommentarlos ab, sondern sammelt die Fehlermeldungen und zeigt sie dir am Ende gebündelt an. So kannst du gezielt erkennen, welche Einträge betroffen waren und was die Ursache ist, ohne den gesamten Lauf manuell nachvollziehen zu müssen.

Ob eine Sprache vollständig übersetzt ist, erkennst du daran, dass der Prozentwert der Zielsprache mit dem Prozentwert der Standardsprache übereinstimmt, weil beide dann die gleiche Abdeckung an gefüllten Werten haben. Zusätzlich siehst du links oben in der Tabelle die Anzahl der noch leeren Felder, wodurch du auf einen Blick einschätzen kannst, ob noch Lücken vorhanden sind. Du kannst den Vorgang jederzeit erneut ausführen, zum Beispiel um nach Änderungen nur die neu hinzugekommenen oder noch fehlenden Übersetzungen zu ergänzen, ohne den gesamten Bestand erneut übersetzen zu lassen.

Wenn du fertig bist, kannst du deine Lokalisierungen direkt aus BetterLocale Code zurück in dein Xcode-Projekt exportieren. So bringst du die bearbeiteten Texte wieder dorthin, wo Xcode sie erwartet, inklusive aller Sprachen, Keys und Werte.

Export als XCStrings (Strings Catalog)

Wenn du mit .xcstrings arbeitest, legst du zuerst die Standardsprache fest. Das ist die Basissprache, von der Xcode ausgeht, und sie dient als Referenz für die übrigen Übersetzungen. Anschließend exportierst du die Datei am besten genau an den ursprünglichen Speicherort in deinem Projekt. So wird die bestehende Datei ersetzt bzw. aktualisiert, und Xcode erkennt die Änderungen sofort. Das ist besonders praktisch, wenn du nur Werte ergänzt oder konsistenter gemacht hast und die Datei als zentrale Quelle im Projekt behalten willst.

Export als .strings

Wenn du lieber mit klassischen .strings-Dateien arbeitest oder ein Legacy-Projekt pflegst, kannst du deine Daten aus XCStrings in das .strings-Format konvertieren. Dabei werden die Einträge je Sprache in die bekannte Schlüssel-Wert-Struktur übertragen, die viele bestehende Build-Setups und Tools erwarten. Das ist auch hilfreich, wenn du bestimmte Workflows hast, die auf .strings basieren, oder wenn du Strings Catalogs nicht nutzen möchtest.

Export als .lproj-Ordnerstruktur

Alternativ kannst du die Lokalisierungen als separate Sprachordner exportieren, also als Struktur mit .lproj-Verzeichnissen. In jedem dieser Ordner liegen dann die passenden Sprachdateien (z. B. Localizable.strings). Diese Variante entspricht dem klassischen Xcode-Standardaufbau und eignet sich gut, wenn du dein Projekt bewusst in einer klaren Ordnerstruktur pro Sprache organisieren willst oder wenn du mehrere Dateien pro Sprache verwaltest.

Ergebnis im Projekt

Egal, welchen Exportweg du wählst: Am Ende liegen die Lokalisierungsdateien in deinem Projekt in einer Form, die Xcode direkt versteht. Damit ist die Lokalisierung technisch abgeschlossen und du kannst sie sofort testen, indem du in Simulator oder Gerät die Sprache umstellst und prüfst, ob alle Texte korrekt erscheinen.

In BetterLocale Code kannst du Feedback direkt aus der App heraus senden, ohne erst nach einer Kontaktadresse suchen oder Informationen zusammensammeln zu müssen.

Wenn du den Feedback-Befehl auswählst, öffnet BetterLocale Code deinen Standard-E-Mail-Client und erstellt eine neue Nachricht mit einer passenden Betreffzeile. So ist die Anfrage direkt korrekt zugeordnet und du kannst sofort losschreiben.

Das ist besonders praktisch, wenn du eine Frage zu einer Funktion oder einem empfohlenen Workflow hast, wenn du einen Feature-Wunsch einreichen möchtest oder wenn du einen Fehler melden willst. Gerade bei Problemen hilft es uns, wenn du kurz beschreibst, was du vorhattest, was tatsächlich passiert ist und welches Verhalten du erwartet hättest. Wenn möglich, füge einen Screenshot hinzu oder nenne, mit welchem Dateityp du gearbeitet hast (.xcstrings, .strings oder .lproj).

Wenn du einen Text in der Standardsprache änderst, ist das oft mehr als ein Tippfehler. Häufig ändert sich Bedeutung, Ton oder Kontext. Damit sind bestehende Übersetzungen in anderen Sprachen im Zweifel nicht mehr passend oder schlicht veraltet. Genau dafür gibt es in BetterLocale Code zwei saubere Wege: Du kannst Übersetzungen nach einer Änderung bewusst zurücksetzen und neu erstellen, oder du kannst denselben Standardwert gezielt in allen Sprachen übernehmen.

Änderst du einen Wert in der Standardsprache, kann es sinnvoll sein, die Übersetzungen der anderen Sprachen zu leeren, damit später nichts unbemerkt falsch bleibt. BetterLocale Code unterstützt dich dabei auf zwei Arten: Bei relevanten Änderungen erscheint ein Hinweis, der dich fragt, ob die bestehenden Übersetzungen entfernt werden sollen. Und du kannst das jederzeit auch manuell auslösen, wenn du bewusst aufräumen willst: Wechsle in der Sprachliste zur Standardsprache, markiere den betroffenen Eintrag und nutze den Befehl „Übersetzungen aller Sprachen löschen“. Dabei bleiben die Keys natürlich erhalten, nur die Werte in den anderen Sprachen werden geleert. Das ist praktisch, weil du anschließend sofort siehst, was neu übersetzt werden muss und weil alte Übersetzungen nicht stillschweigend im Projekt weiterleben.

Typische Fälle dafür sind überarbeitete UI-Formulierungen (Ton, Länge, Klarheit), fachliche Änderungen an Inhalten (z. B. Bedingungen, neue Features) oder Anpassungen an Platzhaltern und Satzstruktur, bei denen du bewusst frische Übersetzungen haben möchtest.

Manchmal willst du genau das Gegenteil: Ein Text soll absichtlich in allen Sprachen identisch sein. Das betrifft oft Inhalte, die man nicht übersetzt, zum Beispiel URLs, Marken- oder Produktnamen, Modellbezeichnungen oder technische Begriffe, die du bewusst gleich lässt. In dem Fall nutzt du „Standardwert auf alle Sprachen anwenden“. Die App übernimmt den Wert aus der Standardsprache in jede vorhandene Sprache. Das spart Zeit und sorgt dafür, dass der Inhalt überall konsistent bleibt.

Für den Alltag gibt es außerdem zwei Befehle, die beim Pflegen und Aufräumen ständig nützlich sind: „In Zwischenablage kopieren“, um Einträge je nach Kontext einzeln oder gesammelt extern weiterzuverwenden (z. B. zum Prüfen oder für ein KI-Tool), und „Key inklusive aller Werte löschen“, um einen Eintrag wirklich komplett aus dem Projekt zu entfernen, also Key und alle Sprachwerte. Das lohnt sich, wenn ein String nicht mehr verwendet wird und dein Projekt sauber bleiben soll.

Sobald Übersetzungen vorhanden sind, lohnt sich eine kurze Stichprobe. Wähle dazu in der Liste einen Eintrag aus und öffne über das Kontextmenü oder den Button „Übersetzungen bearbeiten“ den Detaildialog. Dort kannst du Übersetzungen schnell prüfen und bei Bedarf direkt korrigieren.

Im Dialog werden untereinander drei Inhalte angezeigt: die Übersetzung in der aktuell gewählten Sprache, eine Rückübersetzung in die Standardsprache sowie der Originaltext in der Standardsprache. Die Rückübersetzung ist dabei ein praktischer Plausibilitätscheck. Wenn sie inhaltlich deutlich vom Original abweicht, ist das oft ein Hinweis darauf, dass die Übersetzung zwar flüssig klingt, aber die Bedeutung nicht sauber trifft.

Damit kannst du Einträge sehr effizient „abhaken“ oder gezielt nachbessern, ohne jedes Mal große Textmengen lesen zu müssen. Gerade bei KI-Übersetzungen hilft dir dieser Dialog, die letzten Prozent Qualität herauszuholen und typische Fehler früh zu erkennen. Zusätzlich stehen im Dialog Aktionen zur Verfügung, mit denen du Texte direkt nachbearbeiten kannst.

BetterLocale Code enthält zusätzlich einen integrierten KI-Chat, der sich wie ein klassischer Chat-Assistent bedienen lässt. Du kannst direkt in der App Fragen stellen und dir beim Arbeiten helfen lassen, zum Beispiel beim Glätten von Formulierungen (App-Store-Texte, UI-Strings, Fehlermeldungen), beim Gegenlesen von Übersetzungen in Bezug auf Ton und Konsistenz, beim Vorschlagen sinnvoller Key-Namen und Strukturen oder beim Erzeugen kurzer Erklärungen und Varianten, ohne dass dir dabei der Kontext verloren geht.

Technisch nutzt der Chat dieselben KI-Schnittstellen wie die Übersetzungsfunktionen. Das bedeutet: Der Anbieter, den du in BetterLocale Code eingerichtet hast (z. B. OpenAI, DeepL, Gemini, Claude oder Perplexity), wird auch für den Chat verwendet. Du arbeitest damit in einem durchgängigen Setup mit denselben Zugangsdaten und denselben Regeln.

Die Abrechnung läuft immer über den jeweiligen Anbieter und dessen Preismodell. Bei tokenbasierter Abrechnung ist wichtig, dass meist getrennt nach Input (dein gesendeter Text) und Output (die Antwort des Modells) berechnet wird. Tokens sind dabei keine Wörter. Als grobe Faustregel kann man oft mit etwa 1 Token ≈ 4 Zeichen bzw. ungefähr 0,75 Wörtern rechnen, je nach Sprache und Text kann das aber spürbar abweichen.

Als reine Orientierung: In der OpenAI-API liegen die Preise für GPT-4.1 bei 2,00 USD pro 1 Mio. Input-Tokens und 8,00 USD pro 1 Mio. Output-Tokens, für GPT-4.1 mini bei 0,40 USD (Input) und 1,60 USD (Output). Andere Anbieter und Modelle können davon abweichen.

Wenn du die Kosten niedrig halten willst, hilft in der Praxis meist schon, im Chat eher kurz und klar zu fragen, nur den Text mitzuschicken, der wirklich geprüft werden soll (statt ganze Dateien), und für schnelle Checks ein kleineres Modell zu nutzen und nur bei heiklen Texten auf ein größeres Modell zu wechseln.

Die Funktion „Swift → KeyValue“ hilft dir dabei, bereits vorhandene Textkonmentare aus deinem Swift-Code schnell in ein sauberes Key-Value-Format zu überführen, damit du sie anschließend direkt in BetterLocale Code weiterverwenden kannst.

Wichtig dabei: Die App liest keine Swift-Dateien automatisch aus deinem Projekt. Du fügst den relevanten Swift-Code oder einzelne Ausschnitte manuell in das Eingabefeld ein. Das ist bewusst so gelöst, damit du selbst bestimmst, welche Stellen analysiert werden, und damit BetterLocale Code keinen Zugriff auf dein Projekt benötigt.

Aus dem eingefügten Text erkennt die Funktion String-Konstanten, bei denen eine feste Zuordnung zwischen einem Namen und einem String-Wert existiert. Daraus erzeugt sie Zeilen im Format „Key“ = „Value“;, die du anschließend als Basis für deine Lokalisierung nutzen kannst, zum Beispiel für .strings- oder xcstrings-Workflows. Typische Quellen sind static let-Definitionen, Konstanten in Structs oder Enums, sowie zentral gepflegte Textsammlungen in Containern wie Strings, L10n, Text, Copy oder ähnlichen.

Am zuverlässigsten funktioniert das, wenn Key und Value eindeutig zusammengehören, etwa bei static let title = „Einstellungen“. Bei frei im Code verteilten String-Literalen wie Text(„Einstellungen“) oder label.text = „Einstellungen“fehlt dagegen meist ein stabiler Key, der später für die Lokalisierung gebraucht wird. Dann müsste man den Key erraten oder den Kontext interpretieren, was schnell zu doppelten oder widersprüchlichen Keys, schlechten Key-Namen oder einer inkonsistenten Struktur führt.

Wenn du verlässliche Ergebnisse möchtest, ist es am besten, deine Texte vorher als Konstanten oder klar benannte Attribute zu definieren, zum Beispiel static let settingsTitle = „…“, static let errorNetwork = „…“ oder static let buttonSave = „…“. So kann BetterLocale Code die Konstantennamen direkt als Keys übernehmen, die String-Werte sauber als Values ausgeben und dir eine konsistente Key-Struktur liefern, die später leicht zu pflegen ist.

Falls du aktuell viele direkte String-Literale im Code hast, lohnt sich als Zwischenschritt, die wichtigsten Texte zuerst in eine zentrale L10n- oder Strings-Struktur zu ziehen und danach „Swift → KeyValue“ zu nutzen, um daraus die Lokalisierungsbasis zu erzeugen.

Die Funktion „KeyValue to Code“ erzeugt aus vorhandenen Key-Value-Einträgen wieder Swift-Code in einer sauberen Konstanten-Struktur. Das ist praktisch, wenn ein Projekt historisch mit hardcodierten Texten im Code gestartet ist, zum Beispiel static let ok = „OK“ oder static let loginTitle = „Anmelden“.

Wenn du später auf eine echte Lokalisierung umstellst, möchtest du diese Struktur im Code oft behalten, aber ohne feste Texte. Stattdessen soll der Code nur noch auf Lokalisierungs-Keys verweisen. Genau hier setzt „KeyValue to Code“ an: BetterLocale Code generiert dir Properties neu und ersetzt die bisherigen String-Literale durch die passenden Keys, die du in deinen .strings oder .xcstrings pflegst.

Wichtig: Die App liest dafür keine Swift-Dateien automatisch aus deinem Projekt. Du fügst den relevanten Code oder eine Key-Liste manuell in das Eingabefeld ein. Das ist bewusst so gelöst, damit die Funktion schnell bleibt, du die volle Kontrolle behältst und keine Projektanalyse nötig ist.

Typische Einsätze sind die Migration von hardcodierten Strings zu key-basierter Lokalisierung ohne viel Handarbeit, das Aufräumen und Vereinheitlichen gewachsener Konstanten-Dateien, sowie Refactorings, bei denen du dir eine klare „Strings“-API aufbaust, zum Beispiel nach Screens oder Features gruppiert. Nebenbei wird es auch für Code-Reviews angenehmer, weil im Code keine UI-Texte mehr stehen, sondern stabile Keys, während sich Inhalte nur noch in den Sprachdateien ändern.

Unterm Strich bekommst du eine robuste, wartbare Struktur: Dein Swift-Code bleibt sauber und stabil, und die eigentlichen Texte liegen zentral in den Lokalisierungsdateien, wo du sie übersetzen, prüfen und versionieren kannst.