From ac6c48e1a68e13f50a8a0baaa459c5357b5c47cc Mon Sep 17 00:00:00 2001
From: Ryan Miller <aerilym@pm.me>
Date: Tue, 6 Jan 2026 14:27:42 +1100
Subject: [PATCH] feat: optimise generation and add validation and
 notificaitons

optimised string generation with new shared parsing steps and parallelised downloads

added new failure notifications with discord webhooks

added validation for string rules from session desktop
---
 .../workflows/check_for_crowdin_updates.yml   | 107 ++-
 .github/workflows/notify_failure.yml          |  34 +
 .../workflows/test_failure_notification.yml   |  11 +
 .gitignore                                    |   1 +
 README.md                                     |  57 ++
 crowdin/download_translations_from_crowdin.py | 238 ++++---
 crowdin/generate_android_strings.py           | 218 ++++---
 crowdin/generate_desktop_strings.py           | 261 ++++----
 crowdin/generate_ios_strings.py               | 291 ++++-----
 crowdin/generate_shared.py                    |  89 ++-
 crowdin/parse_xliff.py                        | 607 ++++++++++++++++++
 11 files changed, 1390 insertions(+), 524 deletions(-)
 create mode 100644 .github/workflows/notify_failure.yml
 create mode 100644 .github/workflows/test_failure_notification.yml
 create mode 100644 crowdin/parse_xliff.py

diff --git a/.github/workflows/check_for_crowdin_updates.yml b/.github/workflows/check_for_crowdin_updates.yml
index 2ee495b..42a6430 100644
--- a/.github/workflows/check_for_crowdin_updates.yml
+++ b/.github/workflows/check_for_crowdin_updates.yml
@@ -14,6 +14,11 @@ on:
         required: true
         type: boolean
         default: true
+      SKIP_VALIDATION_ERRORS:
+        description: 'Continue even if string validation fails'
+        required: false
+        type: boolean
+        default: false
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -77,10 +82,56 @@ jobs:
           if-no-files-found: warn
           retention-days: 7
 
+  parse_translations:
+    name: Parse and validate translations
+    runs-on: ubuntu-latest
+    needs: [fetch_translations]
+    steps:
+      - name: Checkout Repo Content
+        uses: actions/checkout@v4
+        with:
+          path: 'scripts'
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: 3.12
+          cache: 'pip'
+
+      - name: Install Dependencies
+        shell: bash
+        run: |
+          pip install -r ${{ github.workspace }}/scripts/crowdin/requirements.txt
+
+      - name: Download raw translations
+        uses: actions/download-artifact@v4
+        with:
+          name: session-download
+          path: "${{ github.workspace }}/raw_translations"
+
+      - name: Parse and validate XLIFF files
+        run: |
+          python "${{ github.workspace }}/scripts/crowdin/parse_xliff.py" \
+            "${{ github.workspace }}/raw_translations" \
+            "${{ github.workspace }}/parsed_translations.json" \
+            ${{ inputs.SKIP_VALIDATION_ERRORS != true && '--error-on-validation-failure' || '' }} \
+            --validation-report "${{ github.workspace }}/validation_report.json"
+
+      - name: Upload parsed translations
+        uses: actions/upload-artifact@v4
+        with:
+          name: session-parsed
+          path: |
+            ${{ github.workspace }}/parsed_translations.json
+            ${{ github.workspace }}/validation_report.json
+          overwrite: true
+          if-no-files-found: error
+          retention-days: 7
+
   build_ios:
     name: Build iOS strings
     runs-on: ubuntu-latest
-    needs: [fetch_translations]
+    needs: [parse_translations]
     steps:
       - name: Checkout Repo Content
         uses: actions/checkout@v4
@@ -93,10 +144,16 @@ jobs:
       - name: Setup shared
         uses: ./scripts/actions/setup_shared
 
+      - name: Download parsed translations
+        uses: actions/download-artifact@v4
+        with:
+          name: session-parsed
+          path: "${{ github.workspace }}"
+
       - name: Prepare iOS Strings
         run: |
           python "${{ github.workspace }}/scripts/crowdin/generate_ios_strings.py" \
-            "${{ github.workspace }}/raw_translations" \
+            "${{ github.workspace }}/parsed_translations.json" \
             "${{ github.workspace }}/ios/Session/Meta/Translations" \
             "${{ github.workspace }}/ios/SessionUIKit/Style Guide/Constants.swift"
       - name: Upload iOS artefacts
@@ -114,7 +171,7 @@ jobs:
 
   build_desktop:
     name: Build Desktop strings
-    needs: [fetch_translations]
+    needs: [parse_translations]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repo Content
@@ -128,11 +185,16 @@ jobs:
       - name: Checkout Desktop
         uses: ./scripts/actions/checkout_desktop
 
+      - name: Download parsed translations
+        uses: actions/download-artifact@v4
+        with:
+          name: session-parsed
+          path: "${{ github.workspace }}"
 
       - name: Prepare Desktop Strings
         run: |
           python "${{ github.workspace }}/scripts/crowdin/generate_desktop_strings.py" \
-            "${{ github.workspace }}/raw_translations" \
+            "${{ github.workspace }}/parsed_translations.json" \
             "${{ github.workspace }}/desktop/_locales" \
             "${{ github.workspace }}/desktop/ts/localization/constants.ts"
 
@@ -152,7 +214,7 @@ jobs:
 
   build_qa:
     name: Build QA strings
-    needs: [fetch_translations]
+    needs: [parse_translations]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repo Content
@@ -166,10 +228,16 @@ jobs:
       - name: Checkout Desktop
         uses: ./scripts/actions/checkout_desktop
 
+      - name: Download parsed translations
+        uses: actions/download-artifact@v4
+        with:
+          name: session-parsed
+          path: "${{ github.workspace }}"
+
       - name: Export QA Strings (json)
         run: |
           python "${{ github.workspace }}/scripts/crowdin/generate_desktop_strings.py" --qa_build \
-            "${{ github.workspace }}/raw_translations" \
+            "${{ github.workspace }}/parsed_translations.json" \
             "${{ github.workspace }}/desktop/_locales" \
             "${{ github.workspace }}/desktop/ts/localization/constants.ts"
       - name: Prepare QA strings (ts)
@@ -191,7 +259,7 @@ jobs:
   build_android:
     name: Build Android strings
     runs-on: ubuntu-latest
-    needs: [fetch_translations]
+    needs: [parse_translations]
 
     steps:
       - name: Checkout Repo Content
@@ -210,16 +278,24 @@ jobs:
         with:
           distribution: 'temurin'
           java-version: 17
-          cache: gradle
 
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4
+        with:
+          gradle-version: wrapper
+          cache-read-only: false
+
+      - name: Download parsed translations
+        uses: actions/download-artifact@v4
+        with:
+          name: session-parsed
+          path: "${{ github.workspace }}"
 
       - name: Prepare Android Strings
         run: |
           rm -rf ${{ github.workspace }}/android/app/src/main/res/values*/strings.xml
           python "${{ github.workspace }}/scripts/crowdin/generate_android_strings.py" \
-            "${{ github.workspace }}/raw_translations" \
+            "${{ github.workspace }}/parsed_translations.json" \
             "${{ github.workspace }}/android/app/src/main/res" \
             "${{ github.workspace }}/android/app/src/main/java/org/session/libsession/utilities/NonTranslatableStringConstants.kt"
       - name: Upload Android artefacts
@@ -234,7 +310,16 @@ jobs:
           retention-days: 7
 
       - name: Validate strings for Android
-        run: cd ${{ github.workspace }}/android && ${{ github.workspace }}/android/gradlew app:mergePlayDebugResources
+        run: |
+          cd ${{ github.workspace }}/android
+          ./gradlew app:generatePlayDebugResValues \
+            --parallel \
+            --build-cache \
+            --configuration-cache \
+            -Dorg.gradle.jvmargs="-Xmx2g -XX:+UseParallelGC" \
+            -Dorg.gradle.caching=true \
+            -x lint \
+            -x test
 
 
   jobs_sync:
@@ -370,4 +455,4 @@ jobs:
           body: ${{ env.PR_DESCRIPTION }}
           branch: ${{ env.PR_TARGET_BRANCH }}
           commit-message: ${{ env.PR_TITLE }}
-          delete-branch: true
\ No newline at end of file
+          delete-branch: true
diff --git a/.github/workflows/notify_failure.yml b/.github/workflows/notify_failure.yml
new file mode 100644
index 0000000..2757c16
--- /dev/null
+++ b/.github/workflows/notify_failure.yml
@@ -0,0 +1,34 @@
+name: Discord Failure Notification
+
+on:
+  workflow_run:
+    workflows: 
+      - "Check for Crowdin Updates"
+      - "Test Failure Notification"
+    types:
+      - completed
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
+    steps:
+      - name: Send Discord notification
+        env:
+          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
+          DISCORD_ROLE_ID: ${{ secrets.DISCORD_ROLE_ID }}
+        run: |
+          curl -H "Content-Type: application/json" \
+            -d '{
+              "content": "<@&'"$DISCORD_ROLE_ID"'> ⚠️ GitHub Action failed!",
+              "embeds": [{
+                "title": "Workflow Failed: ${{ github.event.workflow_run.name }}",
+                "url": "${{ github.event.workflow_run.html_url }}",
+                "color": 15158332,
+                "fields": [
+                  {"name": "Repository", "value": "${{ github.repository }}", "inline": true},
+                  {"name": "Branch", "value": "${{ github.event.workflow_run.head_branch }}", "inline": true}
+                ]
+              }]
+            }' \
+            "$DISCORD_WEBHOOK_URL"
diff --git a/.github/workflows/test_failure_notification.yml b/.github/workflows/test_failure_notification.yml
new file mode 100644
index 0000000..d22440c
--- /dev/null
+++ b/.github/workflows/test_failure_notification.yml
@@ -0,0 +1,11 @@
+name: Test Failure Notification
+
+on:
+  workflow_dispatch:
+
+jobs:
+  fail:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fail on purpose
+        run: exit 1
diff --git a/.gitignore b/.gitignore
index e046d9c..3fb72ac 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@
 # Exclude venv folder
 venv
 
+.env
 
 __pycache__
 .vscode/
diff --git a/README.md b/README.md
index 8b9e7f1..88cf0ee 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,60 @@
 # Session Shared Scripts
 
 This repo houses scripts which are shared between the different platform repos for Session, it also contains a number of Actions used to automatically sync some shared elements across the repos.
+
+## Crowdin Translation Workflow
+
+Automated workflow that downloads translations from Crowdin, validates them, and creates PRs for iOS, Android, and Desktop platforms.
+
+### Required Secrets
+
+| Secret              | Description                               |
+| ------------------- | ----------------------------------------- |
+| `CROWDIN_API_TOKEN` | Crowdin API token with project access     |
+| `CROWDIN_PR_TOKEN`  | GitHub token with PR creation permissions |
+
+### Workflow Inputs
+
+| Input                    | Default | Description                              |
+| ------------------------ | ------- | ---------------------------------------- |
+| `UPDATE_PULL_REQUESTS`   | `true`  | Create/update PRs for all platforms      |
+| `SKIP_VALIDATION_ERRORS` | `false` | Continue even if string validation fails |
+
+### Schedule
+
+Runs automatically every Monday at 00:00 UTC.
+
+### Validation Rules
+
+#### All Strings (including plurals)
+
+- **Valid `{variable}` syntax** - No broken braces (`{`, `}`, `{}`, `{ space }`)
+- **Allowed HTML tags only** - Only `<b>`, `<br/>`, `<span>`
+- **Valid tag syntax** - No malformed `<` (e.g., `<script>`, `<123>`)
+
+#### Non-Plural Strings Only
+
+- **Variables match English** - Same `{variables}` as source locale
+- **Tag count matches English** - Same number of tags (warning only)
+
+#### All Locales
+
+- **No extra keys** - No strings that don't exist in English
+
+> **Note:** Plural strings skip variable/tag comparison because languages have different plural forms (English: 2, Arabic: 6, Russian: 4). It would be nice to add suppot for plural validation in the future.
+
+## Workflow Failure Notificaiton
+
+If a workflow fails and is in the list of workflows monitored by the failure notificaiton workflow, the failure notificaiton workflow will send a message to a discord webhook.
+
+### Required Secrets
+
+| Secret                | Description                        |
+| --------------------- | ---------------------------------- |
+| `DISCORD_WEBHOOK_URL` | Url for the Discord webhook        |
+| `DISCORD_ROLE_ID`     | Discord role id to tag in messages |
+
+### Trigger Test Notification
+
+The failure notification can be triggered by manualy running the Test Failure Notification workflow.
+
diff --git a/crowdin/download_translations_from_crowdin.py b/crowdin/download_translations_from_crowdin.py
index 298d6fd..033607b 100644
--- a/crowdin/download_translations_from_crowdin.py
+++ b/crowdin/download_translations_from_crowdin.py
@@ -3,6 +3,9 @@
 import sys
 import argparse
 import requests
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from threading import Lock, Semaphore
 
 from colorama import Fore, Style, init
 
