💻 computer science

Swa-bhasha Resource Hub: Romanized Sinhala to Sinhala Transliteration Systems and Data Resources

This paper introduces the Swa-bhasha Resource Hub, a publicly accessible platform offering a comprehensive collection of data and algorithms for Romanized Sinhala to Sinhala transliteration developed between 2020 and 2025, alongside a comparative analysis of existing tools to advance Sinhala Natural Language Processing.

Original authors: Deshan Sumanathilaka, Sameera Perera, Sachithya Dharmasiri, Maneesha Athukorala, Anuja Dilrukshi Herath, Rukshan Dias, Pasindu Gamage, Ruvan Weerasinghe, Y. H. P. P. Priyadarshana

Published 2026-04-28

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Deshan Sumanathilaka, Sameera Perera, Sachithya Dharmasiri, Maneesha Athukorala, Anuja Dilrukshi Herath, Rukshan Dias, Pasindu Gamage, Ruvan Weerasinghe, Y. H. P. P. Priyadarshana

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the Sinhala language as a beautiful, intricate garden. For decades, people in Sri Lanka have been trying to enter this garden using a different set of keys: the English keyboard. Because they didn't have a Sinhala keyboard handy, they started typing Sinhala sounds using English letters. They called this "Singlish" (Romanized Sinhala).

Think of Singlish as a secret code or a dialect of typos. It's fast and convenient, but it's messy. One word typed as "Adaraya" could mean "Love" or "Aid," depending on the context. It's like if you typed "bat" and it could mean the animal, the sports equipment, or a verb, and the computer has no idea which one you meant without reading the whole sentence.

This paper is a report card and a toolbox from a team of researchers (the Swa-bhasha team) who spent years building a bridge to help computers understand this messy code and turn it back into proper, beautiful Sinhala.

Here is what they built, explained simply:

1. The Problem: The "Lost in Translation" Game

The team noticed that while computers are great at translating English to French, they struggle with "Singlish" to Sinhala.

The Mess: People type differently. Some skip vowels (writing "klna" instead of "kalana"), some use English spelling rules, and some mix English and Sinhala words in the same sentence.
The Ambiguity: The biggest headache is that one typed word can have multiple meanings. The computer needs to be a detective to figure out which meaning fits the story.

2. The Toolbox: How They Fixed It

The team didn't just build one tool; they built a whole workshop with different machines, getting smarter with each generation.

The Rule-Book Robot (Swa Bhasha 1.0):
- How it worked: Imagine a robot that follows a strict instruction manual. If it sees "k," it knows it needs a vowel next. It uses a "fuzzy" search (like a spell-checker that guesses) to find the closest match in a dictionary.
- The Result: It was okay, but it struggled when people broke the rules (like skipping vowels).
The Hybrid Detective (Swa Bhasha 2.0 & The N-gram Model):
- How it worked: They combined the Rule-Book Robot with a "Statistical Detective." This detective looked at millions of sentences to learn patterns. It used a "Trie" (a smart tree structure) to suggest words, like a phone's autocomplete but for Sinhala.
- The Result: Much better at guessing the right word, but still got confused by very tricky sentences.
The Super-Reader (BERT & Transformers):
- How it worked: This is the team's "Super-Reader." Instead of just looking at individual words, it reads the whole sentence at once, understanding the context like a human does. They used a powerful AI model called BERT (which is like a brain that has read the entire internet of Sinhala text).
- The Trick: When the AI saw a confusing word, it put a "mask" over it and asked, "Based on the words before and after this, what word fits best here?"
- The Result: This was the champion. It solved the ambiguity problems better than any previous method, achieving near-perfect accuracy in tests.
The Code-Mixing Specialist:
- How it worked: People often mix English and Sinhala in one sentence (e.g., "I went to the kade [shop]"). The team built a special model that acts like a translator who speaks both languages fluently, handling the mix without getting confused.

3. The Library: The Data They Collected

You can't teach a child to read without books, and you can't teach an AI without data. The team realized there were no good "textbooks" for Singlish, so they wrote their own.

The "Swa-Bhasha" Library: They collected over 7 million words and thousands of sentences from real life (like YouTube comments and social media). This is like gathering every messy note ever written by a Sri Lankan to teach the computer how real people actually type.
The "Ambiguity" Test: They created a special quiz where one word has two meanings. They tested their AI on this to see if it could pick the right meaning based on the story.
The "Code-Mixed" Collection: They gathered examples of people mixing English and Sinhala, a very common habit that was previously ignored by researchers.

