first

README.md

@@ -1,6 +1,6 @@
 ---
 title: Speech Resource Finder
-emoji: 🦀
+emoji: 🧭
 colorFrom: gray
 colorTo: pink
 sdk: gradio
@@ -10,4 +10,46 @@ pinned: false
 short_description: 'Discover ASR and TTS support and resources for any language '
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Speech Resource Finder
+
+## Description
+
+Almost 4 billion people speak languages with little or no speech technology support. This tool makes visible which languages have resources available and which communities are being left behind in the speech AI revolution.
+
+Built by CLEAR Global to support language inclusion and help close the digital language divide.
+
+## Data Sources
+
+### Commercial Speech Services
+
+Commercial service support is automatically pulled from the language support page of each service provider.
+
+- **Azure Speech Services** - [Speech-to-Text](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=stt) | [Text-to-Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)
+- **Google Cloud Speech** - [Speech-to-Text](https://cloud.google.com/speech-to-text/docs/speech-to-text-supported-languages) | [Text-to-Speech](https://cloud.google.com/text-to-speech/docs/voices)
+- **AWS** - [Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html) | [Polly](https://docs.aws.amazon.com/polly/latest/dg/supported-languages.html)
+- **ElevenLabs** - [Multilingual v2](https://elevenlabs.io/docs/models#multilingual-v2) | [Turbo v3](https://elevenlabs.io/docs/models#eleven-v3-alpha)
+
+### Open Source Resources
+- **HuggingFace Models** - Pre-trained speech models sorted by downloads
+  - [ASR Models](https://huggingface.co/models?pipeline_tag=automatic-speech-recognition)
+  - [TTS Models](https://huggingface.co/models?pipeline_tag=text-to-speech)
+- **HuggingFace Datasets** - Speech corpora for training and evaluation
+  - [ASR Datasets](https://huggingface.co/datasets?task_categories=task_categories:automatic-speech-recognition)
+  - [TTS Datasets](https://huggingface.co/datasets?task_categories=task_categories:text-to-speech)
+
+## How to Use
+1. Select a language from the dropdown (type to search by name or ISO code)
+2. Toggle model deduplication if desired (enabled by default)
+3. Review results: commercial availability, models, and datasets
+4. Click model/dataset names to open on HuggingFace
+
+## Disclaimer
+
+- Currently lists only 487 languages and is taken from this [Github repository](https://github.com/datasets/language-codes).
+- Data fetched in real-time and can change.
+- This is not an exhaustive list. There are other commercial voice technology providers and dataset/model resources that this app doesn't cover.
+- Deduplication discards models with same name uploaded by others and keeps the most downloaded version in the list.
+
+## Feedback
+
+We would love to hear your feedback and suggestions. Please write us at tech@clearglobal.org. 

app.py

@@ -0,0 +1,1303 @@
+import gradio as gr
+import pandas as pd
+import requests
+from bs4 import BeautifulSoup
+from functools import lru_cache
+import csv
+from io import StringIO
+import re
+
+# Configuration
+LANGUAGE_CODES_FILE = "language-codes-full.csv"
+APP_CONTENT_FILE = "app_content.md"
+
+# Language list will be loaded from CSV
+# Structure: {alpha3_b: {"name": str, "alpha3_t": str, "alpha2": str}}
+LANGUAGES = {}
+
+# App content will be loaded from markdown file
+APP_CONTENT = {
+    "title": "Speech Resource Finder",
+    "description": "Search for speech resources",
+    "full_content": ""
+}
+
+def load_app_content(content_path=None):
+    """Load app content from markdown file"""
+    global APP_CONTENT
+    if content_path is None:
+        content_path = APP_CONTENT_FILE
+
+    try:
+        with open(content_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+
+        # Parse markdown content
+        lines = content.split('\n')
+
+        # Extract title (first # heading)
+        title = "Speech Resource Finder"
+        for line in lines:
+            if line.startswith('# '):
+                title = line[2:].strip()
+                break
+
+        # Extract description (text after ## Description until next ##)
+        description = ""
+        in_description = False
+        for line in lines:
+            if line.startswith('## Description'):
+                in_description = True
+                continue
+            elif in_description and line.startswith('##'):
+                break
+            elif in_description and line.strip():
+                description += line.strip() + " "
+
+        APP_CONTENT = {
+            "title": title,
+            "description": description.strip(),
+            "full_content": content
+        }
+        print(f"Loaded app content from {content_path}")
+    except Exception as e:
+        print(f"Error loading app content: {e}")
+        print("Using default content")
+
+def load_language_list(csv_path=None):
+    """Load ISO 639 language codes from CSV file"""
+    global LANGUAGES
+    if csv_path is None:
+        csv_path = LANGUAGE_CODES_FILE
+
+    try:
+        with open(csv_path, 'r', encoding='utf-8') as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                # Use alpha3-b as primary key, fallback to alpha3-t if empty
+                code_b = row['alpha3-b'].strip()
+                code_t = row['alpha3-t'].strip()
+                code_2 = row['alpha2'].strip()
+                name = row['English'].strip()
+
+                primary_code = code_b if code_b else code_t
+
+                if primary_code and name:
+                    LANGUAGES[primary_code] = {
+                        "name": name,
+                        "alpha3_b": code_b,
+                        "alpha3_t": code_t,
+                        "alpha2": code_2
+                    }
+        print(f"Loaded {len(LANGUAGES)} languages from {csv_path}")
+    except Exception as e:
+        print(f"Error loading language list: {e}")
+        # Fallback to a minimal set
+        LANGUAGES = {
+            "eng": {"name": "English", "alpha3_b": "eng", "alpha3_t": "", "alpha2": "en"},
+            "spa": {"name": "Spanish", "alpha3_b": "spa", "alpha3_t": "", "alpha2": "es"},
+            "fra": {"name": "French", "alpha3_b": "fra", "alpha3_t": "", "alpha2": "fr"},
+            "deu": {"name": "German", "alpha3_b": "ger", "alpha3_t": "deu", "alpha2": "de"},
+        }
+        print(f"Using fallback with {len(LANGUAGES)} languages")
+
+@lru_cache(maxsize=1)
+def fetch_azure_asr_languages():
+    """Scrape Azure Speech-to-Text supported languages"""
+    url = "https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=stt"
+    
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Find the table with locale data
+        # The table has columns: Locale (BCP-47) | Language | Fast transcription support | Custom speech support
+        tables = soup.find_all('table')
+        
+        azure_asr = {}
+        for table in tables:
+            rows = table.find_all('tr')
+            if not rows:
+                continue
+                
+            # Check if this is the right table by looking at headers
+            headers = [th.get_text(strip=True) for th in rows[0].find_all('th')]
+            if 'Locale' in ' '.join(headers) or 'Language' in ' '.join(headers):
+                for row in rows[1:]:  # Skip header
+                    cols = row.find_all('td')
+                    if len(cols) >= 2:
+                        locale = cols[0].get_text(strip=True)
+                        language = cols[1].get_text(strip=True)
+                        if locale and language:
+                            azure_asr[locale] = language
+                break
+        
+        return azure_asr
+    except Exception as e:
+        print(f"Error fetching Azure ASR data: {e}")
+        return {}
+
+@lru_cache(maxsize=1)
+def fetch_azure_tts_languages():
+    """Scrape Azure Text-to-Speech supported languages with voice counts"""
+    url = "https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts"
+
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Find the TTS table
+        # Columns: Locale (BCP-47) | Language | Text to speech voices
+        tables = soup.find_all('table')
+
+        azure_tts = {}
+        for table in tables:
+            rows = table.find_all('tr')
+            if not rows:
+                continue
+
+            headers = [th.get_text(strip=True) for th in rows[0].find_all('th')]
+            if 'Text to speech' in ' '.join(headers) or 'voices' in ' '.join(headers).lower():
+                for row in rows[1:]:
+                    cols = row.find_all('td')
+                    if len(cols) >= 3:
+                        locale = cols[0].get_text(strip=True)
+                        language = cols[1].get_text(strip=True)
+                        voices_text = cols[2].get_text(strip=True)
+                        # Count number of voices (look for "Neural" in the text)
+                        voice_count = voices_text.count('Neural')
+                        if locale and language:
+                            azure_tts[locale] = {
+                                'language': language,
+                                'voice_count': voice_count
+                            }
+                break
+
+        return azure_tts
+    except Exception as e:
+        print(f"Error fetching Azure TTS data: {e}")
+        return {}
+
+@lru_cache(maxsize=1)
+def fetch_google_stt_languages():
+    """Scrape Google Cloud Speech-to-Text supported languages"""
+    url = "https://cloud.google.com/speech-to-text/docs/speech-to-text-supported-languages"
+
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Find tables with BCP-47 language codes
+        tables = soup.find_all('table')
+
+        google_stt = {}
+        for table in tables:
+            rows = table.find_all('tr')
+            if not rows:
+                continue
+
+            # Check if this table has BCP-47 column
+            headers = [th.get_text(strip=True) for th in rows[0].find_all('th')]
+
+            # Find BCP-47 column index
+            bcp47_idx = None
+            name_idx = None
+            for idx, header in enumerate(headers):
+                if 'BCP-47' in header or 'BCP47' in header:
+                    bcp47_idx = idx
+                if 'Name' in header and name_idx is None:
+                    name_idx = idx
+
+            if bcp47_idx is not None:
+                for row in rows[1:]:  # Skip header
+                    cols = row.find_all('td')
+                    if len(cols) > bcp47_idx:
+                        locale = cols[bcp47_idx].get_text(strip=True)
+                        language = cols[name_idx].get_text(strip=True) if name_idx and len(cols) > name_idx else ''
+                        if locale and locale not in ['—', '-', '']:
+                            google_stt[locale] = language
+
+        return google_stt
+    except Exception as e:
+        print(f"Error fetching Google STT data: {e}")
+        return {}
+
+@lru_cache(maxsize=1)
+def fetch_google_tts_languages():
+    """Scrape Google Cloud Text-to-Speech supported languages with voice counts"""
+    url = "https://cloud.google.com/text-to-speech/docs/voices"
+
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Find the voices table
+        # Columns: Language | Voice type | Language code | Voice name | SSML Gender | Sample
+        tables = soup.find_all('table')
+
+        google_tts = {}
+        for table in tables:
+            rows = table.find_all('tr')
+            if not rows:
+                continue
+
+            headers = [th.get_text(strip=True) for th in rows[0].find_all('th')]
+
+            # Find Language code column index
+            lang_code_idx = None
+            for idx, header in enumerate(headers):
+                if 'Language code' in header or 'language code' in header.lower():
+                    lang_code_idx = idx
+                    break
+
+            if lang_code_idx is not None:
+                for row in rows[1:]:
+                    cols = row.find_all('td')
+                    if len(cols) > lang_code_idx:
+                        locale = cols[lang_code_idx].get_text(strip=True)
+                        if locale and locale not in ['—', '-', '']:
+                            # Count voices per locale
+                            if locale in google_tts:
+                                google_tts[locale]['voice_count'] += 1
+                            else:
+                                language = cols[0].get_text(strip=True) if len(cols) > 0 else ''
+                                google_tts[locale] = {
+                                    'language': language,
+                                    'voice_count': 1
+                                }
+
+        return google_tts
+    except Exception as e:
+        print(f"Error fetching Google TTS data: {e}")
+        return {}
+
+@lru_cache(maxsize=1)
+def fetch_elevenlabs_multilingual_v2():
+    """Get ElevenLabs Multilingual v2 supported languages"""
+    # Based on https://elevenlabs.io/docs/models#multilingual-v2
+    # These are ISO 639-1 (2-letter) codes
+    supported_codes = {
+        'en', 'ja', 'zh', 'de', 'hi', 'fr', 'ko', 'pt', 'it', 'es',
+        'id', 'nl', 'tr', 'fil', 'pl', 'sv', 'bg', 'ro', 'ar', 'cs',
+        'el', 'fi', 'hr', 'ms', 'sk', 'da', 'ta', 'uk', 'ru'
+    }
+    return supported_codes
+
+@lru_cache(maxsize=1)
+def fetch_elevenlabs_turbo_v3():
+    """Get ElevenLabs Eleven Turbo v3 (formerly v3 Alpha) supported languages"""
+    # Based on https://elevenlabs.io/docs/models#eleven-v3-alpha
+    # These are ISO 639-3 (3-letter) codes
+    supported_codes = {
+        'afr', 'ara', 'hye', 'asm', 'aze', 'bel', 'ben', 'bos', 'bul', 'cat',
+        'ceb', 'nya', 'hrv', 'ces', 'dan', 'nld', 'eng', 'est', 'fil', 'fin',
+        'fra', 'glg', 'kat', 'deu', 'ell', 'guj', 'hau', 'heb', 'hin', 'hun',
+        'isl', 'ind', 'gle', 'ita', 'jpn', 'jav', 'kan', 'kaz', 'kir', 'kor',
+        'lav', 'lin', 'lit', 'ltz', 'mkd', 'msa', 'mal', 'cmn', 'mar', 'nep',
+        'nor', 'pus', 'fas', 'pol', 'por', 'pan', 'ron', 'rus', 'srp', 'snd',
+        'slk', 'slv', 'som', 'spa', 'swa', 'swe', 'tam', 'tel', 'tha', 'tur',
+        'ukr', 'urd', 'vie', 'cym'
+    }
+    return supported_codes
+
+@lru_cache(maxsize=1)
+def fetch_aws_transcribe_languages():
+    """Scrape AWS Transcribe (ASR) supported languages"""
+    url = "https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html"
+
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Find tables with language codes
+        tables = soup.find_all('table')
+
+        aws_transcribe = {}
+        for table in tables:
+            rows = table.find_all('tr')
+            if not rows:
+                continue
+
+            # Check if this table has language code column
+            headers = [th.get_text(strip=True) for th in rows[0].find_all('th')]
+
+            # Find language code column index
+            lang_code_idx = None
+            lang_name_idx = None
+            for idx, header in enumerate(headers):
+                if 'Language code' in header or 'language code' in header.lower():
+                    lang_code_idx = idx
+                if 'Language' == header or header.startswith('Language'):
+                    lang_name_idx = idx
+
+            if lang_code_idx is not None:
+                for row in rows[1:]:  # Skip header
+                    cols = row.find_all('td')
+                    if len(cols) > lang_code_idx:
+                        locale = cols[lang_code_idx].get_text(strip=True)
+                        language = cols[lang_name_idx].get_text(strip=True) if lang_name_idx and len(cols) > lang_name_idx else ''
+                        if locale and locale not in ['—', '-', '']:
+                            aws_transcribe[locale] = language
+
+        return aws_transcribe
+    except Exception as e:
+        print(f"Error fetching AWS Transcribe data: {e}")
+        return {}
+
+@lru_cache(maxsize=1)
+def fetch_aws_polly_languages():
+    """Scrape AWS Polly (TTS) supported languages"""
+    url = "https://docs.aws.amazon.com/polly/latest/dg/supported-languages.html"
+
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Find tables with language codes
+        tables = soup.find_all('table')
+
+        aws_polly = {}
+        for table in tables:
+            rows = table.find_all('tr')
+            if not rows:
+                continue
+
+            # Check if this table has language code column
+            headers = [th.get_text(strip=True) for th in rows[0].find_all('th')]
+
+            # Find language code column index
+            lang_code_idx = None
+            lang_name_idx = None
+            for idx, header in enumerate(headers):
+                if 'Language code' in header or 'language code' in header.lower():
+                    lang_code_idx = idx
+                if 'Language' == header or header.startswith('Language'):
+                    lang_name_idx = idx
+
+            if lang_code_idx is not None:
+                for row in rows[1:]:  # Skip header
+                    cols = row.find_all('td')
+                    if len(cols) > lang_code_idx:
+                        locale = cols[lang_code_idx].get_text(strip=True)
+                        language = cols[lang_name_idx].get_text(strip=True) if lang_name_idx and len(cols) > lang_name_idx else ''
+                        if locale and locale not in ['—', '-', '']:
+                            # Count voices per locale (each row is a different voice/locale combo)
+                            if locale in aws_polly:
+                                aws_polly[locale]['voice_count'] += 1
+                            else:
+                                aws_polly[locale] = {
+                                    'language': language,
+                                    'voice_count': 1
+                                }
+
+        return aws_polly
+    except Exception as e:
+        print(f"Error fetching AWS Polly data: {e}")
+        return {}
+
+def get_azure_locales_for_language(language_code):
+    """
+    Get Azure BCP-47 locales for a language using its alpha2 code
+    Returns list of matching locales from Azure
+    """
+    lang_info = LANGUAGES.get(language_code)
+    if not lang_info or not lang_info['alpha2']:
+        return []
+
+    alpha2 = lang_info['alpha2']
+    azure_asr = fetch_azure_asr_languages()
+    azure_tts = fetch_azure_tts_languages()
+
+    # Find all locales that start with the alpha2 code
+    matching_locales = set()
+
+    for locale in azure_asr.keys():
+        if locale.startswith(alpha2 + '-') or locale == alpha2:
+            matching_locales.add(locale)
+
+    for locale in azure_tts.keys():
+        if locale.startswith(alpha2 + '-') or locale == alpha2:
+            matching_locales.add(locale)
+
+    return sorted(matching_locales)
+
+def get_google_locales_for_language(language_code):
+    """
+    Get Google Cloud BCP-47 locales for a language using its alpha2 code
+    Returns list of matching locales from Google Cloud
+    """
+    lang_info = LANGUAGES.get(language_code)
+    if not lang_info or not lang_info['alpha2']:
+        return []
+
+    alpha2 = lang_info['alpha2']
+    google_stt = fetch_google_stt_languages()
+    google_tts = fetch_google_tts_languages()
+
+    # Find all locales that start with the alpha2 code
+    matching_locales = set()
+
+    for locale in google_stt.keys():
+        if locale.startswith(alpha2 + '-') or locale == alpha2:
+            matching_locales.add(locale)
+
+    for locale in google_tts.keys():
+        if locale.startswith(alpha2 + '-') or locale == alpha2:
+            matching_locales.add(locale)
+
+    return sorted(matching_locales)
+
+def check_elevenlabs_multilingual_v2_support(language_code):
+    """
+    Check if ElevenLabs Multilingual v2 supports a language using ISO 639-1 (alpha2) codes
+    Returns True if supported, False otherwise
+    """
+    lang_info = LANGUAGES.get(language_code)
+    if not lang_info:
+        return False
+
+    supported_codes = fetch_elevenlabs_multilingual_v2()
+
+    # Check alpha2 code (2-letter code)
+    if lang_info['alpha2'] and lang_info['alpha2'] in supported_codes:
+        return True
+
+    return False
+
+def check_elevenlabs_turbo_v3_support(language_code):
+    """
+    Check if ElevenLabs Turbo v3 supports a language using ISO 639-3 (alpha3) codes
+    Returns True if supported, False otherwise
+    """
+    lang_info = LANGUAGES.get(language_code)
+    if not lang_info:
+        return False
+
+    supported_codes = fetch_elevenlabs_turbo_v3()
+
+    # Check alpha3_b code first (3-letter code, bibliographic)
+    if lang_info['alpha3_b'] and lang_info['alpha3_b'] in supported_codes:
+        return True
+
+    # Check alpha3_t code (3-letter code, terminological)
+    if lang_info['alpha3_t'] and lang_info['alpha3_t'] in supported_codes:
+        return True
+
+    return False
+
+def get_aws_locales_for_language(language_code):
+    """
+    Get AWS locales for a language using its alpha2 code
+    Returns list of matching locales from AWS Transcribe and Polly
+    """
+    lang_info = LANGUAGES.get(language_code)
+    if not lang_info or not lang_info['alpha2']:
+        return []
+
+    alpha2 = lang_info['alpha2']
+    aws_transcribe = fetch_aws_transcribe_languages()
+    aws_polly = fetch_aws_polly_languages()
+
+    # Find all locales that start with the alpha2 code
+    matching_locales = set()
+
+    for locale in aws_transcribe.keys():
+        if locale.startswith(alpha2 + '-') or locale == alpha2:
+            matching_locales.add(locale)
+
+    for locale in aws_polly.keys():
+        if locale.startswith(alpha2 + '-') or locale == alpha2:
+            matching_locales.add(locale)
+
+    return sorted(matching_locales)
+
+def search_huggingface_models(language_code, pipeline_tag, max_results=100, max_pages=3):
+    """
+    Search HuggingFace for models supporting a specific language
+    pipeline_tag: 'automatic-speech-recognition' or 'text-to-speech'
+    max_results: maximum number of models to return
+    max_pages: maximum number of pages to search per language code
+    Returns tuple: (list of model dictionaries, log messages)
+    """
+    lang_info = LANGUAGES.get(language_code)
+    logs = []
+
+    if not lang_info:
+        logs.append(f"No language info found for code: {language_code}")
+        return [], logs
+
+    # Try multiple language code formats
+    codes_to_try = []
+    if lang_info['alpha2']:
+        codes_to_try.append(lang_info['alpha2'])  # 2-letter code
+    if lang_info['alpha3_b']:
+        codes_to_try.append(lang_info['alpha3_b'])  # 3-letter code
+    if lang_info['alpha3_t']:
+        codes_to_try.append(lang_info['alpha3_t'])  # 3-letter terminological
+
+    logs.append(f"Language codes to search: {set(codes_to_try)}")
+
+    models = []
+    seen_models = set()
+
+    for code in codes_to_try:
+        if len(models) >= max_results:
+            break
+
+        logs.append(f"Searching for language code: {code}")
+
+        # Try multiple pages for this language code
+        for page in range(max_pages):
+            if len(models) >= max_results:
+                break
+
+            try:
+                # Use HuggingFace model search with pagination
+                url = f"https://huggingface.co/models?pipeline_tag={pipeline_tag}&language={code}&sort=trending"
+                if page > 0:
+                    url += f"&p={page}"
+
+                logs.append(f"  Page {page}: {url}")
+
+                headers = {
+                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
+                }
+
+                response = requests.get(url, headers=headers, timeout=10)
+                response.raise_for_status()
+
+                soup = BeautifulSoup(response.content, 'html.parser')
+
+                # Parse model cards from the page
+                model_cards = soup.find_all('article', class_='overview-card-wrapper')
+
+                if not model_cards:
+                    logs.append(f"  No model cards found on page {page}")
+                    break
+
+                logs.append(f"  Found {len(model_cards)} model cards on page {page}")
+
+                for card in model_cards:
+                    if len(models) >= max_results:
+                        break
+
+                    try:
+                        link = card.find('a', href=True)
+                        if link:
+                            href = link.get('href', '')
+                            model_name = href.lstrip('/')
+
+                            if model_name and model_name != '#' and model_name not in seen_models:
+                                seen_models.add(model_name)
+
+                                # Parse stats directly from the card HTML by looking at SVG icons
+                                downloads = 0
+                                likes = 0
+                                size = ""
+
+                                # Find all SVG elements in the card
+                                svgs = card.find_all('svg')
+
+                                for svg in svgs:
+                                    # Get the next sibling text after the SVG
+                                    # Could be direct text or text within a span/other element
+                                    next_elem = svg.find_next_sibling(string=True)
+                                    stat_text = ""
+
+                                    if next_elem and next_elem.strip():
+                                        stat_text = next_elem.strip()
+                                    else:
+                                        # Try to find text in the next sibling element (e.g., <span>)
+                                        next_tag = svg.find_next_sibling()
+                                        if next_tag:
+                                            stat_text = next_tag.get_text(strip=True)
+
+                                    if not stat_text or len(stat_text) < 1:
+                                        continue
+
+                                    # Identify icon type by viewBox or path content
+                                    svg_str = str(svg)
+
+                                    # Download icon: viewBox="0 0 32 32" with download arrow path
+                                    if 'M26 24v4H6v-4H4v4a2 2 0 0 0 2 2h20a2 2 0 0 0 2-2v-4zm0-10l-1.41-1.41L17 20.17V2h-2v18.17l-7.59-7.58L6 14l10 10l10-10z' in svg_str:
+                                        downloads = parse_stat_number(stat_text)
+
+                                    # Like/heart icon: heart path
+                                    elif 'M22.45,6a5.47,5.47,0,0,1,3.91,1.64,5.7,5.7,0,0,1,0,8L16,26.13' in svg_str:
+                                        likes = parse_stat_number(stat_text)
+
+                                    # Model size icon: small grid icon (viewBox="0 0 12 12") with specific path for parameter count
+                                    elif 'M10 10H8.4V8.4H10V10Zm0-3.2H8.4V5.2H10v1.6ZM6.8 10H5.2V8.4h1.6V10Z' in svg_str:
+                                        # Model parameter count (e.g., "2B", "0.6B")
+                                        # Must be short and contain B for billion params
+                                        if len(stat_text) <= 6 and re.search(r'\d+\.?\d*\s*[Bb]', stat_text):
+                                            size = stat_text
+
+                                models.append({
+                                    'name': model_name,
+                                    'url': f"https://huggingface.co/{model_name}",
+                                    'downloads': downloads,
+                                    'likes': likes,
+                                    'size': size
+                                })
+                    except Exception as e:
+                        logs.append(f"  Error parsing model card: {e}")
+                        continue
+
+            except Exception as e:
+                logs.append(f"  ERROR searching page {page}: {e}")
+                break
+
+    # Sort by downloads (descending)
+    models.sort(key=lambda x: x['downloads'], reverse=True)
+
+    logs.append(f"Total unique models found: {len(models)}")
+    return models, logs
+
+def get_huggingface_stats(item_name, item_type='datasets'):
+    """
+    Get likes and downloads for a HuggingFace dataset or model using API
+    item_type: 'datasets' or 'models'
+    Returns dict with likes and downloads
+
+    NOTE: This method is currently NOT USED. We parse stats directly from HTML instead.
+    Keeping it here as a fallback in case HTML parsing fails.
+    """
+    try:
+        api_url = f"https://huggingface.co/api/{item_type}/{item_name}"
+        response = requests.get(api_url, timeout=5)
+
+        if response.status_code == 200:
+            data = response.json()
+            return {
+                'likes': data.get('likes', 0),
+                'downloads': data.get('downloads', 0)
+            }
+    except Exception:
+        pass
+
+    return {'likes': 0, 'downloads': 0}
+
+def parse_stat_number(stat_text):
+    """
+    Parse HuggingFace stat numbers like '4.07M', '23.4k', '349' into integers
+    Returns integer value or 0 if parsing fails
+    """
+    if not stat_text:
+        return 0
+
+    stat_text = stat_text.strip().upper()
+
+    try:
+        # Handle 'M' (millions)
+        if 'M' in stat_text:
+            return int(float(stat_text.replace('M', '')) * 1_000_000)
+        # Handle 'K' (thousands)
+        elif 'K' in stat_text:
+            return int(float(stat_text.replace('K', '')) * 1_000)
+        # Plain number
+        else:
+            return int(stat_text.replace(',', ''))
+    except (ValueError, AttributeError):
+        return 0
+
+def deduplicate_models(models):
+    """
+    Deduplicate models by base name (without user/org prefix)
+    Keep the model with most downloads and count duplicates
+    Returns list of deduplicated models with duplicate count added
+    """
+    from collections import defaultdict
+
+    # Group models by base name
+    grouped = defaultdict(list)
+    for model in models:
+        # Extract base name (everything after last '/')
+        name_parts = model['name'].split('/')
+        if len(name_parts) > 1:
+            base_name = name_parts[-1]  # e.g., "whisper-large-v3"
+        else:
+            base_name = model['name']
+
+        grouped[base_name].append(model)
+
+    # For each group, keep the one with most downloads
+    deduplicated = []
+    for base_name, model_list in grouped.items():
+        # Sort by downloads (descending) and keep the first one
+        model_list.sort(key=lambda x: x['downloads'], reverse=True)
+        best_model = model_list[0]
+
+        # Add duplicate count (total in group)
+        best_model['duplicates'] = len(model_list) - 1
+
+        deduplicated.append(best_model)
+
+    # Sort by downloads again
+    deduplicated.sort(key=lambda x: x['downloads'], reverse=True)
+
+    return deduplicated
+
+def search_huggingface_datasets(language_code, task_category, max_results=100, max_pages=3):
+    """
+    Search HuggingFace for datasets supporting a specific language
+    task_category: 'automatic-speech-recognition' or 'text-to-speech'
+    max_results: maximum number of datasets to return
+    max_pages: maximum number of pages to search per language code
+    Returns tuple: (list of dataset dictionaries, log messages)
+    """
+    lang_info = LANGUAGES.get(language_code)
+    logs = []
+
+    if not lang_info:
+        logs.append(f"No language info found for code: {language_code}")
+        return [], logs
+
+    # Collect all unique language codes for this language
+    language_codes = set()
+    if lang_info['alpha2']:
+        language_codes.add(lang_info['alpha2'])  # 2-letter code
+    if lang_info['alpha3_b']:
+        language_codes.add(lang_info['alpha3_b'])  # 3-letter code
+    if lang_info['alpha3_t']:
+        language_codes.add(lang_info['alpha3_t'])  # 3-letter terminological
+
+    logs.append(f"Language codes to search: {language_codes}")
+
+    datasets = []
+    seen_datasets = set()
+
+    # Search separately for each language code
+    for code in language_codes:
+        if len(datasets) >= max_results:
+            break
+
+        logs.append(f"Searching for language code: {code}")
+
+        for page in range(max_pages):
+            if len(datasets) >= max_results:
+                break
+
+            try:
+                # Use HuggingFace dataset search with correct format
+                # Format: task_categories=task_categories:automatic-speech-recognition&language=language:en
+                url = f"https://huggingface.co/datasets?task_categories=task_categories:{task_category}&language=language:{code}&sort=trending"
+                if page > 0:
+                    url += f"&p={page}"
+
+                logs.append(f"  Page {page}: {url}")
+
+                headers = {
+                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36'
+                }
+
+                response = requests.get(url, headers=headers, timeout=10)
+                response.raise_for_status()
+
+                soup = BeautifulSoup(response.content, 'html.parser')
+
+                # Parse dataset cards from the page
+                dataset_cards = soup.find_all('article', class_='overview-card-wrapper')
+
+                if not dataset_cards:
+                    logs.append(f"  No dataset cards found on page {page}")
+                    break
+
+                logs.append(f"  Found {len(dataset_cards)} dataset cards on page {page}")
+
+                for card in dataset_cards:
+                    if len(datasets) >= max_results:
+                        break
+
+                    try:
+                        link = card.find('a', href=True)
+                        if link:
+                            href = link.get('href', '')
+                            dataset_path = href.lstrip('/')
+
+                            # Remove "datasets/" prefix if present
+                            if dataset_path.startswith('datasets/'):
+                                dataset_name = dataset_path[9:]  # Remove "datasets/" (9 chars)
+                            else:
+                                dataset_name = dataset_path
+
+                            if dataset_name and dataset_name != '#' and dataset_name not in seen_datasets:
+                                seen_datasets.add(dataset_name)
+
+                                # Parse stats directly from the card HTML by looking at SVG icons
+                                downloads = 0
+                                likes = 0
+                                size = ""
+
+                                # Find all SVG elements in the card
+                                svgs = card.find_all('svg')
+
+                                for svg in svgs:
+                                    # Get the next sibling text after the SVG
+                                    # Could be direct text or text within a span/other element
+                                    next_elem = svg.find_next_sibling(string=True)
+                                    stat_text = ""
+
+                                    if next_elem and next_elem.strip():
+                                        stat_text = next_elem.strip()
+                                    else:
+                                        # Try to find text in the next sibling element (e.g., <span>)
+                                        next_tag = svg.find_next_sibling()
+                                        if next_tag:
+                                            stat_text = next_tag.get_text(strip=True)
+
+                                    # Skip non-numeric text like "Viewer", "Updated", etc.
+                                    if not stat_text or len(stat_text) < 1 or stat_text in ['Viewer', 'Updated']:
+                                        continue
+
+                                    # Identify icon type by viewBox or path content
+                                    svg_str = str(svg)
+
+                                    # Download icon: viewBox="0 0 32 32" with download arrow path
+                                    if 'M26 24v4H6v-4H4v4a2 2 0 0 0 2 2h20a2 2 0 0 0 2-2v-4zm0-10l-1.41-1.41L17 20.17V2h-2v18.17l-7.59-7.58L6 14l10 10l10-10z' in svg_str:
+                                        downloads = parse_stat_number(stat_text)
+
+                                    # Like/heart icon: heart path
+                                    elif 'M22.45,6a5.47,5.47,0,0,1,3.91,1.64,5.7,5.7,0,0,1,0,8L16,26.13' in svg_str:
+                                        likes = parse_stat_number(stat_text)
+
+                                    # Dataset size icon: table/grid icon with fill-rule="evenodd"
+                                    elif 'fill-rule="evenodd"' in svg_str and 'clip-rule="evenodd"' in svg_str:
+                                        # Dataset size (e.g., "411k", "23.4M", "65.1k")
+                                        # Must look like a number (has k, M, or digits)
+                                        if any(c in stat_text for c in ['k', 'K', 'm', 'M']) or stat_text.replace(',', '').replace('.', '').isdigit():
+                                            size = stat_text
+
+                                datasets.append({
+                                    'name': dataset_name,
+                                    'url': f"https://huggingface.co/datasets/{dataset_name}",
+                                    'downloads': downloads,
+                                    'likes': likes,
+                                    'size': size
+                                })
+                    except Exception as e:
+                        logs.append(f"  Error parsing dataset card: {e}")
+                        continue
+
+            except Exception as e:
+                logs.append(f"  ERROR searching page {page}: {e}")
+                break
+
+    # Sort by downloads (descending)
+    datasets.sort(key=lambda x: x['downloads'], reverse=True)
+
+    logs.append(f"Total unique datasets found: {len(datasets)}")
+    return datasets, logs
+
+def search_language_resources(language_code, deduplicate=False):
+    """
+    Search for ASR/TTS resources for a given language
+    Returns results organized by service type
+    deduplicate: if True, remove duplicate models (same base name) and keep only the one with most downloads
+    """
+    all_logs = []
+
+    if not language_code:
+        return None, None, None, 0, 0, None, None, 0, 0, ""
+
+    lang_info = LANGUAGES.get(language_code)
+    if not lang_info:
+        return None, None, None, 0, 0, None, None, 0, 0, ""
+
+    language_name = lang_info['name']
+    all_logs.append(f"=== Searching for {language_name} ({language_code}) ===")
+    all_logs.append(f"Language codes: alpha2={lang_info['alpha2']}, alpha3_b={lang_info['alpha3_b']}, alpha3_t={lang_info['alpha3_t']}")
+
+    # Fetch Azure data
+    all_logs.append("\n[Azure Speech Services]")
+    azure_asr = fetch_azure_asr_languages()
+    azure_tts = fetch_azure_tts_languages()
+    all_logs.append(f"  Fetched {len(azure_asr)} ASR languages and {len(azure_tts)} TTS languages from Azure")
+
+    # Get matching Azure locales using alpha2 code
+    azure_locales = get_azure_locales_for_language(language_code)
+    all_logs.append(f"  Matching Azure locales: {azure_locales}")
+
+    # Check Azure ASR support
+    azure_asr_locales = [loc for loc in azure_locales if loc in azure_asr]
+    azure_asr_available = len(azure_asr_locales) > 0
+    all_logs.append(f"  Azure ASR: {'✅ Supported' if azure_asr_available else '❌ Not supported'} ({len(azure_asr_locales)} locales)")
+
+    # Check Azure TTS support and count voices
+    azure_tts_locales = [loc for loc in azure_locales if loc in azure_tts]
+    azure_tts_available = len(azure_tts_locales) > 0
+    azure_total_voices = sum(azure_tts[loc]['voice_count'] for loc in azure_tts_locales)
+    all_logs.append(f"  Azure TTS: {'✅ Supported' if azure_tts_available else '❌ Not supported'} ({len(azure_tts_locales)} locales, {azure_total_voices} voices)")
+
+    # Fetch Google Cloud data
+    all_logs.append("\n[Google Cloud Speech]")
+    google_stt = fetch_google_stt_languages()
+    google_tts = fetch_google_tts_languages()
+    all_logs.append(f"  Fetched {len(google_stt)} STT languages and {len(google_tts)} TTS languages from Google Cloud")
+
+    # Get matching Google Cloud locales using alpha2 code
+    google_locales = get_google_locales_for_language(language_code)
+    all_logs.append(f"  Matching Google Cloud locales: {google_locales}")
+
+    # Check Google Cloud STT support
+    google_stt_locales = [loc for loc in google_locales if loc in google_stt]
+    google_stt_available = len(google_stt_locales) > 0
+    all_logs.append(f"  Google STT: {'✅ Supported' if google_stt_available else '❌ Not supported'} ({len(google_stt_locales)} locales)")
+
+    # Check Google Cloud TTS support and count voices
+    google_tts_locales = [loc for loc in google_locales if loc in google_tts]
+    google_tts_available = len(google_tts_locales) > 0
+    google_total_voices = sum(google_tts[loc]['voice_count'] for loc in google_tts_locales)
+    all_logs.append(f"  Google TTS: {'✅ Supported' if google_tts_available else '❌ Not supported'} ({len(google_tts_locales)} locales, {google_total_voices} voices)")
+
+    # Fetch AWS data
+    all_logs.append("\n[AWS (Transcribe + Polly)]")
+    aws_transcribe = fetch_aws_transcribe_languages()
+    aws_polly = fetch_aws_polly_languages()
+    all_logs.append(f"  Fetched {len(aws_transcribe)} Transcribe languages and {len(aws_polly)} Polly languages from AWS")
+
+    # Get matching AWS locales using alpha2 code
+    aws_locales = get_aws_locales_for_language(language_code)
+    all_logs.append(f"  Matching AWS locales: {aws_locales}")
+
+    # Check AWS Transcribe support
+    aws_transcribe_locales = [loc for loc in aws_locales if loc in aws_transcribe]
+    aws_transcribe_available = len(aws_transcribe_locales) > 0
+    all_logs.append(f"  AWS Transcribe: {'✅ Supported' if aws_transcribe_available else '❌ Not supported'} ({len(aws_transcribe_locales)} locales)")
+
+    # Check AWS Polly support and count voices
+    aws_polly_locales = [loc for loc in aws_locales if loc in aws_polly]
+    aws_polly_available = len(aws_polly_locales) > 0
+    aws_total_voices = sum(aws_polly[loc]['voice_count'] for loc in aws_polly_locales)
+    all_logs.append(f"  AWS Polly: {'✅ Supported' if aws_polly_available else '❌ Not supported'} ({len(aws_polly_locales)} locales, {aws_total_voices} voices)")
+
+    # Commercial Services
+    commercial_rows = []
+
+    # Azure Speech
+    if azure_asr_available:
+        azure_asr_text = f"✅ {len(azure_asr_locales)} locale(s)"
+    else:
+        azure_asr_text = "❌ N/A"
+
+    if azure_tts_available:
+        azure_tts_text = f"✅ {len(azure_tts_locales)} locale(s), {azure_total_voices} voice(s)"
+    else:
+        azure_tts_text = "❌ N/A"
+
+    commercial_rows.append({
+        "Service": "Azure Speech",
+        "ASR": azure_asr_text,
+        "TTS": azure_tts_text,
+    })
+
+    # Google Cloud Speech
+    if google_stt_available:
+        google_stt_text = f"✅ {len(google_stt_locales)} locale(s)"
+    else:
+        google_stt_text = "❌ N/A"
+
+    if google_tts_available:
+        google_tts_text = f"✅ {len(google_tts_locales)} locale(s), {google_total_voices} voice(s)"
+    else:
+        google_tts_text = "❌ N/A"
+
+    commercial_rows.append({
+        "Service": "Google Cloud Speech",
+        "ASR": google_stt_text,
+        "TTS": google_tts_text,
+    })
+
+    # AWS (Transcribe + Polly)
+    if aws_transcribe_available:
+        aws_transcribe_text = f"✅ {len(aws_transcribe_locales)} locale(s)"
+    else:
+        aws_transcribe_text = "❌ N/A"
+
+    if aws_polly_available:
+        aws_polly_text = f"✅ {len(aws_polly_locales)} locale(s), {aws_total_voices} voice(s)"
+    else:
+        aws_polly_text = "❌ N/A"
+
+    commercial_rows.append({
+        "Service": "AWS (Transcribe + Polly)",
+        "ASR": aws_transcribe_text,
+        "TTS": aws_polly_text,
+    })
+
+    # ElevenLabs Multilingual v2 (TTS only)
+    all_logs.append("\n[ElevenLabs]")
+    elevenlabs_v2_supported = check_elevenlabs_multilingual_v2_support(language_code)
+    all_logs.append(f"  Multilingual v2: {'✅ Supported' if elevenlabs_v2_supported else '❌ Not supported'}")
+
+    if elevenlabs_v2_supported:
+        elevenlabs_v2_tts_text = "✅ Supported"
+    else:
+        elevenlabs_v2_tts_text = "❌ N/A"
+
+    commercial_rows.append({
+        "Service": "ElevenLabs Multilingual v2",
+        "ASR": "N/A",  # ElevenLabs doesn't offer ASR
+        "TTS": elevenlabs_v2_tts_text,
+    })
+
+    # ElevenLabs Turbo v3 (TTS only)
+    elevenlabs_v3_supported = check_elevenlabs_turbo_v3_support(language_code)
+    all_logs.append(f"  Turbo v3: {'✅ Supported' if elevenlabs_v3_supported else '❌ Not supported'}")
+
+    if elevenlabs_v3_supported:
+        elevenlabs_v3_tts_text = "✅ Supported"
+    else:
+        elevenlabs_v3_tts_text = "❌ N/A"
+
+    commercial_rows.append({
+        "Service": "ElevenLabs Turbo v3",
+        "ASR": "N/A",  # ElevenLabs doesn't offer ASR
+        "TTS": elevenlabs_v3_tts_text,
+    })
+
+    commercial_df = pd.DataFrame(commercial_rows)
+
+    # HuggingFace Models - Search for real ASR and TTS models
+    all_logs.append("\n[HuggingFace Models]")
+
+    asr_models, asr_model_logs = search_huggingface_models(language_code, 'automatic-speech-recognition', max_results=100, max_pages=5)
+    all_logs.extend([f"  [ASR] {log}" for log in asr_model_logs])
+
+    tts_models, tts_model_logs = search_huggingface_models(language_code, 'text-to-speech', max_results=100, max_pages=5)
+    all_logs.extend([f"  [TTS] {log}" for log in tts_model_logs])
+
+    # Apply deduplication if requested
+    if deduplicate:
+        all_logs.append(f"\n[Deduplication]")
+        asr_before = len(asr_models)
+        asr_models = deduplicate_models(asr_models)
+        all_logs.append(f"  ASR models: {asr_before} → {len(asr_models)} (removed {asr_before - len(asr_models)} duplicates)")
+
+        tts_before = len(tts_models)
+        tts_models = deduplicate_models(tts_models)
+        all_logs.append(f"  TTS models: {tts_before} → {len(tts_models)} (removed {tts_before - len(tts_models)} duplicates)")
+    else:
+        # Add duplicates count of 1 for all models when not deduplicating
+        for model in asr_models:
+            model['duplicates'] = 1
+        for model in tts_models:
+            model['duplicates'] = 1
+
+    # Format ASR models with clickable names
+    asr_models_data = []
+    for model in asr_models:
+        asr_models_data.append({
+            "Model Name": f"[{model['name']}]({model['url']})",
+            "Downloads": model['downloads'],
+            "Likes": model['likes'],
+            "Size": model.get('size', ''),
+            "Duplicates": model.get('duplicates', 1)
+        })
+
+    if asr_models_data:
+        asr_models_df = pd.DataFrame(asr_models_data)
+    else:
+        # Empty dataframe if no models found
+        asr_models_df = pd.DataFrame(columns=["Model Name", "Downloads", "Likes", "Size", "Duplicates"])
+
+    # Format TTS models with clickable names
+    tts_models_data = []
+    for model in tts_models:
+        tts_models_data.append({
+            "Model Name": f"[{model['name']}]({model['url']})",
+            "Downloads": model['downloads'],
+            "Likes": model['likes'],
+            "Size": model.get('size', ''),
+            "Duplicates": model.get('duplicates', 1)
+        })
+
+    if tts_models_data:
+        tts_models_df = pd.DataFrame(tts_models_data)
+    else:
+        # Empty dataframe if no models found
+        tts_models_df = pd.DataFrame(columns=["Model Name", "Downloads", "Likes", "Size", "Duplicates"])
+
+    # HuggingFace Datasets - Search for real ASR and TTS datasets
+    all_logs.append("\n[HuggingFace Datasets]")
+    asr_datasets, asr_dataset_logs = search_huggingface_datasets(language_code, 'automatic-speech-recognition', max_results=100, max_pages=5)
+    all_logs.extend([f"  [ASR] {log}" for log in asr_dataset_logs])
+
+    tts_datasets, tts_dataset_logs = search_huggingface_datasets(language_code, 'text-to-speech', max_results=100, max_pages=5)
+    all_logs.extend([f"  [TTS] {log}" for log in tts_dataset_logs])
+
+    # Format ASR datasets with clickable names
+    asr_datasets_data = []
+    for dataset in asr_datasets:
+        asr_datasets_data.append({
+            "Dataset Name": f"[{dataset['name']}]({dataset['url']})",
+            "Downloads": dataset['downloads'],
+            "Likes": dataset['likes'],
+            "Size": dataset.get('size', '')
+        })
+
+    if asr_datasets_data:
+        asr_datasets_df = pd.DataFrame(asr_datasets_data)
+    else:
+        # Empty dataframe if no datasets found
+        asr_datasets_df = pd.DataFrame(columns=["Dataset Name", "Downloads", "Likes", "Size"])
+
+    # Format TTS datasets with clickable names
+    tts_datasets_data = []
+    for dataset in tts_datasets:
+        tts_datasets_data.append({
+            "Dataset Name": f"[{dataset['name']}]({dataset['url']})",
+            "Downloads": dataset['downloads'],
+            "Likes": dataset['likes'],
+            "Size": dataset.get('size', '')
+        })
+
+    if tts_datasets_data:
+        tts_datasets_df = pd.DataFrame(tts_datasets_data)
+    else:
+        # Empty dataframe if no datasets found
+        tts_datasets_df = pd.DataFrame(columns=["Dataset Name", "Downloads", "Likes", "Size"])
+
+    # Combine all logs
+    log_text = "\n".join(all_logs)
+
+    # Return separate ASR and TTS dataframes, plus counts for tab labels, plus logs
+    return commercial_df, asr_models_df, tts_models_df, len(asr_models), len(tts_models), asr_datasets_df, tts_datasets_df, len(asr_datasets), len(tts_datasets), log_text
+
+# Initialize - load language list and app content
+print("Initializing Speech Resource Finder...")
+load_app_content()
+load_language_list()
+
+# Create language choices for dropdown (code: name format for easy searching)
+language_choices = [f"{code}: {info['name']}" for code, info in sorted(LANGUAGES.items(), key=lambda x: x[1]['name'])]
+print(f"Created dropdown with {len(language_choices)} language options")
+
+with gr.Blocks(title=APP_CONTENT["title"]) as demo:
+    gr.Markdown(f"# {APP_CONTENT['title']}")
+    gr.Markdown(APP_CONTENT["description"])
+
+    with gr.Row():
+        language_dropdown = gr.Dropdown(
+            choices=language_choices,
+            label="Select Language",
+            info="Type to search for a language",
+            allow_custom_value=False,
+            filterable=True,
+        )
+        search_btn = gr.Button("Search", variant="primary")
+
+    with gr.Row():
+        deduplicate_checkbox = gr.Checkbox(
+            label="Deduplicate models",
+            value=True,
+            info="Keep only the model with most downloads for each base name"
+        )
+    
+    gr.Markdown("## Commercial Services")
+    commercial_table = gr.Dataframe(
+        headers=["Service", "ASR", "TTS"],
+        interactive=False,
+        wrap=True,
+    )
+
+    gr.Markdown("## HuggingFace Models")
+
+    # Create tabs for ASR and TTS models with count labels
+    with gr.Tabs():
+        with gr.Tab(label="ASR Models") as asr_tab:
+            asr_count_label = gr.Markdown("*Loading...*")
+            asr_models_table = gr.Dataframe(
+                headers=["Model Name", "Downloads", "Likes", "Size", "Duplicates"],
+                interactive=False,
+                wrap=True,
+                datatype=["markdown", "number", "number", "str", "number"],
+            )
+
+        with gr.Tab(label="TTS Models") as tts_tab:
+            tts_count_label = gr.Markdown("*Loading...*")
+            tts_models_table = gr.Dataframe(
+                headers=["Model Name", "Downloads", "Likes", "Size", "Duplicates"],
+                interactive=False,
+                wrap=True,
+                datatype=["markdown", "number", "number", "str", "number"],
+            )
+
+    gr.Markdown("## HuggingFace Datasets")
+
+    # Create tabs for ASR and TTS datasets with count labels
+    with gr.Tabs():
+        with gr.Tab(label="ASR Datasets") as asr_datasets_tab:
+            asr_datasets_count_label = gr.Markdown("*Loading...*")
+            asr_datasets_table = gr.Dataframe(
+                headers=["Dataset Name", "Downloads", "Likes", "Size"],
+                interactive=False,
+                wrap=True,
+                datatype=["markdown", "number", "number", "str"],
+            )
+
+        with gr.Tab(label="TTS Datasets") as tts_datasets_tab:
+            tts_datasets_count_label = gr.Markdown("*Loading...*")
+            tts_datasets_table = gr.Dataframe(
+                headers=["Dataset Name", "Downloads", "Likes", "Size"],
+                interactive=False,
+                wrap=True,
+                datatype=["markdown", "number", "number", "str"],
+            )
+
+    gr.Markdown("## Logs")
+    log_textbox = gr.Textbox(
+        label="Search Logs",
+        lines=10,
+        max_lines=20,
+        interactive=False,
+        placeholder="Logs will appear here...",
+    )
+
+    # About section with full content
+    with gr.Accordion("About this tool", open=False):
+        gr.Markdown(APP_CONTENT["full_content"])
+
+    def on_search(language_selection, deduplicate):
+        if not language_selection:
+            return None, "", None, "", None, "", None, "", None, ""
+        # Extract the language code from "code: name" format
+        language_code = language_selection.split(":")[0].strip()
+        commercial_df, asr_models_df, tts_models_df, asr_models_count, tts_models_count, asr_datasets_df, tts_datasets_df, asr_datasets_count, tts_datasets_count, logs = search_language_resources(language_code, deduplicate=deduplicate)
+
+        # Create count labels
+        asr_models_label = f"**Found {asr_models_count} ASR model(s)**"
+        tts_models_label = f"**Found {tts_models_count} TTS model(s)**"
+        asr_datasets_label = f"**Found {asr_datasets_count} ASR dataset(s)**"
+        tts_datasets_label = f"**Found {tts_datasets_count} TTS dataset(s)**"
+
+        return commercial_df, asr_models_label, asr_models_df, tts_models_label, tts_models_df, asr_datasets_label, asr_datasets_df, tts_datasets_label, tts_datasets_df, logs
+
+    search_btn.click(
+        fn=on_search,
+        inputs=[language_dropdown, deduplicate_checkbox],
+        outputs=[commercial_table, asr_count_label, asr_models_table, tts_count_label, tts_models_table, asr_datasets_count_label, asr_datasets_table, tts_datasets_count_label, tts_datasets_table, log_textbox],
+    )
+
+    # Also trigger search when language is selected
+    language_dropdown.change(
+        fn=on_search,
+        inputs=[language_dropdown, deduplicate_checkbox],
+        outputs=[commercial_table, asr_count_label, asr_models_table, tts_count_label, tts_models_table, asr_datasets_count_label, asr_datasets_table, tts_datasets_count_label, tts_datasets_table, log_textbox],
+    )
+
+    # Trigger search when deduplicate checkbox is changed
+    deduplicate_checkbox.change(
+        fn=on_search,
+        inputs=[language_dropdown, deduplicate_checkbox],
+        outputs=[commercial_table, asr_count_label, asr_models_table, tts_count_label, tts_models_table, asr_datasets_count_label, asr_datasets_table, tts_datasets_count_label, tts_datasets_table, log_textbox],
+    )
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False, show_error=True)

app_content.md

@@ -0,0 +1,43 @@
+# Speech Resource Finder
+
+## Description
+
+Almost 4 billion people speak languages with little or no speech technology support. This tool makes visible which languages have resources available and which communities are being left behind in the speech AI revolution.
+
+Built by CLEAR Global to support language inclusion and help close the digital language divide.
+
+## How to Use
+1. Select a language from the dropdown (type to search by name or ISO code)
+2. Toggle model deduplication if desired (enabled by default)
+3. Review results: commercial availability, models, and datasets
+4. Click model/dataset names to open on HuggingFace
+
+## Data Sources
+
+### Commercial Speech Services
+
+Commercial service support is automatically pulled from the language support page of each service provider.
+
+- **Azure Speech Services** - [Speech-to-Text](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=stt) | [Text-to-Speech](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/language-support?tabs=tts)
+- **Google Cloud Speech** - [Speech-to-Text](https://cloud.google.com/speech-to-text/docs/speech-to-text-supported-languages) | [Text-to-Speech](https://cloud.google.com/text-to-speech/docs/voices)
+- **AWS** - [Transcribe](https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html) | [Polly](https://docs.aws.amazon.com/polly/latest/dg/supported-languages.html)
+- **ElevenLabs** - [Multilingual v2](https://elevenlabs.io/docs/models#multilingual-v2) | [Turbo v3](https://elevenlabs.io/docs/models#eleven-v3-alpha)
+
+### Open Source Resources
+- **HuggingFace Models** - Pre-trained speech models sorted by downloads
+  - [ASR Models](https://huggingface.co/models?pipeline_tag=automatic-speech-recognition)
+  - [TTS Models](https://huggingface.co/models?pipeline_tag=text-to-speech)
+- **HuggingFace Datasets** - Speech corpora for training and evaluation
+  - [ASR Datasets](https://huggingface.co/datasets?task_categories=task_categories:automatic-speech-recognition)
+  - [TTS Datasets](https://huggingface.co/datasets?task_categories=task_categories:text-to-speech)
+
+## Disclaimer
+
+- Currently lists only 487 languages and is taken from this [Github repository](https://github.com/datasets/language-codes).
+- Data fetched in real-time and can change.
+- This is not an exhaustive list. There are other commercial voice technology providers and dataset/model resources that this app doesn't cover.
+- Deduplication discards models with same name uploaded by others and keeps the most downloaded version in the list.
+
+## Feedback
+
+We would love to hear your feedback and suggestions. Please write us at tech@clearglobal.org. 

language-codes-full.csv

@@ -0,0 +1,488 @@
+"alpha3-b","alpha3-t","alpha2","English","French"
+"aar","","aa","Afar","afar
+"abk","","ab","Abkhazian","abkhaze
+"ace","","","Achinese","aceh
+"ach","","","Acoli","acoli
+"ada","","","Adangme","adangme
+"ady","","","Adyghe; Adygei","adyghé
+"afa","","","Afro-Asiatic languages","afro-asiatiques, langues
+"afh","","","Afrihili","afrihili
+"afr","","af","Afrikaans","afrikaans
+"ain","","","Ainu","aïnou
+"aka","","ak","Akan","akan
+"akk","","","Akkadian","akkadien
+"alb","sqi","sq","Albanian","albanais
+"ale","","","Aleut","aléoute
+"alg","","","Algonquian languages","algonquines, langues
+"alt","","","Southern Altai","altai du Sud
+"amh","","am","Amharic","amharique
+"ang","","","English, Old (ca.450-1100)","anglo-saxon (ca.450-1100)
+"anp","","","Angika","angika
+"apa","","","Apache languages","apaches, langues
+"ara","","ar","Arabic","arabe
+"arc","","","Official Aramaic (700-300 BCE); Imperial Aramaic (700-300 BCE)","araméen d'empire (700-300 BCE)
+"arg","","an","Aragonese","aragonais
+"arm","hye","hy","Armenian","arménien
+"arn","","","Mapudungun; Mapuche","mapudungun; mapuche; mapuce
+"arp","","","Arapaho","arapaho
+"art","","","Artificial languages","artificielles, langues
+"arw","","","Arawak","arawak
+"asm","","as","Assamese","assamais
+"ast","","","Asturian; Bable; Leonese; Asturleonese","asturien; bable; léonais; asturoléonais
+"ath","","","Athapascan languages","athapascanes, langues
+"aus","","","Australian languages","australiennes, langues
+"ava","","av","Avaric","avar
+"ave","","ae","Avestan","avestique
+"awa","","","Awadhi","awadhi
+"aym","","ay","Aymara","aymara
+"aze","","az","Azerbaijani","azéri
+"bad","","","Banda languages","banda, langues
+"bai","","","Bamileke languages","bamiléké, langues
+"bak","","ba","Bashkir","bachkir
+"bal","","","Baluchi","baloutchi
+"bam","","bm","Bambara","bambara
+"ban","","","Balinese","balinais
+"baq","eus","eu","Basque","basque
+"bas","","","Basa","basa
+"bat","","","Baltic languages","baltes, langues
+"bej","","","Beja; Bedawiyet","bedja
+"bel","","be","Belarusian","biélorusse
+"bem","","","Bemba","bemba
+"ben","","bn","Bengali","bengali
+"ber","","","Berber languages","berbères, langues
+"bho","","","Bhojpuri","bhojpuri
+"bih","","","Bihari languages","langues biharis
+"bik","","","Bikol","bikol
+"bin","","","Bini; Edo","bini; edo
+"bis","","bi","Bislama","bichlamar
+"bla","","","Siksika","blackfoot
+"bnt","","","Bantu languages","bantou, langues
+"bos","","bs","Bosnian","bosniaque
+"bra","","","Braj","braj
+"bre","","br","Breton","breton
+"btk","","","Batak languages","batak, langues
+"bua","","","Buriat","bouriate
+"bug","","","Buginese","bugi
+"bul","","bg","Bulgarian","bulgare
+"bur","mya","my","Burmese","birman
+"byn","","","Blin; Bilin","blin; bilen
+"cad","","","Caddo","caddo
+"cai","","","Central American Indian languages","amérindiennes de L'Amérique centrale, langues
+"car","","","Galibi Carib","karib; galibi; carib
+"cat","","ca","Catalan; Valencian","catalan; valencien
+"cau","","","Caucasian languages","caucasiennes, langues
+"ceb","","","Cebuano","cebuano
+"cel","","","Celtic languages","celtiques, langues; celtes, langues
+"cha","","ch","Chamorro","chamorro
+"chb","","","Chibcha","chibcha
+"che","","ce","Chechen","tchétchène
+"chg","","","Chagatai","djaghataï
+"chi","zho","zh","Chinese","chinois
+"chk","","","Chuukese","chuuk
+"chm","","","Mari","mari
+"chn","","","Chinook jargon","chinook, jargon
+"cho","","","Choctaw","choctaw
+"chp","","","Chipewyan; Dene Suline","chipewyan
+"chr","","","Cherokee","cherokee
+"chu","","cu","Church Slavic; Old Slavonic; Church Slavonic; Old Bulgarian; Old Church Slavonic","slavon d'église; vieux slave; slavon liturgique; vieux bulgare
+"chv","","cv","Chuvash","tchouvache
+"chy","","","Cheyenne","cheyenne
+"cmc","","","Chamic languages","chames, langues
+"cnr","","","Montenegrin","monténégrin
+"cop","","","Coptic","copte
+"cor","","kw","Cornish","cornique
+"cos","","co","Corsican","corse
+"cpe","","","Creoles and pidgins, English based","créoles et pidgins basés sur l'anglais
+"cpf","","","Creoles and pidgins, French-based","créoles et pidgins basés sur le français
+"cpp","","","Creoles and pidgins, Portuguese-based","créoles et pidgins basés sur le portugais
+"cre","","cr","Cree","cree
+"crh","","","Crimean Tatar; Crimean Turkish","tatar de Crimé
+"crp","","","Creoles and pidgins","créoles et pidgins
+"csb","","","Kashubian","kachoube
+"cus","","","Cushitic languages","couchitiques, langues
+"cze","ces","cs","Czech","tchèque
+"dak","","","Dakota","dakota
+"dan","","da","Danish","danois
+"dar","","","Dargwa","dargwa
+"day","","","Land Dayak languages","dayak, langues
+"del","","","Delaware","delaware
+"den","","","Slave (Athapascan)","esclave (athapascan)
+"dgr","","","Tlicho; Dogrib","tlicho; dogrib
+"din","","","Dinka","dinka
+"div","","dv","Divehi; Dhivehi; Maldivian","maldivien
+"doi","","","Dogri","dogri
+"dra","","","Dravidian languages","dravidiennes, langues
+"dsb","","","Lower Sorbian","bas-sorabe
+"dua","","","Duala","douala
+"dum","","","Dutch, Middle (ca.1050-1350)","néerlandais moyen (ca. 1050-1350)
+"dut","nld","nl","Dutch; Flemish","néerlandais; flamand
+"dyu","","","Dyula","dioula
+"dzo","","dz","Dzongkha","dzongkha
+"efi","","","Efik","efik
+"egy","","","Egyptian (Ancient)","égyptien
+"eka","","","Ekajuk","ekajuk
+"elx","","","Elamite","élamite
+"eng","","en","English","anglais
+"enm","","","English, Middle (1100-1500)","anglais moyen (1100-1500)
+"epo","","eo","Esperanto","espéranto
+"est","","et","Estonian","estonien
+"ewe","","ee","Ewe","éwé
+"ewo","","","Ewondo","éwondo
+"fan","","","Fang","fang
+"fao","","fo","Faroese","féroïen
+"fat","","","Fanti","fanti
+"fij","","fj","Fijian","fidjien
+"fil","","","Filipino; Pilipino","filipino; pilipino
+"fin","","fi","Finnish","finnois
+"fiu","","","Finno-Ugrian languages","finno-ougriennes, langues
+"fon","","","Fon","fon
+"fre","fra","fr","French","français
+"frm","","","French, Middle (ca.1400-1600)","français moyen (1400-1600)
+"fro","","","French, Old (842-ca.1400)","français ancien (842-ca.1400)
+"frr","","","Northern Frisian","frison septentrional
+"frs","","","Eastern Frisian","frison oriental
+"fry","","fy","Western Frisian","frison occidental
+"ful","","ff","Fulah","peul
+"fur","","","Friulian","frioulan
+"gaa","","","Ga","ga
+"gay","","","Gayo","gayo
+"gba","","","Gbaya","gbaya
+"gem","","","Germanic languages","germaniques, langues
+"geo","kat","ka","Georgian","géorgien
+"ger","deu","de","German","allemand
+"gez","","","Geez","guèze
+"gil","","","Gilbertese","kiribati
+"gla","","gd","Gaelic; Scottish Gaelic","gaélique; gaélique écossais
+"gle","","ga","Irish","irlandais
+"glg","","gl","Galician","galicien
+"glv","","gv","Manx","manx; mannois
+"gmh","","","German, Middle High (ca.1050-1500)","allemand, moyen haut (ca. 1050-1500)
+"goh","","","German, Old High (ca.750-1050)","allemand, vieux haut (ca. 750-1050)
+"gon","","","Gondi","gond
+"gor","","","Gorontalo","gorontalo
+"got","","","Gothic","gothique
+"grb","","","Grebo","grebo
+"grc","","","Greek, Ancient (to 1453)","grec ancien (jusqu'à 1453)
+"gre","ell","el","Greek, Modern (1453-)","grec moderne (après 1453)
+"grn","","gn","Guarani","guarani
+"gsw","","","Swiss German; Alemannic; Alsatian","suisse alémanique; alémanique; alsacien
+"guj","","gu","Gujarati","goudjrati
+"gwi","","","Gwich'in","gwich'in
+"hai","","","Haida","haida
+"hat","","ht","Haitian; Haitian Creole","haïtien; créole haïtien
+"hau","","ha","Hausa","haoussa
+"haw","","","Hawaiian","hawaïen
+"heb","","he","Hebrew","hébreu
+"her","","hz","Herero","herero
+"hil","","","Hiligaynon","hiligaynon
+"him","","","Himachali languages; Western Pahari languages","langues himachalis; langues paharis occidentales
+"hin","","hi","Hindi","hindi
+"hit","","","Hittite","hittite
+"hmn","","","Hmong; Mong","hmong
+"hmo","","ho","Hiri Motu","hiri motu
+"hrv","","hr","Croatian","croate
+"hsb","","","Upper Sorbian","haut-sorabe
+"hun","","hu","Hungarian","hongrois
+"hup","","","Hupa","hupa
+"iba","","","Iban","iban
+"ibo","","ig","Igbo","igbo
+"ice","isl","is","Icelandic","islandais
+"ido","","io","Ido","ido
+"iii","","ii","Sichuan Yi; Nuosu","yi de Sichuan
+"ijo","","","Ijo languages","ijo, langues
+"iku","","iu","Inuktitut","inuktitut
+"ile","","ie","Interlingue; Occidental","interlingue
+"ilo","","","Iloko","ilocano
+"ina","","ia","Interlingua (International Auxiliary Language Association)","interlingua (langue auxiliaire internationale)
+"inc","","","Indic languages","indo-aryennes, langues
+"ind","","id","Indonesian","indonésien
+"ine","","","Indo-European languages","indo-européennes, langues
+"inh","","","Ingush","ingouche
+"ipk","","ik","Inupiaq","inupiaq
+"ira","","","Iranian languages","iraniennes, langues
+"iro","","","Iroquoian languages","iroquoises, langues
+"ita","","it","Italian","italien
+"jav","","jv","Javanese","javanais
+"jbo","","","Lojban","lojban
+"jpn","","ja","Japanese","japonais
+"jpr","","","Judeo-Persian","judéo-persan
+"jrb","","","Judeo-Arabic","judéo-arabe
+"kaa","","","Kara-Kalpak","karakalpak
+"kab","","","Kabyle","kabyle
+"kac","","","Kachin; Jingpho","kachin; jingpho
+"kal","","kl","Kalaallisut; Greenlandic","groenlandais
+"kam","","","Kamba","kamba
+"kan","","kn","Kannada","kannada
+"kar","","","Karen languages","karen, langues
+"kas","","ks","Kashmiri","kashmiri
+"kau","","kr","Kanuri","kanouri
+"kaw","","","Kawi","kawi
+"kaz","","kk","Kazakh","kazakh
+"kbd","","","Kabardian","kabardien
+"kha","","","Khasi","khasi
+"khi","","","Khoisan languages","khoïsan, langues
+"khm","","km","Central Khmer","khmer central
+"kho","","","Khotanese; Sakan","khotanais; sakan
+"kik","","ki","Kikuyu; Gikuyu","kikuyu
+"kin","","rw","Kinyarwanda","rwanda
+"kir","","ky","Kirghiz; Kyrgyz","kirghiz
+"kmb","","","Kimbundu","kimbundu
+"kok","","","Konkani","konkani
+"kom","","kv","Komi","kom
+"kon","","kg","Kongo","kongo
+"kor","","ko","Korean","coréen
+"kos","","","Kosraean","kosrae
+"kpe","","","Kpelle","kpellé
+"krc","","","Karachay-Balkar","karatchai balkar
+"krl","","","Karelian","carélien
+"kro","","","Kru languages","krou, langues
+"kru","","","Kurukh","kurukh
+"kua","","kj","Kuanyama; Kwanyama","kuanyama; kwanyama
+"kum","","","Kumyk","koumyk
+"kur","","ku","Kurdish","kurde
+"kut","","","Kutenai","kutenai
+"lad","","","Ladino","judéo-espagnol
+"lah","","","Lahnda","lahnda
+"lam","","","Lamba","lamba
+"lao","","lo","Lao","lao
+"lat","","la","Latin","latin
+"lav","","lv","Latvian","letton
+"lez","","","Lezghian","lezghien
+"lim","","li","Limburgan; Limburger; Limburgish","limbourgeois
+"lin","","ln","Lingala","lingala
+"lit","","lt","Lithuanian","lituanien
+"lol","","","Mongo","mongo
+"loz","","","Lozi","lozi
+"ltz","","lb","Luxembourgish; Letzeburgesch","luxembourgeois
+"lua","","","Luba-Lulua","luba-lulua
+"lub","","lu","Luba-Katanga","luba-katanga
+"lug","","lg","Ganda","ganda
+"lui","","","Luiseno","luiseno
+"lun","","","Lunda","lunda
+"luo","","","Luo (Kenya and Tanzania)","luo (Kenya et Tanzanie)
+"lus","","","Lushai","lushai
+"mac","mkd","mk","Macedonian","macédonien
+"mad","","","Madurese","madourais
+"mag","","","Magahi","magahi
+"mah","","mh","Marshallese","marshall
+"mai","","","Maithili","maithili
+"mak","","","Makasar","makassar
+"mal","","ml","Malayalam","malayalam
+"man","","","Mandingo","mandingue
+"mao","mri","mi","Maori","maori
+"map","","","Austronesian languages","austronésiennes, langues
+"mar","","mr","Marathi","marathe
+"mas","","","Masai","massaï
+"may","msa","ms","Malay","malais
+"mdf","","","Moksha","moksa
+"mdr","","","Mandar","mandar
+"men","","","Mende","mendé
+"mga","","","Irish, Middle (900-1200)","irlandais moyen (900-1200)
+"mic","","","Mi'kmaq; Micmac","mi'kmaq; micmac
+"min","","","Minangkabau","minangkabau
+"mis","","","Uncoded languages","langues non codées
+"mkh","","","Mon-Khmer languages","môn-khmer, langues
+"mlg","","mg","Malagasy","malgache
+"mlt","","mt","Maltese","maltais
+"mnc","","","Manchu","mandchou
+"mni","","","Manipuri","manipuri
+"mno","","","Manobo languages","manobo, langues
+"moh","","","Mohawk","mohawk
+"mon","","mn","Mongolian","mongol
+"mos","","","Mossi","moré
+"mul","","","Multiple languages","multilingue
+"mun","","","Munda languages","mounda, langues
+"mus","","","Creek","muskogee
+"mwl","","","Mirandese","mirandais
+"mwr","","","Marwari","marvari
+"myn","","","Mayan languages","maya, langues
+"myv","","","Erzya","erza
+"nah","","","Nahuatl languages","nahuatl, langues
+"nai","","","North American Indian languages","nord-amérindiennes, langues
+"nap","","","Neapolitan","napolitain
+"nau","","na","Nauru","nauruan
+"nav","","nv","Navajo; Navaho","navaho
+"nbl","","nr","Ndebele, South; South Ndebele","ndébélé du Sud
+"nde","","nd","Ndebele, North; North Ndebele","ndébélé du Nord
+"ndo","","ng","Ndonga","ndonga
+"nds","","","Low German; Low Saxon; German, Low; Saxon, Low","bas allemand; bas saxon; allemand, bas; saxon, bas
+"nep","","ne","Nepali","népalais
+"new","","","Nepal Bhasa; Newari","nepal bhasa; newari
+"nia","","","Nias","nias
+"nic","","","Niger-Kordofanian languages","nigéro-kordofaniennes, langues
+"niu","","","Niuean","niué
+"nno","","nn","Norwegian Nynorsk; Nynorsk, Norwegian","norvégien nynorsk; nynorsk, norvégien
+"nob","","nb","Bokmål, Norwegian; Norwegian Bokmål","norvégien bokmål
+"nog","","","Nogai","nogaï; nogay
+"non","","","Norse, Old","norrois, vieux
+"nor","","no","Norwegian","norvégien
+"nqo","","","N'Ko","n'ko
+"nso","","","Pedi; Sepedi; Northern Sotho","pedi; sepedi; sotho du Nord
+"nub","","","Nubian languages","nubiennes, langues
+"nwc","","","Classical Newari; Old Newari; Classical Nepal Bhasa","newari classique
+"nya","","ny","Chichewa; Chewa; Nyanja","chichewa; chewa; nyanja
+"nym","","","Nyamwezi","nyamwezi
+"nyn","","","Nyankole","nyankolé
+"nyo","","","Nyoro","nyoro
+"nzi","","","Nzima","nzema
+"oci","","oc","Occitan (post 1500)","occitan (après 1500)
+"oji","","oj","Ojibwa","ojibwa
+"ori","","or","Oriya","oriya
+"orm","","om","Oromo","galla
+"osa","","","Osage","osage
+"oss","","os","Ossetian; Ossetic","ossète
+"ota","","","Turkish, Ottoman (1500-1928)","turc ottoman (1500-1928)
+"oto","","","Otomian languages","otomi, langues
+"paa","","","Papuan languages","papoues, langues
+"pag","","","Pangasinan","pangasinan
+"pal","","","Pahlavi","pahlavi
+"pam","","","Pampanga; Kapampangan","pampangan
+"pan","","pa","Panjabi; Punjabi","pendjabi
+"pap","","","Papiamento","papiamento
+"pau","","","Palauan","palau
+"peo","","","Persian, Old (ca.600-400 B.C.)","perse, vieux (ca. 600-400 av. J.-C.)
+"per","fas","fa","Persian","persan
+"phi","","","Philippine languages","philippines, langues
+"phn","","","Phoenician","phénicien
+"pli","","pi","Pali","pali
+"pol","","pl","Polish","polonais
+"pon","","","Pohnpeian","pohnpei
+"por","","pt","Portuguese","portugais
+"pra","","","Prakrit languages","prâkrit, langues
+"pro","","","Provençal, Old (to 1500); Occitan, Old (to 1500)","provençal ancien (jusqu'à 1500); occitan ancien (jusqu'à 1500)
+"pus","","ps","Pushto; Pashto","pachto
+"qaa-qtz","","","Reserved for local use","réservée à l'usage local
+"que","","qu","Quechua","quechua
+"raj","","","Rajasthani","rajasthani
+"rap","","","Rapanui","rapanui
+"rar","","","Rarotongan; Cook Islands Maori","rarotonga; maori des îles Cook
+"roa","","","Romance languages","romanes, langues
+"roh","","rm","Romansh","romanche
+"rom","","","Romany","tsigane
+"rum","ron","ro","Romanian; Moldavian; Moldovan","roumain; moldave
+"run","","rn","Rundi","rundi
+"rup","","","Aromanian; Arumanian; Macedo-Romanian","aroumain; macédo-roumain
+"rus","","ru","Russian","russe
+"sad","","","Sandawe","sandawe
+"sag","","sg","Sango","sango
+"sah","","","Yakut","iakoute
+"sai","","","South American Indian languages","sud-amérindiennes, langues
+"sal","","","Salishan languages","salishennes, langues
+"sam","","","Samaritan Aramaic","samaritain
+"san","","sa","Sanskrit","sanskrit
+"sas","","","Sasak","sasak
+"sat","","","Santali","santal
+"scn","","","Sicilian","sicilien
+"sco","","","Scots","écossais
+"sel","","","Selkup","selkoupe
+"sem","","","Semitic languages","sémitiques, langues
+"sga","","","Irish, Old (to 900)","irlandais ancien (jusqu'à 900)
+"sgn","","","Sign Languages","langues des signes
+"shn","","","Shan","chan
+"sid","","","Sidamo","sidamo
+"sin","","si","Sinhala; Sinhalese","singhalais
+"sio","","","Siouan languages","sioux, langues
+"sit","","","Sino-Tibetan languages","sino-tibétaines, langues
+"sla","","","Slavic languages","slaves, langues
+"slo","slk","sk","Slovak","slovaque
+"slv","","sl","Slovenian","slovène
+"sma","","","Southern Sami","sami du Sud
+"sme","","se","Northern Sami","sami du Nord
+"smi","","","Sami languages","sames, langues
+"smj","","","Lule Sami","sami de Lule
+"smn","","","Inari Sami","sami d'Inari
+"smo","","sm","Samoan","samoan
+"sms","","","Skolt Sami","sami skolt
+"sna","","sn","Shona","shona
+"snd","","sd","Sindhi","sindhi
+"snk","","","Soninke","soninké
+"sog","","","Sogdian","sogdien
+"som","","so","Somali","somali
+"son","","","Songhai languages","songhai, langues
+"sot","","st","Sotho, Southern","sotho du Sud
+"spa","","es","Spanish; Castilian","espagnol; castillan
+"srd","","sc","Sardinian","sarde
+"srn","","","Sranan Tongo","sranan tongo
+"srp","","sr","Serbian","serbe
+"srr","","","Serer","sérère
+"ssa","","","Nilo-Saharan languages","nilo-sahariennes, langues
+"ssw","","ss","Swati","swati
+"suk","","","Sukuma","sukuma
+"sun","","su","Sundanese","soundanais
+"sus","","","Susu","soussou
+"sux","","","Sumerian","sumérien
+"swa","","sw","Swahili","swahili
+"swe","","sv","Swedish","suédois
+"syc","","","Classical Syriac","syriaque classique
+"syr","","","Syriac","syriaque
+"tah","","ty","Tahitian","tahitien
+"tai","","","Tai languages","tai, langues
+"tam","","ta","Tamil","tamoul
+"tat","","tt","Tatar","tatar
+"tel","","te","Telugu","télougou
+"tem","","","Timne","temne
+"ter","","","Tereno","tereno
+"tet","","","Tetum","tetum
+"tgk","","tg","Tajik","tadjik
+"tgl","","tl","Tagalog","tagalog
+"tha","","th","Thai","thaï
+"tib","bod","bo","Tibetan","tibétain
+"tig","","","Tigre","tigré
+"tir","","ti","Tigrinya","tigrigna
+"tiv","","","Tiv","tiv
+"tkl","","","Tokelau","tokelau
+"tlh","","","Klingon; tlhIngan-Hol","klingon
+"tli","","","Tlingit","tlingit
+"tmh","","","Tamashek","tamacheq
+"tog","","","Tonga (Nyasa)","tonga (Nyasa)
+"ton","","to","Tonga (Tonga Islands)","tongan (Îles Tonga)
+"tpi","","","Tok Pisin","tok pisin
+"tsi","","","Tsimshian","tsimshian
+"tsn","","tn","Tswana","tswana
+"tso","","ts","Tsonga","tsonga
+"tuk","","tk","Turkmen","turkmène
+"tum","","","Tumbuka","tumbuka
+"tup","","","Tupi languages","tupi, langues
+"tur","","tr","Turkish","turc
+"tut","","","Altaic languages","altaïques, langues
+"tvl","","","Tuvalu","tuvalu
+"twi","","tw","Twi","twi
+"tyv","","","Tuvinian","touva
+"udm","","","Udmurt","oudmourte
+"uga","","","Ugaritic","ougaritique
+"uig","","ug","Uighur; Uyghur","ouïgour
+"ukr","","uk","Ukrainian","ukrainien
+"umb","","","Umbundu","umbundu
+"und","","","Undetermined","indéterminée
+"urd","","ur","Urdu","ourdou
+"uzb","","uz","Uzbek","ouszbek
+"vai","","","Vai","vaï
+"ven","","ve","Venda","venda
+"vie","","vi","Vietnamese","vietnamien
+"vol","","vo","Volapük","volapük
+"vot","","","Votic","vote
+"wak","","","Wakashan languages","wakashanes, langues
+"wal","","","Wolaitta; Wolaytta","wolaitta; wolaytta
+"war","","","Waray","waray
+"was","","","Washo","washo
+"wel","cym","cy","Welsh","gallois
+"wen","","","Sorbian languages","sorabes, langues
+"wln","","wa","Walloon","wallon
+"wol","","wo","Wolof","wolof
+"xal","","","Kalmyk; Oirat","kalmouk; oïrat
+"xho","","xh","Xhosa","xhosa
+"yao","","","Yao","yao
+"yap","","","Yapese","yapois
+"yid","","yi","Yiddish","yiddish
+"yor","","yo","Yoruba","yoruba
+"ypk","","","Yupik languages","yupik, langues
+"zap","","","Zapotec","zapotèque
+"zbl","","","Blissymbols; Blissymbolics; Bliss","symboles Bliss; Bliss
+"zen","","","Zenaga","zenaga
+"zgh","","","Standard Moroccan Tamazight","amazighe standard marocain
+"zha","","za","Zhuang; Chuang","zhuang; chuang
+"znd","","","Zande languages","zandé, langues
+"zul","","zu","Zulu","zoulou
+"zun","","","Zuni","zuni
+"zxx","","","No linguistic content; Not applicable","pas de contenu linguistique; non applicable
+"zza","","","Zaza; Dimili; Dimli; Kirdki; Kirmanjki; Zazaki","zaza; dimili; dimli; kirdki; kirmanjki; zazaki"