@@ -18,6 +21,7 @@
 parser.add_argument('--concept_id', help='Crowdin non-translatable terms concept ID (optional)', default=None)
 parser.add_argument('--skip-untranslated-strings', action='store_true', help='Exclude strings which have not been translated from the translation files')
 parser.add_argument('--force-allow-unapproved', action='store_true', help='Include unapproved translations in the translation files')
+parser.add_argument('--max-workers', type=int, default=10, help='Maximum number of parallel downloads (default: 10, max: 20 due to Crowdin API limits)')
 parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose output')
 args = parser.parse_args()
 
@@ -30,23 +34,67 @@
 SKIP_UNTRANSLATED_STRINGS = args.skip_untranslated_strings
 FORCE_ALLOW_UNAPPROVED = args.force_allow_unapproved
 VERBOSE = args.verbose
+# Crowdin API limit is 20 simultaneous requests per account
+MAX_WORKERS = min(args.max_workers, 20)
+# Semaphore ensures we don't exceed the concurrent requests limit
+api_semaphore = Semaphore(MAX_WORKERS)
 
-REQUEST_TIMEOUT_S = 5
+REQUEST_TIMEOUT_S = 30
+MAX_RETRIES = 5
+INITIAL_RETRY_DELAY_S = 0.5
 
-def check_error(response):
-    """
-    Function to check for errors in API responses
-    """
+progress_lock = Lock()
+completed_count = 0
+total_count = 0
+
+
+def make_request_with_retry(method: str, url: str, **kwargs) -> requests.Response:
+    last_exception = None
+
+    for attempt in range(MAX_RETRIES):
+        try:
+            with api_semaphore:
+                if method.upper() == 'GET':
+                    response = requests.get(
+                        url, timeout=REQUEST_TIMEOUT_S, **kwargs)
+                elif method.upper() == 'POST':
+                    response = requests.post(
+                        url, timeout=REQUEST_TIMEOUT_S, **kwargs)
+                else:
+                    raise ValueError(f"Unsupported HTTP method: {method}")
+
+                # Handle rate limiting
+                if response.status_code == 429:
+                    retry_after = int(response.headers.get(
+                        'Retry-After', INITIAL_RETRY_DELAY_S * (2 ** attempt)))
+                    if VERBOSE:
+                        print(f"\n{Fore.YELLOW}⚠️  Rate limited, waiting {
+                              retry_after}s before retry...{Style.RESET_ALL}")
+                    time.sleep(retry_after)
+                    continue
+
+                return response
+
+        except requests.exceptions.RequestException as e:
+            last_exception = e
+            delay = INITIAL_RETRY_DELAY_S * (2 ** attempt)
+            if VERBOSE:
+                print(f"\n{Fore.YELLOW}⚠️  Request failed, retrying in {
+                      delay}s... ({e}){Style.RESET_ALL}")
+            time.sleep(delay)
+
+    raise last_exception or Exception(
+        f"Request failed after {MAX_RETRIES} retries")
+
+
+def check_error(response, context=""):
     if response.status_code != 200:
-        print(f"\033[2K{Fore.RED}❌ Error: {response.json().get('error', {}).get('message', 'Unknown error')} (Code: {response.status_code}){Style.RESET_ALL}")
-        if VERBOSE:
-            print(f"{Fore.BLUE}Response: {json.dumps(response.json(), indent=2)}{Style.RESET_ALL}")
-        sys.exit(1)
+        error_msg = response.json().get('error', {}).get('message', 'Unknown error')
+        raise Exception(
+            f"{context}: {error_msg} (Code: {response.status_code})")
+
 
 def download_file(url: str, output_path: str):
-    """
-    Function to download a file from Crowdin
-    """
     response = requests.get(url, stream=True, timeout=REQUEST_TIMEOUT_S)
     response.raise_for_status()
 
@@ -55,19 +103,50 @@ def download_file(url: str, output_path: str):
             f.write(chunk)
 
 
+def export_and_download_language(language: dict, is_source: bool = False) -> str:
+    global completed_count
+
+    lang_id = language['id']
+    lang_locale = language['locale']
+    export_payload = {
+        "targetLanguageId": lang_id,
+        "format": "xliff",
+        "skipUntranslatedStrings": False if is_source else SKIP_UNTRANSLATED_STRINGS,
+        "exportApprovedOnly": False if is_source else (not FORCE_ALLOW_UNAPPROVED)
+    }
+
+    export_response = make_request_with_retry(
+        'POST',
+        f"{CROWDIN_API_BASE_URL}/projects/{CROWDIN_PROJECT_ID}/translations/exports",
+        headers={"Authorization": f"Bearer {CROWDIN_API_TOKEN}",
+                 "Content-Type": "application/json"},
+        data=json.dumps(export_payload)
+    )
+    check_error(export_response, f"Export failed for {lang_locale}")
+
+    download_url = export_response.json()['data']['url']
+    download_path = os.path.join(DOWNLOAD_DIRECTORY, f"{lang_locale}.xliff")
+    download_file(download_url, download_path)
+
+    with progress_lock:
+        completed_count += 1
+        print(f"\033[2K{Fore.WHITE}⏳ Downloaded {
+              completed_count}/{total_count} translations...{Style.RESET_ALL}", end='\r')
+
+    return lang_locale
+
+
 def main():
-    """
-    Main Function
-    Fetch crowdin project info, and iterate over each locale to save the corresponding .xliff locally.
-    """
+    global total_count, completed_count
     # Retrieve the list of languages
     print(f"{Fore.WHITE}⏳ Retrieving project details...{Style.RESET_ALL}", end='\r')
-    project_response = requests.get(f"{CROWDIN_API_BASE_URL}/projects/{CROWDIN_PROJECT_ID}",
-                                      headers={"Authorization": f"Bearer {CROWDIN_API_TOKEN}"},
-                                      timeout=REQUEST_TIMEOUT_S)
-    check_error(project_response)
+    project_response = make_request_with_retry(
+        'GET',
+        f"{CROWDIN_API_BASE_URL}/projects/{CROWDIN_PROJECT_ID}",
+        headers={"Authorization": f"Bearer {CROWDIN_API_TOKEN}"}
+    )
+    check_error(project_response, "Failed to retrieve project details")
     project_details = project_response.json()['data']
-    source_language_id = project_details['sourceLanguageId']
     source_language = project_details['sourceLanguage']
     target_languages = project_details['targetLanguages']
     num_languages = len(target_languages)
@@ -76,7 +155,6 @@ def main():
     if VERBOSE:
         print(f"{Fore.BLUE}Response: {json.dumps(project_response.json(), indent=2)}{Style.RESET_ALL}")
 
-    # Ensure the download and output directories exist
     if not os.path.exists(DOWNLOAD_DIRECTORY):
         os.makedirs(DOWNLOAD_DIRECTORY)
 
@@ -84,85 +162,51 @@ def main():
     with open(project_info_file, 'w', encoding='utf-8') as file:
         json.dump(project_response.json(), file, indent=2)
 
