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()