4. The Results: Who Won the Race?

The team tested their tools against other methods (like Google's tools or older rule-based systems).

The Old Way: The old rule-based systems were like a rigid teacher; they failed when students broke the rules.
The New Way: The new "Super-Reader" (BERT-based) models were like a wise mentor. They understood the context and got the answers right almost every time.
The Score: In tests, their best model got a score of 91% (BLEU score) and made very few mistakes, while older models made many more errors.

5. What's Next?

The team is currently working on a predictive text feature. Imagine a keyboard that doesn't just translate what you typed, but guesses what you are going to type next, even if you are typing in a messy, personal style. They are using a special learning technique (Meta-Learning) so the keyboard can learn your specific typing habits quickly, without needing to store your private data on a server.

Summary

The Swa-bhasha team built a bridge between the messy, informal way Sri Lankans type on English keyboards and the formal, beautiful Sinhala script. They started with simple rule-books, moved to statistical detectives, and finally built a "Super-Reader" AI that understands context. They also built the massive libraries of data needed to teach these AIs. Their work proves that with the right tools, even a low-resource language like Sinhala can be understood perfectly by computers, even when people type it in a hurry.

Important Note: The paper focuses strictly on the technology of translating text and the data used to train it. It does not claim to have medical applications, clinical uses, or specific future products beyond the research tools and open-source code they have released.

1. Problem Statement

The paper addresses the critical challenge of Backward Transliteration (converting Romanized Sinhala, or "Singlish," back into native Sinhala script).

Context: With the rise of Web 2.0 and social media, nearly 13 million Sri Lankans use Romanized Sinhala due to the convenience of English keyboards.
Core Challenges:
- Non-Standardization: Singlish lacks standardization, leading to ad-hoc typing patterns, spelling variations, and structural inconsistencies (e.g., vowel omissions).
- Lexical Ambiguity: A single Romanized word can map to multiple distinct Sinhala words with different meanings depending on context (e.g., "Adaraya" could mean love or aid).
- Low-Resource Status: Sinhala lacks dedicated linguistic resources, benchmarks, and datasets specifically designed to resolve these contextual ambiguities.
Goal: To develop robust, context-aware systems and provide comprehensive datasets to advance Natural Language Processing (NLP) for low-resource languages.

2. Methodology and Systems

The Swa-bhasha team employed a hybrid evolution of approaches, moving from rule-based systems to advanced deep learning models.

A. Algorithmic Approaches

Rule-Based with Fuzzy Logic (Swa Bhasha v1):
- Utilized Python, NLTK, and fuzzywuzzy for string matching.
- Implemented a two-stage process: Tokenization/Letter Mapping (converting letters to numeric values) followed by Rule Mapping.
- Used specific rules to infer missing vowels based on consonant counts and phonetic patterns, then matched candidates against a native Sinhala dataset.
Hybrid Statistical & Knowledge-Based (Swa-Bhasha v2):
- Combined statistical N-gram tagging (Unigram/Bigram/Trigram) with rule-based transformation (60 vowel/consonant rules, 18 hal-marker rules).
- Integrated a Trie data structure (binary tree) for efficient, context-aware word suggestions and disambiguation.
- Used a post-processing module to resolve tokens where statistical tagging failed.
Neural Machine Translation (NMT) & Hybrid (Swa Bhasha 2.0):
- Combined rule-based phonetic encoding with Seq2Seq models using Gated Recurrent Units (GRUs) and attention mechanisms.
- Integrated a Suffix Tree for a knowledge-based suggestion algorithm to handle word selection ambiguity.
Transformer-Based Contextual Disambiguation (BERT):
- Architecture: Utilized a pre-trained Sinhala BERT model (fine-tuned on the Dakshina dataset).
- Mechanism:
  - Input Singlish is mapped to candidates; ambiguous words are replaced with a [MASK] token.
  - The system generates all possible sentence candidates by replacing masks with candidate words.
  - Scoring: BERT scores each candidate sentence based on contextual probability (using softmax on logits). The highest-scoring sentence is selected.
- Optimization: To handle computational costs of multiple masks, the system uses candidate word reduction (filtering by tokenizer vocabulary) and chunking (splitting long sentences into overlapping segments).
Code-Mixed Translation (LoRA & LLMs):
- Developed a hybrid pipeline for Code-Mixed Romanized Sinhala (Singlish + English).
- Pipeline: LoRA fine-tuned mBART50 model $\rightarrow$ Regex post-processing $\rightarrow$ LLM-based post-editing (using Gemini-3 Flash) with word alignment to resolve complex code-mixing and zero-width space issues.

B. Data Resources

The team created several high-quality datasets to support these models:

Swa-Bhasha Dataset: Contains ~7.13 million Romanized Sinhala words derived from 440,024 unique Sinhala roots. Includes social media sentence pairs and a specific Transliteration Disambiguation (WSD) subset.
IndoNLP Evaluation Dataset: Two test sets (General and Ad-hoc typing patterns) used for shared tasks.
Augmented Romanized Dataset: ~7.24 million standardized sentence pairs for formal language modeling.
Transliteration Disambiguation (TD) Dataset: A specialized dataset with 660 sentence pairs focusing on binary ambiguity (one Romanized word $\rightarrow$ two distinct Sinhala meanings).
SinMix2Mono Dataset: 25,000 rows of Code-Mixed Romanized Sinhala, split into training, golden evaluation, and ambiguity subsets.

3. Key Contributions

Open-Source Ecosystem: Released all algorithms, models, and datasets (hosted on Hugging Face, Kaggle, and GitHub) to the research community.
State-of-the-Art Models: Developed and fine-tuned Transformer-based models (BERT, mBART, XLM-R) that significantly outperform traditional rule-based systems.
Specialized Datasets: Created the first dedicated datasets for Transliteration Disambiguation and Code-Mixed Sinhala, addressing a major gap in low-resource NLP.
Hybrid Architectures: Demonstrated that combining rule-based phonetic logic with deep learning (NMT/Transformers) yields superior results for handling informal, ad-hoc typing.
Custom Tokenization: Developed a custom Byte-Pair Encoding (BPE) tokenizer (si_rom) specifically for Romanized Sinhala to improve model performance.

4. Results and Evaluation

The systems were evaluated using Word Error Rate (WER), Character Error Rate (CER), BLEU, F1 Score, and BERTScore.

Transliteration Accuracy:
- Perera et al. (2025) [BERT-based]: Achieved the best performance with WER ~0.09, CER ~0.02, and BLEU ~0.91 on the IndoNLP dataset. This confirms Transformer models excel at contextual accuracy.
- Comparison: Rule-based systems (e.g., De Mel et al.) had high error rates (WER ~0.67), while hybrid N-gram models showed moderate improvement (WER ~0.23).
Disambiguation Performance:
- F1 Scores: The Fine-tuned BERT model achieved an F1 score of 0.96 on the Disambiguation dataset.
- Baseline: Traditional rule-based and hybrid models struggled significantly, with F1 scores ranging between 0.33 and 0.37, highlighting the necessity of contextual embeddings for ambiguity resolution.
Code-Mixed Translation:
- The SwaBhasha-mBART model (LoRA fine-tuned) achieved the highest BLEU (49.70) and BERTScore (81.19) on the SinMix2Mono golden dataset, outperforming zero-shot LLMs and other fine-tuned models.

5. Significance and Future Work

Significance: The Swa-bhasha Resource Hub provides a foundational infrastructure for Sinhala NLP. It proves that low-resource languages can achieve high-accuracy transliteration through the combination of curated datasets, hybrid methodologies, and modern Transformer architectures.
Limitations: Transformer-based models (like BERT) are computationally expensive, making real-time mobile deployment challenging for long, ambiguity-rich sentences.
Future Directions:
- Optimizing inference efficiency for real-time mobile applications.
- Expanding research into Code-Mixed inputs (Sinhala-English).
- Developing Meta-Learning approaches (MAML) for personalized, privacy-preserving word prediction in Singlish keyboards.
- Integrating transliteration into broader NLP pipelines (sentiment analysis, chatbots).

In conclusion, the paper establishes a new benchmark for Romanized Sinhala transliteration, shifting the paradigm from rigid rule-based systems to context-aware, deep learning-driven solutions supported by robust, open-source data resources.