-    # Retrieve the source language
-    print(f"\033[2K{Fore.WHITE}⏳ Exporting source language {source_language_id}...{Style.RESET_ALL}", end='\r')
-    source_lang_locale = source_language['locale']
-    source_export_payload = {
-        "targetLanguageId": source_language_id,
-        "format": "xliff",
-        "skipUntranslatedStrings": False,
-        "exportApprovedOnly": False
-    }
-    source_export_response = requests.post(f"{CROWDIN_API_BASE_URL}/projects/{CROWDIN_PROJECT_ID}/translations/exports",
-                                    headers={"Authorization": f"Bearer {CROWDIN_API_TOKEN}", "Content-Type": "application/json"},
-                                    data=json.dumps(source_export_payload), timeout=REQUEST_TIMEOUT_S)
-    check_error(source_export_response)
-
-    if VERBOSE:
-        print(f"\n{Fore.BLUE}Response: {json.dumps(source_export_response.json(), indent=2)}{Style.RESET_ALL}")
-
-    # Download the exported file
-    source_download_url = source_export_response.json()['data']['url']
-    source_download_path = os.path.join(DOWNLOAD_DIRECTORY, f"{source_lang_locale}.xliff")
-    print(f"\033[2K{Fore.WHITE}⏳ Downloading translations for {source_lang_locale}...{Style.RESET_ALL}", end='\r')
-    try:
-        download_file(source_download_url, source_download_path)
-    except requests.exceptions.HTTPError as e:
-        print(f"\033[2K{Fore.RED}❌ Failed to download translations for {source_lang_locale} (Error: {e}){Style.RESET_ALL}")
-        if VERBOSE:
-            print(f"{Fore.BLUE}Response: {e.response.text}{Style.RESET_ALL}")
-        sys.exit(1)
-
-    # Completed downloading
-    print(f"\033[2K{Fore.GREEN}✅ Downloading source language complete{Style.RESET_ALL}")
-
-    # Sort languages alphabetically by locale
-    target_languages.sort(key=lambda x: x['locale'])
-
-    # Iterate over each language and download the translations
-    for index, language in enumerate(target_languages, start=1):
-        lang_id = language['id']
-        lang_locale = language['locale']
-        prefix = f"({index:02d}/{num_languages:02d})"
-
-        # Request export of translations for the specific language
-        print(f"\033[2K{Fore.WHITE}⏳ {prefix} Exporting translations for {lang_locale}...{Style.RESET_ALL}", end='\r')
-        export_payload = {
-            "targetLanguageId": lang_id,
-            "format": "xliff",
-            "skipUntranslatedStrings": (True if SKIP_UNTRANSLATED_STRINGS else False),
-            "exportApprovedOnly": (False if FORCE_ALLOW_UNAPPROVED else True)
+    all_languages = [{'language': source_language, 'is_source': True}]
+    for lang in sorted(target_languages, key=lambda x: x['locale']):
+        all_languages.append({'language': lang, 'is_source': False})
+
+    total_count = len(all_languages)
+    completed_count = 0
+
+    print(f"{Fore.WHITE}⏳ Downloading {total_count} translations (using {MAX_WORKERS} parallel workers)...{Style.RESET_ALL}")
+    failed_languages = []
+    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        future_to_lang = {
+            executor.submit(
+                export_and_download_language,
+                item['language'],
+                item['is_source']
+            ): item['language']['locale']
+            for item in all_languages
         }
-        export_response = requests.post(f"{CROWDIN_API_BASE_URL}/projects/{CROWDIN_PROJECT_ID}/translations/exports",
-                                        headers={"Authorization": f"Bearer {CROWDIN_API_TOKEN}", "Content-Type": "application/json"},
-                                        data=json.dumps(export_payload), timeout=REQUEST_TIMEOUT_S)
-        check_error(export_response)
-
-        if VERBOSE:
-            print(f"\n{Fore.BLUE}Response: {json.dumps(export_response.json(), indent=2)}{Style.RESET_ALL}")
 
-        # Download the exported file
-        download_url = export_response.json()['data']['url']
-        download_path = os.path.join(DOWNLOAD_DIRECTORY, f"{lang_locale}.xliff")
-        print(f"\033[2K{Fore.WHITE}⏳ {prefix} Downloading translations for {lang_locale}...{Style.RESET_ALL}", end='\r')
-        try:
-            download_file(download_url, download_path)
-        except requests.exceptions.HTTPError as e:
-            print(f"\033[2K{Fore.RED}❌ {prefix} Failed to download translations for {lang_locale} (Error: {e}){Style.RESET_ALL}")
-            if VERBOSE:
-                print(f"{Fore.BLUE}Response: {e.response.text}{Style.RESET_ALL}")
-            sys.exit(1)
-
-    # Completed downloading
-    print(f"\033[2K{Fore.GREEN}✅ Downloading {num_languages} translations complete{Style.RESET_ALL}")
+        for future in as_completed(future_to_lang):
+            lang_locale = future_to_lang[future]
+            try:
+                future.result()
+            except Exception as e:
+                failed_languages.append((lang_locale, str(e)))
+                if VERBOSE:
+                    print(f"\n{Fore.RED}❌ Failed: {lang_locale} - {e}{Style.RESET_ALL}")
+
+    if failed_languages:
+        print(f"\033[2K{Fore.RED}❌ {len(failed_languages)} downloads failed:{Style.RESET_ALL}")
+        for locale, error in failed_languages:
+            print(f"  - {locale}: {error}")
+        sys.exit(1)
+    else:
+        print(f"\033[2K{Fore.GREEN}✅ Downloaded {total_count} translations complete{Style.RESET_ALL}")
 
     # Download non-translatable terms (if requested)
     if CROWDIN_GLOSSARY_ID is not None and CROWDIN_CONCEPT_ID is not None:
         print(f"{Fore.WHITE}⏳ Retrieving non-translatable strings...{Style.RESET_ALL}", end='\r')
-        static_string_response = requests.get(f"{CROWDIN_API_BASE_URL}/glossaries/{CROWDIN_GLOSSARY_ID}/terms?conceptId={CROWDIN_CONCEPT_ID}&limit=500",
-                                          headers={"Authorization": f"Bearer {CROWDIN_API_TOKEN}"},
-                                          timeout=REQUEST_TIMEOUT_S)
-        check_error(static_string_response)
+        static_string_response = make_request_with_retry(
+            'GET',
+            f"{CROWDIN_API_BASE_URL}/glossaries/{CROWDIN_GLOSSARY_ID}/terms?conceptId={CROWDIN_CONCEPT_ID}&limit=500",
+            headers={"Authorization": f"Bearer {CROWDIN_API_TOKEN}"}
+        )
+        check_error(static_string_response, "Failed to retrieve non-translatable strings")
 
         if VERBOSE:
             print(f"{Fore.BLUE}Response: {json.dumps(static_string_response.json(), indent=2)}{Style.RESET_ALL}")
@@ -173,9 +217,13 @@ def main():
 
         print(f"\033[2K{Fore.GREEN}✅ Downloading non-translatable complete{Style.RESET_ALL}")
 
+
 if __name__ == "__main__":
     try:
         main()
     except KeyboardInterrupt:
         print(f"\n{Fore.RED}Process interrupted by user{Style.RESET_ALL}")
         sys.exit(0)
+    except Exception as e:
+        print(f"\033[2K{Fore.RED}❌ An error occurred: {e}{Style.RESET_ALL}")
+        sys.exit(1)
diff --git a/crowdin/generate_android_strings.py b/crowdin/generate_android_strings.py
index 67f8f96..64290a3 100644
--- a/crowdin/generate_android_strings.py
+++ b/crowdin/generate_android_strings.py
@@ -1,11 +1,15 @@
 import os
-import xml.etree.ElementTree as ET
-import sys
-import argparse
 import re
+import argparse
 from pathlib import Path
-from colorama import Fore, Style
-from generate_shared import load_glossary_dict, clean_string, setup_generation
+from typing import Dict, Any
+from generate_shared import (
+    load_parsed_translations,
+    clean_string,
+    print_progress,
+    print_success,
+    run_main
+)
 
 # Variables that should be treated as numeric (using %d)
 NUMERIC_VARIABLES = ['count', 'found_count', 'total_count']
@@ -13,50 +17,8 @@
 AUTO_REPLACE_STATIC_STRINGS = False
 
 
-# Parse command-line arguments
-parser = argparse.ArgumentParser(description='Convert a XLIFF translation files to Android XML.')
-parser.add_argument('raw_translations_directory', help='Directory which contains the raw translation files')
-parser.add_argument('translations_output_directory', help='Directory to save the converted translation files')
-parser.add_argument('non_translatable_strings_output_path', help='Path to save the non-translatable strings to')
-args = parser.parse_args()
-
-INPUT_DIRECTORY = args.raw_translations_directory
-TRANSLATIONS_OUTPUT_DIRECTORY = args.translations_output_directory
-NON_TRANSLATABLE_STRINGS_OUTPUT_PATH = args.non_translatable_strings_output_path
-
-def parse_xliff(file_path):
-    tree = ET.parse(file_path)
-    root = tree.getroot()
-    namespace = {'ns': 'urn:oasis:names:tc:xliff:document:1.2'}
-    translations = {}
-
-    # Handle plural groups
-    for group in root.findall('.//ns:group[@restype="x-gettext-plurals"]', namespaces=namespace):
-        plural_forms = {}
-        resname = None
-        for trans_unit in group.findall('ns:trans-unit', namespaces=namespace):
-            if resname is None:
-                resname = trans_unit.get('resname')
-            target = trans_unit.find('ns:target', namespaces=namespace)
-            context_group = trans_unit.find('ns:context-group', namespaces=namespace)
-            plural_form = context_group.find('ns:context[@context-type="x-plural-form"]', namespaces=namespace)
-            if target is not None and target.text and plural_form is not None:
-                form = plural_form.text.split(':')[-1].strip().lower()
-                plural_forms[form] = target.text
-        if resname and plural_forms:
-            translations[resname] = plural_forms
-
-    # Handle non-plural translations
-    for trans_unit in root.findall('.//ns:trans-unit', namespaces=namespace):
-        resname = trans_unit.get('resname')
-        if resname not in translations:  # This is not part of a plural group
-            target = trans_unit.find('ns:target', namespaces=namespace)
-            if target is not None and target.text:
-                translations[resname] = target.text
-
-    return translations
-
-def convert_placeholders(text):
+def convert_placeholders(text: str) -> str:
+    """Convert {placeholder} syntax to Android positional format."""
     def repl(match):
         var_name = match.group(1)
         index = len(set(re.findall(r'\{([^}]+)\}', text[:match.start()]))) + 1
@@ -69,7 +31,20 @@ def repl(match):
     return re.sub(r'\{([^}]+)\}', repl, text)
 
 
-def generate_android_xml(translations, app_name, glossary_dict):
+def generate_android_xml(
+    translations: Dict[str, Any],
+    app_name: str | None,
+    glossary_dict: Dict[str, str]
+) -> str:
+    """
+    Generate Android strings.xml content from translations.
+    Args:
+        translations: Dictionary of translations
+        app_name: App name to include (only for source language)
+        glossary_dict: Dictionary for string cleaning
+    Returns:
+        XML string content
+    """
     sorted_translations = sorted(translations.items())
     result = '<?xml version="1.0" encoding="utf-8"?>\n'
     result += '<resources>\n'
@@ -77,36 +52,42 @@ def generate_android_xml(translations, app_name, glossary_dict):
     if app_name is not None:
         result += f'    <string name="app_name" translatable="false">{app_name}</string>\n'
 
-    for resname, target in sorted_translations:
-        if isinstance(target, dict):  # It's a plural group
+    for resname, trans_data in sorted_translations:
+        if trans_data['type'] == 'plural':
             result += f'    <plurals name="{resname}">\n'
-            for form, value in target.items():
+            for form, value in trans_data['forms'].items():
                 escaped_value = clean_string(convert_placeholders(value), True, glossary_dict, {})
                 result += f'        <item quantity="{form}">{escaped_value}</item>\n'
             result += '    </plurals>\n'
-        else:  # It's a regular string (for these we DON'T want to convert the placeholders)
-            escaped_target = clean_string(target, True, glossary_dict, {})
+        else:
+            # Regular strings: DON'T convert placeholders
+            escaped_target = clean_string(trans_data['value'], True, glossary_dict, {})
             result += f'    <string name="{resname}">{escaped_target}</string>\n'
 
     result += '</resources>'
-
     return result
 
-def convert_xliff_to_android_xml(input_file, output_dir, source_locale, locale, glossary_dict):
-    if not os.path.exists(input_file):
-        raise FileNotFoundError(f"Could not find '{input_file}' in raw translations directory")
 
-    # Parse the XLIFF and convert to XML (only include the 'app_name' entry in the source language)
+def write_android_xml(
+    translations: Dict[str, Any],
+    output_dir: str,
+    source_locale: str,
+    locale: str,
+    glossary_dict: Dict[str, str]
+):
+    """Write Android strings.xml for a locale."""
     is_source_language = locale == source_locale
-    translations = parse_xliff(input_file)
-    app_name = glossary_dict['app_name']
-    output_data = generate_android_xml(translations, app_name if is_source_language else None, glossary_dict if AUTO_REPLACE_STATIC_STRINGS else {})
+    app_name = glossary_dict.get('app_name')
+
+    output_data = generate_android_xml(
+        translations,
+        app_name if is_source_language else None,
+        glossary_dict if AUTO_REPLACE_STATIC_STRINGS else {}
+    )
 
-    # android is pretty smart to resolve resources for translations, see the example here:
-    # https://developer.android.com/guide/topics/resources/multilingual-support#resource-resolution-examples
-    android_safe_locale = f"b+{locale.replace('-','+')}"
+    # Android locale path format
+    android_safe_locale = f"b+{locale.replace('-', '+')}"
 
-    # Generate output files
     if is_source_language:
         language_output_dir = os.path.join(output_dir, 'values')
     else:
@@ -114,65 +95,88 @@ def convert_xliff_to_android_xml(input_file, output_dir, source_locale, locale,
 
     os.makedirs(language_output_dir, exist_ok=True)
     language_output_file = os.path.join(language_output_dir, 'strings.xml')
+
     with open(language_output_file, 'w', encoding='utf-8') as file:
         file.write(output_data)
 
 
-
-def convert_non_translatable_strings_to_kotlin(input_file, output_path):
-    glossary_dict = load_glossary_dict(input_file)
-
+def generate_kotlin_constants(glossary_dict: Dict[str, str], output_path: str):
+    """Generate Kotlin file with non-translatable string constants."""
     max_key_length = max(len(key) for key in glossary_dict)
-    app_name = glossary_dict['app_name']
+    app_name = glossary_dict.get('app_name')
+
+    if not app_name:
+        raise ValueError("Could not find app_name in glossary_dict")
 
-    # Output the file in the desired format
     Path(output_path).parent.mkdir(parents=True, exist_ok=True)
 
     with open(output_path, 'w', encoding='utf-8') as file:
-        file.write('package org.session.libsession.utilities\n')
-        file.write('\n')
+        file.write('package org.session.libsession.utilities\n\n')
         file.write('// Non-translatable strings for use with the UI\n')
         file.write("object NonTranslatableStringConstants {\n")
-        for key_lowercase in glossary_dict:
+        for key_lowercase, text in glossary_dict.items():
             key = key_lowercase.upper()
-            text = glossary_dict[key_lowercase]
             cleaned_text = clean_string(text, True, glossary_dict, {})
             file.write(f'    const val {key:<{max_key_length}} = "{cleaned_text}"\n')
 
-        file.write('}\n')
-        file.write('\n')
-
-    if not app_name:
-        raise ValueError("could not find app_name in glossary_dict")
-
-def convert_all_files(input_directory: str ):
-    setup_values = setup_generation(input_directory)
-    source_language, rtl_languages, non_translatable_strings_file, target_languages = setup_values.values()
-
-    convert_non_translatable_strings_to_kotlin(non_translatable_strings_file, NON_TRANSLATABLE_STRINGS_OUTPUT_PATH)
-    print(f"\033[2K{Fore.GREEN}✅ Static string generation complete{Style.RESET_ALL}")
-    glossary_dict = load_glossary_dict(non_translatable_strings_file)
-
-    # Convert the XLIFF data to the desired format
-    print(f"\033[2K{Fore.WHITE}⏳ Converting translations to target format...{Style.RESET_ALL}", end='\r')
+        file.write('}\n\n')
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert parsed translations to Android XML.'
+    )
+    parser.add_argument(
+        'parsed_translations_file',
+        help='Path to the parsed translations JSON file'
+    )
+    parser.add_argument(
+        'translations_output_directory',
+        help='Directory to save the converted translation files'
+    )
+    parser.add_argument(
+        'non_translatable_strings_output_path',
+        help='Path to save the non-translatable strings to'
+    )
+    args = parser.parse_args()
+
+    parsed_data = load_parsed_translations(args.parsed_translations_file)
+    glossary_dict = parsed_data['glossary']
+    source_language = parsed_data['source_language']
+    target_languages = parsed_data['target_languages']
+    locales = parsed_data['locales']
+
+    print_progress("Generating static strings file...")
+    generate_kotlin_constants(glossary_dict, args.non_translatable_strings_output_path)
+    print_success("Static string generation complete")
+
+    print_progress("Converting translations to target format...")
     source_locale = source_language['locale']
+
     for language in [source_language] + target_languages:
         lang_locale = language['locale']
+
         if lang_locale == 'sh-HR':
-            # see https://en.wikipedia.org/wiki/Language_secessionism#In_Serbo-Croatian
-            print(f"\033[2K{Fore.WHITE}⏳ Skipping {lang_locale} as unsupported by android{Style.RESET_ALL}")
+            # See https://en.wikipedia.org/wiki/Language_secessionism#In_Serbo-Croatian
+            print_progress(f"Skipping {lang_locale} as unsupported by Android")
             continue
-        print(f"\033[2K{Fore.WHITE}⏳ Converting translations for {lang_locale} to target format...{Style.RESET_ALL}", end='\r')
-        input_file = os.path.join(input_directory, f"{lang_locale}.xliff")
-        convert_xliff_to_android_xml(input_file, TRANSLATIONS_OUTPUT_DIRECTORY, source_locale, lang_locale, glossary_dict)
-    print(f"\033[2K{Fore.GREEN}✅ All conversions complete{Style.RESET_ALL}")
+
+        print_progress(f"Converting translations for {lang_locale} to target format...")
+
+        locale_data = locales.get(lang_locale)
+        if locale_data is None:
+            raise ValueError(f"Missing locale data for {lang_locale}")
+
+        write_android_xml(
+            locale_data['translations'],
+            args.translations_output_directory,
+            source_locale,
+            lang_locale,
+            glossary_dict
+        )
+
+    print_success("All conversions complete")
+
 
 if __name__ == "__main__":
-    try:
-        convert_all_files(INPUT_DIRECTORY)
-    except KeyboardInterrupt:
-        print("\nProcess interrupted by user")
-        sys.exit(0)
-    except Exception as e:
-        print(f"\033[2K{Fore.RED}❌ An error occurred: {str(e)}")
-        sys.exit(1)
+    run_main(main)
diff --git a/crowdin/generate_desktop_strings.py b/crowdin/generate_desktop_strings.py
index 5d3a0eb..6e2ec38 100644
--- a/crowdin/generate_desktop_strings.py
+++ b/crowdin/generate_desktop_strings.py
@@ -1,13 +1,16 @@
 import os
 import json
 import re
-from typing import Dict, List
-import xml.etree.ElementTree as ET
-import sys
 import argparse
 from pathlib import Path
-from colorama import Fore, Style
-from generate_shared import clean_string, load_glossary_dict, setup_generation
+from typing import Dict, List, Any
+from generate_shared import (
+    load_parsed_translations,
+    clean_string,
+    print_progress,
+    print_success,
+    run_main
+)
 
 # Customizable mapping for output folder hierarchy
 # Add entries here to customize the output path for specific locales
@@ -29,110 +32,91 @@
 }
 
 
-# Parse command-line arguments
-parser = argparse.ArgumentParser(description='Convert a XLIFF translation files to JSON.')
-parser.add_argument('--qa_build', help='Set to true to output only English strings (only used for QA)', action=argparse.BooleanOptionalAction)
-parser.add_argument('raw_translations_directory', help='Directory which contains the raw translation files')
-parser.add_argument('translations_output_directory', help='Directory to save the converted translation files')
-parser.add_argument('non_translatable_strings_output_path', help='Path to save the non-translatable strings to')
-args = parser.parse_args()
-
-INPUT_DIRECTORY = args.raw_translations_directory
-TRANSLATIONS_OUTPUT_DIRECTORY = args.translations_output_directory
-NON_TRANSLATABLE_STRINGS_OUTPUT_PATH = args.non_translatable_strings_output_path
-IS_QA_BUILD = args.qa_build
-
-
-def matches_braced_pattern(string):
+def matches_braced_pattern(string: str) -> bool:
     return re.search(r"\{(.+?)\}", string) is not None
 
+
 def snake_to_camel(snake_str: str) -> str:
     parts = snake_str.split('_')
     return parts[0].lower() + ''.join(word.capitalize() for word in parts[1:])
 
-def parse_xliff(file_path):
-    tree = ET.parse(file_path)
-    root = tree.getroot()
-    namespace = {'ns': 'urn:oasis:names:tc:xliff:document:1.2'}
-    translations = {}
-
-    # Handle plural groups
-    for group in root.findall('.//ns:group[@restype="x-gettext-plurals"]', namespaces=namespace):
-        plural_forms = {}
-        resname = None
-        for trans_unit in group.findall('ns:trans-unit', namespaces=namespace):
-            if resname is None:
-                resname = trans_unit.get('resname')
-            target = trans_unit.find('ns:target', namespaces=namespace)
-            context_group = trans_unit.find('ns:context-group', namespaces=namespace)
-            plural_form = context_group.find('ns:context[@context-type="x-plural-form"]', namespaces=namespace)
-            if target is not None and target.text and plural_form is not None:
-                form = plural_form.text.split(':')[-1].strip().lower()
-                plural_forms[form] = target.text
-        if resname and plural_forms:
-            translations[resname] = plural_forms
-
-    # Handle non-plural translations
-    for trans_unit in root.findall('.//ns:trans-unit', namespaces=namespace):
-        resname = trans_unit.get('resname')
-        if resname not in translations:  # This is not part of a plural group
-            target = trans_unit.find('ns:target', namespaces=namespace)
-            if target is not None and target.text:
-                translations[resname] = target.text
-
-    return translations
-
-
-def generate_icu_pattern(target, glossary_dict : Dict[str,str]):
-    if isinstance(target, dict):  # It's a plural group
+
+def generate_icu_pattern(trans_data: Dict[str, Any] | str, glossary_dict: Dict[str, str]) -> str:
+    """
+    Generate an ICU pattern from translation data.
+    Args:
+        trans_data: Either a dict with 'type' and 'forms'/'value', or a raw string
+        glossary_dict: Dictionary of non-translatable strings
+    Returns:
+        ICU-formatted string
+    """
+    # Handle raw strings (from glossary)
+    if isinstance(trans_data, str):
+        return clean_string(trans_data, False, glossary_dict, {})
+    if trans_data['type'] == 'plural':
         pattern_parts = []
-        for form, value in target.items():
+        for form, value in trans_data['forms'].items():
             if form in ['zero', 'one', 'two', 'few', 'many', 'other', 'exact', 'fractional']:
-                value = clean_string(value, False, glossary_dict, {})
-                pattern_parts.append(f"{form} [{value}]")
-
+                cleaned_value = clean_string(value, False, glossary_dict, {})
+                pattern_parts.append(f"{form} [{cleaned_value}]")
         return "{{count, plural, {0}}}".format(" ".join(pattern_parts))
-    else:  # It's a regular string
-        return clean_string(target, False, glossary_dict, {})
-
-def convert_xliff_to_json(input_file, output_dir, locale, locale_two_letter_code, glossary_dict):
-    if not os.path.exists(input_file):
-        raise FileNotFoundError(f"Could not find '{input_file}' in raw translations directory")
-
-    # Parse the XLIFF and convert to XML
-    translations = parse_xliff(input_file)
+    else:
+        return clean_string(trans_data['value'], False, glossary_dict, {})
+
+
+def get_output_locale(locale: str, two_letter_code: str) -> str:
+    return LOCALE_PATH_MAPPING.get(locale, LOCALE_PATH_MAPPING.get(two_letter_code, two_letter_code))
+
+
+def convert_locale_to_json(
+    translations: Dict[str, Any],
+    glossary_dict: Dict[str, str],
+    output_dir: str,
+    locale: str,
+    two_letter_code: str
+) -> str:
+    """
+    Convert translations for a single locale to JSON format.
+    Args:
+        translations: Dictionary of translations for this locale
+        glossary_dict: Dictionary of non-translatable strings
+        output_dir: Base output directory
+        locale: Full locale code
+        two_letter_code: Two-letter language code
+    Returns:
+        The output locale name used
+    """
     sorted_translations = sorted(translations.items())
     converted_translations = {}
 
-    for resname, target in sorted_translations:
-        converted_translations[resname] = generate_icu_pattern(target, glossary_dict)
+    for resname, trans_data in sorted_translations:
+        converted_translations[resname] = generate_icu_pattern(trans_data, glossary_dict)
 
+    # Add glossary items (converted to camelCase)
+    for resname, text in glossary_dict.items():
+        converted_translations[snake_to_camel(resname)] = generate_icu_pattern(text, glossary_dict)
 
-    for resname in glossary_dict:
-        target = glossary_dict[resname]
-        # Note: this adds the glossary dict items to the translated strings.
-        # This way, we can use desktop <Localiser /> and tr function with them directly
-        converted_translations[snake_to_camel(resname)] = generate_icu_pattern(target, glossary_dict)
-
-    # Generate output files
-    output_locale = LOCALE_PATH_MAPPING.get(locale, LOCALE_PATH_MAPPING.get(locale_two_letter_code, locale_two_letter_code))
+    # Write output
+    output_locale = get_output_locale(locale, two_letter_code)
     locale_output_dir = os.path.join(output_dir, output_locale)
     output_file = os.path.join(locale_output_dir, 'messages.json')
     os.makedirs(locale_output_dir, exist_ok=True)
 
     with open(output_file, 'w', encoding='utf-8') as file:
         json.dump(converted_translations, file, ensure_ascii=False, indent=2, sort_keys=True)
-        file.write('\n')
-        file.write('\n')
-    return output_locale
+        file.write('\n\n')
 
+    return output_locale
 
 
-def convert_non_translatable_strings_to_type_script(input_file: str, output_path: str, exported_locales: List[str], rtl_languages: List[str]):
-    glossary_dict = load_glossary_dict(input_file)
+def generate_typescript_constants(
+    glossary_dict: Dict[str, str],
+    output_path: str,
+    exported_locales: List[str],
+    rtl_languages: List[Dict]
+):
     rtl_locales = sorted([lang["twoLettersCode"] for lang in rtl_languages])
 
-    # Output the file in the desired format
     Path(output_path).parent.mkdir(parents=True, exist_ok=True)
 
     joined_exported_locales = ",".join(f"\n  '{locale}'" for locale in exported_locales)
@@ -140,58 +124,85 @@ def convert_non_translatable_strings_to_type_script(input_file: str, output_path
 
     with open(output_path, 'w', encoding='utf-8') as file:
         file.write('export enum LOCALE_DEFAULTS {\n')
-        for key in glossary_dict:
-            text = glossary_dict[key]
-            # constant strings that have braces in them are not constants. We add them to the localised strings output
-            # for easy replacing of their variables
-            if(not matches_braced_pattern(text)):
+
+        for key, text in glossary_dict.items():
+            if not matches_braced_pattern(text):
                 cleaned_text = clean_string(text, False, glossary_dict, {})
                 file.write(f"  {key} = '{cleaned_text}',\n")
 
-        file.write('}\n')
-        file.write('\n')
-        file.write(f"export const rtlLocales = [{joined_rtl_locales}];\n")
-        file.write('\n')
-        file.write(f"export const crowdinLocales = [{joined_exported_locales},\n] as const;\n")
-        file.write('\n')
-        file.write("export type CrowdinLocale = (typeof crowdinLocales)[number];\n")
-        file.write('\n')
+        file.write('}\n\n')
+        file.write(f"export const rtlLocales = [{joined_rtl_locales}];\n\n")
+        file.write(f"export const crowdinLocales = [{joined_exported_locales},\n] as const;\n\n")
+        file.write("export type CrowdinLocale = (typeof crowdinLocales)[number];\n\n")
         file.write('export function isCrowdinLocale(locale: string): locale is CrowdinLocale {\n')
         file.write('  return crowdinLocales.includes(locale as CrowdinLocale);\n')
-        file.write('}\n')
-        file.write('\n')
-
-
-def convert_all_files(input_directory: str, is_qa_build: bool):
-    setup_values = setup_generation(input_directory)
-    source_language, rtl_languages, non_translatable_strings_file, target_languages = setup_values.values()
-
-    # Convert the XLIFF data to the desired format
-    print(f"\033[2K{Fore.WHITE}⏳ Converting translations to target format...{Style.RESET_ALL}", end='\r')
+        file.write('}\n\n')
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Convert parsed translations to JSON.')
+    parser.add_argument(
+        '--qa_build',
+        help='Set to true to output only English strings (only used for QA)',
+        action=argparse.BooleanOptionalAction
+    )
+    parser.add_argument(
+        'parsed_translations_file',
+        help='Path to the parsed translations JSON file'
+    )
+    parser.add_argument(
+        'translations_output_directory',
+        help='Directory to save the converted translation files'
+    )
+    parser.add_argument(
+        'non_translatable_strings_output_path',
+        help='Path to save the non-translatable strings to'
+    )
+    args = parser.parse_args()
+    is_qa_build = args.qa_build or False
+
+    parsed_data = load_parsed_translations(args.parsed_translations_file)
+    glossary_dict = parsed_data['glossary']
+    source_language = parsed_data['source_language']
+    target_languages = parsed_data['target_languages']
+    rtl_languages = parsed_data['rtl_languages']
+    locales = parsed_data['locales']
+
+    print_progress("Converting translations to target format...")
     exported_locales = []
-    glossary_dict = load_glossary_dict(non_translatable_strings_file)
 
-    for language in [source_language] + ([] if is_qa_build else target_languages):
+    languages_to_process = [source_language] + ([] if is_qa_build else target_languages)
+
+    for language in languages_to_process:
         lang_locale = language['locale']
         lang_two_letter_code = language['twoLettersCode']
-        print(f"\033[2K{Fore.WHITE}⏳ Converting translations for {lang_locale} to target format...{Style.RESET_ALL}", end='\r')
-        input_file = os.path.join(input_directory, f"{lang_locale}.xliff")
-        exported_as = convert_xliff_to_json(input_file, TRANSLATIONS_OUTPUT_DIRECTORY, lang_locale, lang_two_letter_code, glossary_dict)
+
+        print_progress(f"Converting translations for {lang_locale} to target format...")
+
+        locale_data = locales.get(lang_locale)
+        if locale_data is None:
+            raise ValueError(f"Missing locale data for {lang_locale}")
+
+        exported_as = convert_locale_to_json(
+            locale_data['translations'],
+            glossary_dict,
+            args.translations_output_directory,
+            lang_locale,
+            lang_two_letter_code
+        )
         exported_locales.append(exported_as)
-    print(f"\033[2K{Fore.GREEN}✅ All conversions complete{Style.RESET_ALL}")
 
-    # Convert the non-translatable strings to the desired format
-    print(f"\033[2K{Fore.WHITE}⏳ Generating static strings file...{Style.RESET_ALL}", end='\r')
+    print_success("All conversions complete")
+
+    print_progress("Generating static strings file...")
+    generate_typescript_constants(
+        glossary_dict,
+        args.non_translatable_strings_output_path,
+        exported_locales,
+        rtl_languages
+    )
+    print_success("Static string generation complete")
 
-    convert_non_translatable_strings_to_type_script(non_translatable_strings_file, NON_TRANSLATABLE_STRINGS_OUTPUT_PATH, exported_locales, rtl_languages)
-    print(f"\033[2K{Fore.GREEN}✅ Static string generation complete{Style.RESET_ALL}")
 
 if __name__ == "__main__":
-    try:
-        convert_all_files(INPUT_DIRECTORY, IS_QA_BUILD)
-    except KeyboardInterrupt:
-        print("\nProcess interrupted by user")
-        sys.exit(0)
-    except Exception as e:
-        print(f"\033[2K{Fore.RED}❌ An error occurred: {str(e)}")
-        sys.exit(1)
+    run_main(main)
diff --git a/crowdin/generate_ios_strings.py b/crowdin/generate_ios_strings.py
index 6029646..a4909d7 100644
--- a/crowdin/generate_ios_strings.py
+++ b/crowdin/generate_ios_strings.py
@@ -1,14 +1,16 @@
 import os
 import json
-import xml.etree.ElementTree as ET
-import sys
 import argparse
-import html
 from pathlib import Path
-from colorama import Fore, Style
 from datetime import datetime
-from generate_shared import load_glossary_dict, clean_string, setup_generation
-from typing import Dict
+from typing import Dict, Any
+from generate_shared import (
+    load_parsed_translations,
+    clean_string,
+    print_progress,
+    print_success,
+    run_main
+)
 
 AUTO_REPLACE_STATIC_STRINGS = False
 
@@ -21,103 +23,26 @@
     'tl': None,             # Tagalog (not supported, we have Filipino which might have to be enough for now)
 }
 
-# Parse command-line arguments
-parser = argparse.ArgumentParser(description='Convert a XLIFF translation files to Apple String Catalog.')
-parser.add_argument('raw_translations_directory', help='Directory which contains the raw translation files')
-parser.add_argument('translations_output_directory', help='Directory to save the converted translation files')
-parser.add_argument(
-    'non_translatable_strings_output_paths',
-    nargs='+',  # Expect one or more arguments
-    help='Paths to save the non-translatable strings to'
-)
-args = parser.parse_args()
-
-INPUT_DIRECTORY = args.raw_translations_directory
-TRANSLATIONS_OUTPUT_DIRECTORY = args.translations_output_directory
-NON_TRANSLATABLE_STRINGS_OUTPUT_PATHS = args.non_translatable_strings_output_paths
-
-def filter_and_map_language_ids(target_languages):
-    result = []
-    for lang in target_languages:
-        if lang['id'] in LANGUAGE_MAPPING:
-            mapped_value = LANGUAGE_MAPPING[lang['id']]
-            if mapped_value is not None:
-                lang['mapped_id'] = mapped_value
-                result.append(lang)
-        else:
-            lang['mapped_id'] = lang['id']
-            result.append(lang)
-    return result
-
-def parse_xliff(file_path):
-    tree = ET.parse(file_path)
-    root = tree.getroot()
-    namespace = {'ns': 'urn:oasis:names:tc:xliff:document:1.2'}
-    translations = {}
-
-    file_elem = root.find('ns:file', namespaces=namespace)
-    if file_elem is None:
-        raise ValueError(f"Invalid XLIFF structure in file: {file_path}")
-
-    target_language = file_elem.get('target-language')
-    if target_language is None:
-        raise ValueError(f"Missing target-language in file: {file_path}")
-
-    if target_language in LANGUAGE_MAPPING:
-        target_language = LANGUAGE_MAPPING[target_language]
-
-    # Handle plural groups first (want to make sure any warnings shown are correctly attributed to plurals or non-plurals)
-    for group in root.findall('.//ns:group[@restype="x-gettext-plurals"]', namespaces=namespace):
-        plural_forms = {}
-        resname = None
-        for trans_unit in group.findall('ns:trans-unit', namespaces=namespace):
-            if resname is None:
-                resname = trans_unit.get('resname') or trans_unit.get('id')
-
-            target = trans_unit.find('ns:target', namespaces=namespace)
-            source = trans_unit.find('ns:source', namespaces=namespace)
-            context_group = trans_unit.find('ns:context-group', namespaces=namespace)
-
-            if context_group is not None:
-                plural_form = context_group.find('ns:context[@context-type="x-plural-form"]', namespaces=namespace)
-                if plural_form is not None:
-                    form = plural_form.text.split(':')[-1].strip().lower()
-
-                    if target is not None and target.text:
-                        plural_forms[form] = target.text
-                    elif source is not None and source.text:
-                        # If target is missing or empty, use source as a fallback
-                        plural_forms[form]  = source.text
-                        print(f"Warning: Using source text for plural form '{form}' of '{resname}' in '{target_language}' as target is missing or empty")
-
-        if resname and plural_forms:
-            translations[resname] = plural_forms
-
-    # Then handle non-plurals (ignore any existing values as they are plurals)
-    for trans_unit in root.findall('.//ns:trans-unit', namespaces=namespace):
-        resname = trans_unit.get('resname') or trans_unit.get('id')
-        if resname is None or resname in translations:
-            continue  # Skip entries without a resname/id and entries which already exist (ie. plurals)
-
-        target = trans_unit.find('ns:target', namespaces=namespace)
-        source = trans_unit.find('ns:source', namespaces=namespace)
-
-        if target is not None and target.text:
-            translations[resname] = target.text
-        elif source is not None and source.text:
-            # If target is missing or empty, use source as a fallback
-            translations[resname] = source.text
-            print(f"Warning: Using source text for '{resname}' in '{target_language}' as target is missing or empty")
-
-    return translations, target_language
-
-def convert_placeholders_for_plurals(translations: Dict[str,str], glossary_dict: Dict[str,str]):
-    # Replace {count} with %lld for iOS
-    converted_translations = {}
-    for form, value in translations.items():
-        converted_translations[form] = clean_string(value, False, glossary_dict if AUTO_REPLACE_STATIC_STRINGS else {}, {'{count}': '%lld'})
-
-    return converted_translations
+
+def get_mapped_language(lang_id: str) -> str | None:
+    """Map a language ID to its iOS equivalent, or return None if unsupported."""
+    if lang_id in LANGUAGE_MAPPING:
+        return LANGUAGE_MAPPING[lang_id]
+    return lang_id
+
+
+def convert_placeholders_for_plurals(forms: Dict[str, str], glossary_dict: Dict[str, str]) -> Dict[str, str]:
+    """Replace {count} with %lld for iOS plural forms."""
+    converted = {}
+    for form, value in forms.items():
+        converted[form] = clean_string(
+            value,
+            False,
+            glossary_dict if AUTO_REPLACE_STATIC_STRINGS else {},
+            {'{count}': '%lld'}
+        )
+    return converted
+
 
 def sort_dict_case_insensitive(data):
     if isinstance(data, dict):
@@ -127,49 +52,58 @@ def sort_dict_case_insensitive(data):
     else:
         return data
 
-def convert_xliff_to_string_catalog(input_dir, output_dir, source_language, target_languages, glossary_dict):
+
+def build_string_catalog(parsed_data: Dict[str, Any], glossary_dict: Dict[str, str]) -> Dict[str, Any]:
+    """
+    Build an Xcode String Catalog from pre-parsed translation data.
+    Args:
+        parsed_data: The pre-parsed translation data
+        glossary_dict: Dictionary of non-translatable strings
+    Returns:
+        String catalog dictionary ready for JSON serialization
+    """
     string_catalog = {
         "sourceLanguage": "en",
         "strings": {},
         "version": "1.0"
     }
-    target_mapped_languages = filter_and_map_language_ids(target_languages)
-    source_language['mapped_id'] = source_language['id']
-
-    # We need to sort the full language list (if the source language comes first rather than in alphabetical order
-    # then the output will differ from what Xcode generates)
-    all_languages = [source_language] + target_mapped_languages
-    sorted_languages = sorted(all_languages, key=lambda x: x['mapped_id'])
-
-    for language in sorted_languages:
-        lang_locale = language['locale']
-        input_file = os.path.join(input_dir, f"{lang_locale}.xliff")
 
-        if not os.path.exists(input_file):
-            raise FileNotFoundError(f"Could not find '{input_file}' in raw translations directory")
-
-        try:
-            translations, target_language = parse_xliff(input_file)
-        except Exception as e:
-            raise ValueError(f"Error processing locale {lang_locale}: {str(e)}")
-
-        print(f"\033[2K{Fore.WHITE}⏳ Converting translations for {target_language} to target format...{Style.RESET_ALL}", end='\r')
-
-        for resname, translation in translations.items():
+    locales = parsed_data['locales']
+    # Build list of languages with mapped IDs, filtering out unsupported ones
+    languages_with_mapping = []
+    for locale, locale_data in locales.items():
+        lang_info = locale_data['language_info']
+        mapped_id = get_mapped_language(lang_info['id'])
+        if mapped_id is not None:
+            languages_with_mapping.append({
+                'locale': locale,
+                'mapped_id': mapped_id,
+                'data': locale_data
+            })
+
+    # Sort languages alphabetically by mapped_id (Xcode does this)
+    languages_with_mapping.sort(key=lambda x: x['mapped_id'])
+
+    for lang in languages_with_mapping:
+        locale = lang['locale']
+        target_language = lang['mapped_id']
+        translations = lang['data']['translations']
+        print_progress(f"Converting translations for {target_language} to target format...")
+
+        for resname, trans_data in translations.items():
             if resname not in string_catalog["strings"]:
                 string_catalog["strings"][resname] = {
                     "extractionState": "manual",
                     "localizations": {}
                 }
 
-            if isinstance(translation, dict):  # It's a plural group
-                converted_translations = convert_placeholders_for_plurals(translation, glossary_dict)
-
-                # Check if any of the translations contain '{count}'
-                contains_count = any('{count}' in value for value in translation.values())
+            if trans_data['type'] == 'plural':
+                forms = trans_data['forms']
+                converted_forms = convert_placeholders_for_plurals(forms, glossary_dict)
 
+                contains_count = any('{count}' in value for value in forms.values())
                 if contains_count:
-                    # It's a standard plural which the code can switch off of using `{count}`
+                    # Standard plural using {count}
                     variations = {
                         "plural": {
                             form: {
@@ -177,12 +111,14 @@ def convert_xliff_to_string_catalog(input_dir, output_dir, source_language, targ
                                     "state": "translated",
                                     "value": value
                                 }
-                            } for form, value in converted_translations.items()
+                            } for form, value in converted_forms.items()
                         }
                     }
-                    string_catalog["strings"][resname]["localizations"][target_language] = {"variations": variations}
+                    string_catalog["strings"][resname]["localizations"][target_language] = {
+                        "variations": variations
+                    }
                 else:
-                    # Otherwise we need to use a custom format which uses just the `{count}` and replaces it with an entire string
+                    # Custom format using substitutions
                     string_catalog["strings"][resname]["localizations"][target_language] = {
                         "stringUnit": {
                             "state": "translated",
@@ -199,41 +135,46 @@ def convert_xliff_to_string_catalog(input_dir, output_dir, source_language, targ
                                                 "state": "translated",
                                                 "value": value
                                             }
-                                        } for form, value in converted_translations.items()
+                                        } for form, value in converted_forms.items()
                                     }
                                 }
                             }
                         }
                     }
             else:
+                # Regular string
+                value = trans_data['value']
                 string_catalog["strings"][resname]["localizations"][target_language] = {
                     "stringUnit": {
                         "state": "translated",
-                        "value": clean_string(translation, False, glossary_dict if AUTO_REPLACE_STATIC_STRINGS else {}, {})
+                        "value": clean_string(
+                            value,
+                            False,
+                            glossary_dict if AUTO_REPLACE_STATIC_STRINGS else {},
+                            {}
+                        )
                     }
                 }
 
-    # Note: Xcode sorts the strings in a case insensitive way so do the same here, apparently some versions of
-    # Python won't maintain insertion order once a dict is manipulated so we need to finalise the dict and then
-    # generate a correctly sorted one to be saved to disk
-    sorted_string_catalog = sort_dict_case_insensitive(string_catalog)
+    return sort_dict_case_insensitive(string_catalog)
 
+
+def write_string_catalog(string_catalog: Dict[str, Any], output_dir: str):
+    """Write the string catalog to disk."""
     output_file = os.path.join(output_dir, 'Localizable.xcstrings')
     os.makedirs(output_dir, exist_ok=True)
 
     with open(output_file, 'w', encoding='utf-8') as f:
-        # We need to add spaces around the `:` in the output beacuse Xcode inserts one when opening
-        # the `xcstrings` so if we don't then there is an absurd number of diffs...
-        json.dump(sorted_string_catalog, f, ensure_ascii=False, indent=2, separators=(',', ' : '))
+        # Add spaces around ':' to match Xcode's format
+        json.dump(string_catalog, f, ensure_ascii=False, indent=2, separators=(',', ' : '))
 
-def convert_non_translatable_strings_to_swift(input_file, output_paths):
-    glossary_dict = load_glossary_dict(input_file)
 
-    # Output the file in the desired format
+def generate_swift_constants(glossary_dict: Dict[str, str], output_paths: list):
+    """Generate Swift file with non-translatable string constants."""
     for path in output_paths:
         Path(path).parent.mkdir(parents=True, exist_ok=True)
         filename = os.path.basename(path)
-        enum_name, ext = os.path.splitext(filename)
+        enum_name, _ = os.path.splitext(filename)
 
         with open(path, 'w', encoding='utf-8') as file:
             file.write(f'// Copyright © {datetime.now().year} Rangeproof Pty Ltd. All rights reserved.\n')
@@ -242,33 +183,45 @@ def convert_non_translatable_strings_to_swift(input_file, output_paths):
             file.write('// stringlint:disable\n')
             file.write('\n')
             file.write(f'public enum {enum_name} {{\n')
-            for key in glossary_dict:
-                text = glossary_dict[key]
+
+            for key, text in glossary_dict.items():
                 cleaned_text = clean_string(text, False, glossary_dict, {})
                 file.write(f'    public static let {key}: String = "{cleaned_text}"\n')
 
             file.write('}\n')
 
-def convert_all_files(input_directory):
-    setup_values = setup_generation(input_directory)
-    source_language, rtl_languages, non_translatable_strings_file, target_languages = setup_values.values()
-    glossary_dict = load_glossary_dict(non_translatable_strings_file)
-    print(f"\033[2K{Fore.WHITE}⏳ Generating static strings file...{Style.RESET_ALL}", end='\r')
 
-    convert_non_translatable_strings_to_swift(non_translatable_strings_file, NON_TRANSLATABLE_STRINGS_OUTPUT_PATHS)
-    print(f"\033[2K{Fore.GREEN}✅ Static string generation complete{Style.RESET_ALL}")
+def main():
+    parser = argparse.ArgumentParser(
+        description='Convert parsed translations to Apple String Catalog.'
+    )
+    parser.add_argument(
+        'parsed_translations_file',
+        help='Path to the parsed translations JSON file'
+    )
+    parser.add_argument(
+        'translations_output_directory',
+        help='Directory to save the converted translation files'
+    )
+    parser.add_argument(
+        'non_translatable_strings_output_paths',
+        nargs='+',
+        help='Paths to save the non-translatable strings to'
+    )
+    args = parser.parse_args()
+
+    parsed_data = load_parsed_translations(args.parsed_translations_file)
+    glossary_dict = parsed_data['glossary']
+
+    print_progress("Generating static strings file...")
+    generate_swift_constants(glossary_dict, args.non_translatable_strings_output_paths)
+    print_success("Static string generation complete")
+
+    print_progress("Converting translations to target format...")
+    string_catalog = build_string_catalog(parsed_data, glossary_dict)
+    write_string_catalog(string_catalog, args.translations_output_directory)
+    print_success("All conversions complete")
 
-    # Convert the XLIFF data to the desired format
-    print(f"\033[2K{Fore.WHITE}⏳ Converting translations to target format...{Style.RESET_ALL}", end='\r')
-    convert_xliff_to_string_catalog(input_directory, TRANSLATIONS_OUTPUT_DIRECTORY, source_language, target_languages,glossary_dict)
-    print(f"\033[2K{Fore.GREEN}✅ All conversions complete{Style.RESET_ALL}")
 
 if __name__ == "__main__":
-    try:
-        convert_all_files(INPUT_DIRECTORY)
-    except KeyboardInterrupt:
-        print("\nProcess interrupted by user")
-        sys.exit(0)
-    except Exception as e:
-        print(f"\033[2K{Fore.RED}❌ An error occurred: {str(e)}")
-        sys.exit(1)
+    run_main(main)
diff --git a/crowdin/generate_shared.py b/crowdin/generate_shared.py
index ae22db8..8375440 100644
--- a/crowdin/generate_shared.py
+++ b/crowdin/generate_shared.py
@@ -1,10 +1,60 @@
-from typing import Dict, List
+from typing import Dict, List, Any
 import html
 import json
 import os
+import sys
 from colorama import Fore, Style
 
-def clean_string(text: str, is_android: bool, glossary_dict: Dict[str, str], extra_replace_dict :Dict[str,str]):
+
+def print_progress(message: str):
+    print(f"\033[2K{Fore.WHITE}⏳ {message}{Style.RESET_ALL}", end='\r')
+
+
+def print_success(message: str):
+    print(f"\033[2K{Fore.GREEN}✅ {message}{Style.RESET_ALL}")
+
+
+def print_error(message: str):
+    print(f"\033[2K{Fore.RED}❌ {message}{Style.RESET_ALL}")
+
+
+def print_warning(message: str):
+    print(f"\033[2K{Fore.YELLOW}⚠️  {message}{Style.RESET_ALL}")
+
+
+def run_main(main_func):
+    try:
+        main_func()
+    except KeyboardInterrupt:
+        print("\nProcess interrupted by user")
+        sys.exit(0)
+    except Exception as e:
+        print_error(f"An error occurred: {str(e)}")
+        sys.exit(1)
+
+
+def ensure_file_exists(file_path: str, description: str = "file"):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"Could not find {description}: '{file_path}'")
+
+
+def load_parsed_translations(input_file: str) -> Dict[str, Any]:
+    """
+    Load the pre-parsed translations JSON file.
+
+    Args:
+        input_file: Path to the parsed translations JSON file
+
+    Returns:
+        Dictionary containing parsed translation data
+    """
+    ensure_file_exists(input_file, "parsed translations file")
+
+    with open(input_file, 'r', encoding='utf-8') as f:
+        return json.load(f)
+
+
+def clean_string(text: str, is_android: bool, glossary_dict: Dict[str, str], extra_replace_dict: Dict[str, str]):
     if is_android:
         # Note: any changes done for all platforms needs most likely to be done on crowdin side.
         # So we don't want to replace -&gt; with → for instance, we want the crowdin strings to not have those at all.
@@ -21,7 +71,8 @@ def clean_string(text: str, is_android: bool, glossary_dict: Dict[str, str], ext
         text = text.replace("&lt;/span&gt;", '</font>')
         text = text.replace("<span>",        '<font color="0">')
         text = text.replace("</span>",       '</font>')
-        text = text.replace("&", "&amp;")   # Assume any remaining ampersands are desired
+        # Assume any remaining ampersands are desired
+        text = text.replace("&", "&amp;")
     else:
         text = html.unescape(text)          # Unescape any HTML escaping
 
@@ -29,7 +80,8 @@ def clean_string(text: str, is_android: bool, glossary_dict: Dict[str, str], ext
 
     # replace all the defined constants (from crowdin's glossary) in the string
     for glossary_key in glossary_dict:
-        text = text.replace("{" + glossary_key + "}", glossary_dict[glossary_key])
+        text = text.replace("{" + glossary_key + "}",
+                            glossary_dict[glossary_key])
 
     # if extra_replace_dict has keys, replace those too
     for extra_key in extra_replace_dict:
@@ -38,8 +90,7 @@ def clean_string(text: str, is_android: bool, glossary_dict: Dict[str, str], ext
 
 
 def load_glossary_dict(input_file: str) -> Dict[str, str]:
-    if not os.path.exists(input_file):
-        raise FileNotFoundError(f"Could not find '{input_file}' in raw translations directory")
+    ensure_file_exists(input_file, "glossary file")
 
     # Process the non-translatable string input
     non_translatable_strings_data = {}
@@ -57,28 +108,32 @@ def load_glossary_dict(input_file: str) -> Dict[str, str]:
 
 def setup_generation(input_directory: str):
     # Extract the project information
-    print(f"\033[2K{Fore.WHITE}⏳ Processing project info...{Style.RESET_ALL}", end='\r')
+    print_progress("Processing project info...")
     project_info_file = os.path.join(input_directory, "_project_info.json")
-    if not os.path.exists(project_info_file):
-        raise FileNotFoundError(f"Could not find '{project_info_file}' in raw translations directory")
+    ensure_file_exists(project_info_file, "project info file")
 
     project_details = {}
     with open(project_info_file, 'r', encoding="utf-8") as file:
         project_details = json.load(file)
 
-    non_translatable_strings_file = os.path.join(input_directory, "_non_translatable_strings.json")
+    non_translatable_strings_file = os.path.join(
+        input_directory, "_non_translatable_strings.json")
 
     # Extract the language info and sort the target languages alphabetically by locale
     source_language: str = project_details['data']['sourceLanguage']
     target_languages: List[str] = project_details['data']['targetLanguages']
     target_languages.sort(key=lambda x: x['locale'])
     num_languages = len(target_languages)
-    print(f"\033[2K{Fore.GREEN}✅ Project info processed, {num_languages} languages will be converted{Style.RESET_ALL}")
+    print_success(f"Project info processed, {
+                  num_languages} languages will be converted")
 
     # Convert the non-translatable strings to the desired format
-    rtl_languages: List[str] = [lang for lang in target_languages if lang["textDirection"] == "rtl"]
-
-    return {"source_language":source_language,
-            "rtl_languages": rtl_languages,
-            "non_translatable_strings_file":non_translatable_strings_file,
-            "target_languages": target_languages}
+    rtl_languages: List[str] = [
+        lang for lang in target_languages if lang["textDirection"] == "rtl"]
+
+    return {
+        "source_language": source_language,
+        "rtl_languages": rtl_languages,
+        "non_translatable_strings_file": non_translatable_strings_file,
+        "target_languages": target_languages
+    }
diff --git a/crowdin/parse_xliff.py b/crowdin/parse_xliff.py
new file mode 100644
index 0000000..b538156
--- /dev/null
+++ b/crowdin/parse_xliff.py
@@ -0,0 +1,607 @@
+import os
+import json
+import xml.etree.ElementTree as ET
+import sys
+import argparse
+import re
+from typing import Dict, List, Any, Set, Tuple
+from dataclasses import dataclass, field
+from colorama import Fore, Style
+from generate_shared import setup_generation, load_glossary_dict
+
+XLIFF_NAMESPACE = {'ns': 'urn:oasis:names:tc:xliff:document:1.2'}
+
+# Allowed HTML tags in translations
+ALLOWED_TAGS = {'b', 'br', 'span'}
+
+# Regex patterns for validation
+VARIABLE_PATTERN = re.compile(r'\{(\w+)\}')
+HTML_TAG_PATTERN = re.compile(r'<(/?)(\w+)([^>]*)>')
+
+
+@dataclass
+class ValidationIssue:
+    """Represents a single validation issue."""
+    locale: str
+    string_key: str
+    issue_type: str
+    message: str
+    severity: str = "error"  # "error" or "warning"
+
+
+@dataclass
+class ValidationResult:
+    issues: List[ValidationIssue] = field(default_factory=list)
+
+    def add_issue(self, locale: str, string_key: str, issue_type: str, message: str, severity: str = "error"):
+        self.issues.append(ValidationIssue(
+            locale, string_key, issue_type, message, severity))
+
+    def has_errors(self) -> bool:
+        return any(issue.severity == "error" for issue in self.issues)
+
+    def get_error_count(self) -> int:
+        return sum(1 for issue in self.issues if issue.severity == "error")
+
+    def get_warning_count(self) -> int:
+        return sum(1 for issue in self.issues if issue.severity == "warning")
+
+    def get_issues_by_type(self) -> Dict[str, List[ValidationIssue]]:
+        by_type = {}
+        for issue in self.issues:
+            if issue.issue_type not in by_type:
+                by_type[issue.issue_type] = []
+            by_type[issue.issue_type].append(issue)
+        return by_type
+
+    def get_issues_by_locale(self) -> Dict[str, List[ValidationIssue]]:
+        by_locale = {}
+        for issue in self.issues:
+            if issue.locale not in by_locale:
+                by_locale[issue.locale] = []
+            by_locale[issue.locale].append(issue)
+        return by_locale
+
+
+def extract_variables(text: str) -> Set[str]:
+    """Extract all {variable} placeholders from a string."""
+    return set(VARIABLE_PATTERN.findall(text))
+
+
+def extract_tags(text: str) -> Dict[str, int]:
+    """
+    Extract HTML tags from a string and count them.
+    Returns a dict like {'b': 2, 'br': 1, 'span': 1}
+    """
+    tag_counts = {}
+    for match in HTML_TAG_PATTERN.finditer(text):
+        tag_name = match.group(2).lower()
+        tag_counts[tag_name] = tag_counts.get(tag_name, 0) + 1
+    return tag_counts
+
+
+def get_string_value(trans_data: Dict[str, Any]) -> str:
+    """
+    Get the string value from translation data,
+    handling both regular strings and plurals.
+    """
+    if trans_data['type'] == 'plural':
+        # For plurals, combine all forms for validation
+        return ' '.join(trans_data['forms'].values())
+    else:
+        return trans_data['value']
+
+
+def get_all_string_values(trans_data: Dict[str, Any]) -> List[Tuple[str, str]]:
+    """
+    Get all string values from translation data with their context.
+    Returns list of (context, value) tuples.
+    """
+    if trans_data['type'] == 'plural':
+        return [(f"plural.{form}", value) for form, value in trans_data['forms'].items()]
+    else:
+        return [("value", trans_data['value'])]
+
+
+def find_disallowed_tags(text: str) -> List[str]:
+    """Find any HTML tags that are not in the allowed list."""
+    disallowed = []
+    for match in HTML_TAG_PATTERN.finditer(text):
+        tag_name = match.group(2).lower()
+        if tag_name not in ALLOWED_TAGS:
+            disallowed.append(match.group(0))
+    return disallowed
+
+
+def find_invalid_angle_brackets(text: str) -> List[str]:
+    """
+    Find invalid uses of angle brackets that don't form valid tags.
+    Only flags '<' that doesn't start a valid tag.
+    Standalone '>' is allowed (e.g., "{name} > {conversation_name}").
+    """
+    issues = []
+
+    i = 0
+    while i < len(text):
+        if text[i] == '<':
+            # Check if this is a valid tag start
+            remaining = text[i:]
+            # Valid patterns: <b>, </b>, <br/>, <span>, </span>
+            valid_tag = re.match(
+                r'</?(?:b|br|span)(?:\s*/)?>', remaining, re.IGNORECASE)
+            if not valid_tag:
+                # Extract context for error message
+                snippet = text[i:i+15] + ('...' if len(text) > i+15 else '')
+                issues.append(f"Invalid '<' at position {i}: '{snippet}'")
+        i += 1
+
+    return issues
+
+
+def find_invalid_braces(text: str) -> List[str]:
+    """
+    Find invalid uses of curly braces that don't form valid variables.
+    Valid: {variable_name}
+    Invalid: {}, {123}, { space }, lone { or }
+    """
+    issues = []
+
+    i = 0
+    while i < len(text):
+        if text[i] == '{':
+            # Find matching }
+            end = text.find('}', i)
+            if end == -1:
+                issues.append(f"Unmatched '{{' at position {i}")
+                i += 1
+                continue
+
+            content = text[i+1:end]
+            # Check if content is a valid variable name (alphanumeric + underscore)
+            if not re.match(r'^\w+$', content):
+                snippet = text[i:end+1]
+                issues.append(f"Invalid variable syntax '{
+                              snippet}' at position {i}")
+
+            i = end + 1
+        elif text[i] == '}':
+            # Check if there's a matching { before
+            before = text[:i]
+            last_open = before.rfind('{')
+            if last_open == -1:
+                issues.append(f"Unmatched '}}' at position {i}")
+            i += 1
+        else:
+            i += 1
+
+    return issues
+
+
+def validate_all_translations(parsed_locales: Dict[str, Any], source_locale: str) -> ValidationResult:
+    """
+    Validate all translations against the source locale (English).
+
+    Checks:
+    1. All NON-PLURAL strings in all locales have the same variables as English
+    2. No locale has extra strings vs English
+    3. No invalid curly braces (must be valid {variable} format) - checked for ALL strings
+    4. All tags are valid: <br/> <b></b> <span></span> - checked for ALL strings
+
+    Note: Plural strings are only checked for syntax validity (3, 4), NOT for variable/tag
+    matching with English, because different languages have different plural forms
+    (e.g., English has 2 forms, Arabic has 6, Russian has 4).
+    """
+    result = ValidationResult()
+
+    if source_locale not in parsed_locales:
+        result.add_issue(source_locale, "", "missing_source",
+                         f"Source locale '{source_locale}' not found")
+        return result
+
+    source_translations = parsed_locales[source_locale]['translations']
+    source_keys = set(source_translations.keys())
+
+    # Extract variables and tags from source strings (non-plurals only)
+    source_variables = {}
+    source_tags = {}
+    for key, trans_data in source_translations.items():
+        # Only track variables/tags for non-plural strings
+        if trans_data['type'] != 'plural':
+            text = trans_data['value']
+            source_variables[key] = extract_variables(text)
+            source_tags[key] = extract_tags(text)
+
+    # Validate each locale
+    for locale, locale_data in parsed_locales.items():
+        translations = locale_data['translations']
+        locale_keys = set(translations.keys())
+
+        # Check 2: No extra keys vs English
+        extra_keys = locale_keys - source_keys
+        for key in extra_keys:
+            result.add_issue(
+                locale, key, "extra_key",
+                f"String '{key}' exists in {locale} but not in source locale"
+            )
+
+        # Validate each string
+        for key, trans_data in translations.items():
+            # Skip if this is an extra key (already reported)
+            if key not in source_keys:
+                continue
+
+            is_plural = trans_data['type'] == 'plural'
+
+            # Get all string values (handles plurals)
+            string_values = get_all_string_values(trans_data)
+
+            for context, text in string_values:
+                full_key = f"{key}" if context == "value" else f"{
+                    key} ({context})"
+
+                # Check 1: Variables match source (NON-PLURALS ONLY)
+                # Plurals are skipped because different languages have different plural forms
+                if not is_plural and key in source_variables:
+                    text_variables = extract_variables(text)
+                    source_vars = source_variables[key]
+
+                    missing_vars = source_vars - text_variables
+                    extra_vars = text_variables - source_vars
+
+                    if missing_vars:
+                        result.add_issue(
+                            locale, full_key, "missing_variable",
+                            f"Missing variables: {{{
+                                ', '.join(sorted(missing_vars))}}}"
+                        )
+
+                    if extra_vars:
+                        result.add_issue(
+                            locale, full_key, "extra_variable",
+                            f"Extra variables not in source: {{{
+                                ', '.join(sorted(extra_vars))}}}"
+                        )
+
+                # Check 3: Invalid curly braces (ALL strings including plurals)
+                brace_issues = find_invalid_braces(text)
+                for issue in brace_issues:
+                    result.add_issue(
+                        locale, full_key, "invalid_braces",
+                        issue
+                    )
+
+                # Check 4a: Disallowed tags (ALL strings including plurals)
+                disallowed = find_disallowed_tags(text)
+                for tag in disallowed:
+                    result.add_issue(
+                        locale, full_key, "disallowed_tag",
+                        f"Disallowed HTML tag: {tag}"
+                    )
+
+                # Check 4b: Invalid angle brackets / malformed tags (ALL strings including plurals)
+                angle_issues = find_invalid_angle_brackets(text)
+                for issue in angle_issues:
+                    result.add_issue(
+                        locale, full_key, "invalid_tag",
+                        issue
+                    )
+
+                # Check 4c: Tag count mismatch with source (NON-PLURALS ONLY, non-source locales)
+                # Plurals are skipped for the same reason as variables
+                if not is_plural and locale != source_locale and key in source_tags:
+                    text_tags = extract_tags(text)
+                    source_tag_counts = source_tags[key]
+
+                    for tag, source_count in source_tag_counts.items():
+                        locale_count = text_tags.get(tag, 0)
+                        if locale_count < source_count:
+                            result.add_issue(
+                                locale, full_key, "missing_tag",
+                                f"Missing <{tag}> tags: expected {
+                                    source_count}, found {locale_count}",
+                                severity="warning"
+                            )
+
+    return result
+
+
+def print_validation_summary(result: ValidationResult):
+    if not result.issues:
+        print(f"{Fore.GREEN}✅ All validations passed{Style.RESET_ALL}")
+        return
+
+    error_count = result.get_error_count()
+    warning_count = result.get_warning_count()
+
+    print(f"\n{Fore.YELLOW}{'='*60}{Style.RESET_ALL}")
+    print(f"{Fore.YELLOW}Validation Summary{Style.RESET_ALL}")
+    print(f"{Fore.YELLOW}{'='*60}{Style.RESET_ALL}")
+
+    by_type = result.get_issues_by_type()
+    for issue_type, issues in sorted(by_type.items()):
+        error_issues = [i for i in issues if i.severity == "error"]
+        warning_issues = [i for i in issues if i.severity == "warning"]
+
+        type_display = issue_type.replace('_', ' ').title()
+        if error_issues:
+            print(f"{Fore.RED}  {type_display}: {
+                  len(error_issues)} errors{Style.RESET_ALL}")
+        if warning_issues:
+            print(f"{Fore.YELLOW}  {type_display}: {
+                  len(warning_issues)} warnings{Style.RESET_ALL}")
+
+    print(f"\n{Fore.YELLOW}Issues by locale:{Style.RESET_ALL}")
+    by_locale = result.get_issues_by_locale()
+    for locale, issues in sorted(by_locale.items()):
+        errors = [i for i in issues if i.severity == "error"]
+        warnings = [i for i in issues if i.severity == "warning"]
+        if errors or warnings:
+            error_str = f"{len(errors)} errors" if errors else ""
+            warning_str = f"{len(warnings)} warnings" if warnings else ""
+            counts = ", ".join(filter(None, [error_str, warning_str]))
+            print(f"  [{locale}] {counts}")
+
+            # Print first few issues for this locale
+            for issue in issues[:3]:
+                color = Fore.RED if issue.severity == "error" else Fore.YELLOW
+                print(
+                    f"    {color}- {issue.string_key}: {issue.message}{Style.RESET_ALL}")
+            if len(issues) > 3:
+                print(f"    ... and {len(issues) - 3} more")
+
+    print(f"\n{Fore.YELLOW}{'='*60}{Style.RESET_ALL}")
+    total_str = f"{Fore.RED}{error_count} errors{
+        Style.RESET_ALL}" if error_count else ""
+    warning_str = f"{Fore.YELLOW}{warning_count} warnings{
+        Style.RESET_ALL}" if warning_count else ""
+    print(f"Total: {', '.join(filter(None, [total_str, warning_str]))}")
+    print(f"{Fore.YELLOW}{'='*60}{Style.RESET_ALL}\n")
+
+
+def parse_xliff_file(file_path: str, warn_on_missing_target: bool = True) -> Dict[str, Any]:
+    """
+    Parse a single XLIFF file and return translations as a dictionary.
+
+    Args:
+        file_path: Path to the XLIFF file
+        warn_on_missing_target: If True, print warnings when target is missing and source is used
+
+    Returns:
+        Dictionary with 'translations' and 'target_language' keys
+    """
+    tree = ET.parse(file_path)
+    root = tree.getroot()
+    translations = {}
+
+    file_elem = root.find('ns:file', namespaces=XLIFF_NAMESPACE)
+    if file_elem is None:
+        raise ValueError(f"Invalid XLIFF structure in file: {file_path}")
+
+    target_language = file_elem.get('target-language')
+    if target_language is None:
+        raise ValueError(f"Missing target-language in file: {file_path}")
+
+    # Handle plural groups first
+    for group in root.findall('.//ns:group[@restype="x-gettext-plurals"]', namespaces=XLIFF_NAMESPACE):
+        plural_forms = {}
+        resname = None
+
+        for trans_unit in group.findall('ns:trans-unit', namespaces=XLIFF_NAMESPACE):
+            if resname is None:
+                resname = trans_unit.get('resname') or trans_unit.get('id')
+
+            target = trans_unit.find('ns:target', namespaces=XLIFF_NAMESPACE)
+            source = trans_unit.find('ns:source', namespaces=XLIFF_NAMESPACE)
+            context_group = trans_unit.find(
+                'ns:context-group', namespaces=XLIFF_NAMESPACE)
+
+            if context_group is not None:
+                plural_form_elem = context_group.find(
+                    'ns:context[@context-type="x-plural-form"]',
+                    namespaces=XLIFF_NAMESPACE
+                )
+                if plural_form_elem is not None:
+                    form = plural_form_elem.text.split(':')[-1].strip().lower()
+
+                    if target is not None and target.text:
+                        plural_forms[form] = target.text
+                    elif source is not None and source.text:
+                        plural_forms[form] = source.text
+                        if warn_on_missing_target:
+                            print(f"Warning: Using source text for plural form '{form}' of "
+                                  f"'{resname}' in '{target_language}' as target is missing or empty")
+
+        if resname and plural_forms:
+            translations[resname] = {
+                'type': 'plural',
+                'forms': plural_forms
+            }
+
+    # Handle non-plural translations (skip entries already processed as plurals)
+    for trans_unit in root.findall('.//ns:trans-unit', namespaces=XLIFF_NAMESPACE):
+        resname = trans_unit.get('resname') or trans_unit.get('id')
+        if resname is None or resname in translations:
+            continue
+
+        target = trans_unit.find('ns:target', namespaces=XLIFF_NAMESPACE)
+        source = trans_unit.find('ns:source', namespaces=XLIFF_NAMESPACE)
+
+        if target is not None and target.text:
+            translations[resname] = {
+                'type': 'string',
+                'value': target.text
+            }
+        elif source is not None and source.text:
+            translations[resname] = {
+                'type': 'string',
+                'value': source.text
+            }
+            if warn_on_missing_target:
+                print(f"Warning: Using source text for '{resname}' in "
+                      f"'{target_language}' as target is missing or empty")
+
+    return {
+        'translations': translations,
+        'target_language': target_language
+    }
+
+
+def parse_all_xliff_files(input_directory: str, skip_validation: bool = False) -> Tuple[Dict[str, Any], ValidationResult]:
+    """
+    Parse all XLIFF files in the input directory and return a combined result.
+
+    Args:
+        input_directory: Directory containing XLIFF files and project info
+        skip_validation: If True, skip validation step
+
+    Returns:
+        Tuple of (parsed data dict, validation result)
+    """
+    setup_values = setup_generation(input_directory)
+    source_language = setup_values['source_language']
+    rtl_languages = setup_values['rtl_languages']
+    non_translatable_strings_file = setup_values['non_translatable_strings_file']
+    target_languages = setup_values['target_languages']
+
+    glossary_dict = load_glossary_dict(non_translatable_strings_file)
+
+    all_languages = [source_language] + target_languages
+    parsed_locales = {}
+
+    for language in all_languages:
+        lang_locale = language['locale']
+        input_file = os.path.join(input_directory, f"{lang_locale}.xliff")
+
+        if not os.path.exists(input_file):
+            raise FileNotFoundError(
+                f"Could not find '{input_file}' in raw translations directory")
+
+        print(f"\033[2K{Fore.WHITE}⏳ Parsing {
+              lang_locale}...{Style.RESET_ALL}", end='\r')
+
+        try:
+            result = parse_xliff_file(input_file)
+            translations = result['translations']
+            target_language = result['target_language']
+
+            parsed_locales[lang_locale] = {
+                'target_language': target_language,
+                'translations': translations,
+                'language_info': language
+            }
+
+        except Exception as e:
+            raise ValueError(f"Error processing locale {
+                             lang_locale}: {str(e)}")
+
+    print(f"\033[2K{Fore.GREEN}✅ Parsed {
+          len(parsed_locales)} locale files{Style.RESET_ALL}")
+
+    # Run validation
+    validation_result = ValidationResult()
+    if not skip_validation:
+        print(f"{Fore.WHITE}⏳ Validating translations...{
+              Style.RESET_ALL}", end='\r')
+        source_locale = source_language['locale']
+        validation_result = validate_all_translations(
+            parsed_locales, source_locale)
+
+        if validation_result.issues:
+            print(f"\033[2K{Fore.YELLOW}⚠️  Validation completed with issues{
+                  Style.RESET_ALL}")
+        else:
+            print(f"\033[2K{Fore.GREEN}✅ Validation passed{Style.RESET_ALL}")
+
+    parsed_data = {
+        'source_language': source_language,
+        'target_languages': target_languages,
+        'rtl_languages': rtl_languages,
+        'glossary': glossary_dict,
+        'locales': parsed_locales
+    }
+
+    return parsed_data, validation_result
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Parse XLIFF translation files into an intermediate JSON format'
+    )
+    parser.add_argument(
+        'raw_translations_directory',
+        help='Directory which contains the raw translation files'
+    )
+    parser.add_argument(
+        'output_file',
+        help='Path to save the parsed translations JSON file'
+    )
+    parser.add_argument(
+        '--skip-validation',
+        action='store_true',
+        help='Skip validation of translations'
+    )
+    parser.add_argument(
+        '--error-on-validation-failure',
+        action='store_true',
+        help='Exit with error code if validation fails'
+    )
+    parser.add_argument(
+        '--validation-report',
+        help='Path to save validation report JSON file'
+    )
+    args = parser.parse_args()
+
+    try:
+        parsed_data, validation_result = parse_all_xliff_files(
+            args.raw_translations_directory,
+            skip_validation=args.skip_validation
+        )
+
+        if not args.skip_validation:
+            print_validation_summary(validation_result)
+
+        if args.validation_report and validation_result.issues:
+            report = {
+                'error_count': validation_result.get_error_count(),
+                'warning_count': validation_result.get_warning_count(),
+                'issues': [
+                    {
+                        'locale': issue.locale,
+                        'string_key': issue.string_key,
+                        'issue_type': issue.issue_type,
+                        'message': issue.message,
+                        'severity': issue.severity
+                    }
+                    for issue in validation_result.issues
+                ]
+            }
+            os.makedirs(os.path.dirname(args.validation_report)
+                        or '.', exist_ok=True)
+            with open(args.validation_report, 'w', encoding='utf-8') as f:
+                json.dump(report, f, ensure_ascii=False, indent=2)
+            print(f"{Fore.WHITE}Validation report saved to {
+                  args.validation_report}{Style.RESET_ALL}")
+
+        os.makedirs(os.path.dirname(args.output_file) or '.', exist_ok=True)
+        with open(args.output_file, 'w', encoding='utf-8') as f:
+            json.dump(parsed_data, f, ensure_ascii=False, indent=2)
+
+        print(f"{Fore.GREEN}✅ Parsed translations saved to {
+              args.output_file}{Style.RESET_ALL}")
+
+        if args.error_on_validation_failure and validation_result.has_errors():
+            print(f"{Fore.RED}❌ Exiting with error due to validation failures{
+                  Style.RESET_ALL}")
+            sys.exit(1)
+
+    except KeyboardInterrupt:
+        print("\nProcess interrupted by user")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\033[2K{Fore.RED}❌ An error occurred: {
+              str(e)}{Style.RESET_ALL}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()