Inside the Romanes App: Building a Multi-Dialect Learning Experience

When most people think about language learning apps, they imagine a fairly simple structure:

One language.

One standardized course.

One “correct” version to learn.

But when I started building the Romanes app, I quickly realized that this approach would not work.

Because Romanes is not a single standardized language.

It is a living network of dialects spoken across different countries, communities, and generations.

And if the app was going to truly serve Roma and Sinti communities, it needed to reflect that reality from the beginning.

The Problem With Traditional Language App Design

Most language learning platforms are built around standardization.

That works reasonably well for languages with:

• centralized education systems
• standardized spelling
• official institutions
• widely accepted “default” forms

Romanes is different.

Different communities may use:

• different words
• different pronunciations
• different grammatical structures
• different influences from surrounding languages

Even within the same family, people may encounter multiple dialect forms.

So the question became:

How do you build a learning experience without flattening linguistic diversity?

Choosing a Multi-Dialect Approach

From the beginning, I decided that the Romanes app should not force users into a single version of the language.

Instead, the app would support multiple dialects side by side.

Today, the app includes dialects such as:

• Lovari
• Kalderash
• Gurbeti
• Arli
• Polish-Baltic
• Slovak

This approach creates additional complexity technically and linguistically — but it also creates something important:

Recognition.

Users can see their own dialect represented instead of feeling excluded by a system that only teaches one standardized variant.

Dialect Comparison Instead of Dialect Replacement

One of the core ideas behind the app is that dialect differences should not be hidden.

They should be visible.

That is why the Romanes app was designed to allow learners to compare dialects directly.

For example, a learner can see:

• how vocabulary differs between dialects
• where words share common roots
• how pronunciation changes regionally
• which forms overlap and which do not

This creates a very different learning experience from traditional language apps.

The goal is not to tell users:

“This is the correct version.”

Instead, the goal is:

“This is how different communities speak.”

That distinction matters.

Building for Heritage Speakers

Another important design decision was understanding who the app is actually for.

The Romanes app is not only built for complete beginners.

It is also built for:

• heritage speakers
• diaspora communities
• people reconnecting with their culture
• learners who already recognize certain words or phrases
• people who may have heard the language growing up but never learned it formally

This changes the design philosophy significantly.

The app needs to feel:

• welcoming
• pressure-free
• respectful
• flexible across dialect backgrounds

For many users, learning Romanes is emotional as much as educational.

And the product design has to acknowledge that.

Why Linguistic Accuracy Matters

As the project evolved, it became increasingly important to ensure that the app was grounded in real linguistic research.

That is why collaboration with Yaron Matras became such an important part of the project.

His expertise helped ensure that the app:

• reflects authentic dialect usage
• avoids oversimplification
• respects linguistic variation
• stays rooted in documented language research

When working with endangered or underrepresented languages, accuracy is not just a technical detail.

It is part of cultural responsibility.

Designing Technology Around Language Reality

One challenge with multi-dialect systems is that traditional software structures often assume consistency.

But real language is messy.

Words change.

Spellings vary.

Communities evolve language naturally over time.

Instead of forcing Romanes into rigid structures, the app tries to adapt to the language itself.

That means building systems that can support:

• dialect-specific vocabulary
• shared lesson structures
• flexible comparisons
• expandable language datasets
• future dialect additions

In many ways, the technology had to become more flexible because the language itself is flexible.

Offline-First and Accessibility

Accessibility has also been a core principle from the beginning.

Many modern apps depend heavily on:

• accounts
• subscriptions
• constant internet access
• cloud-based systems

The Romanes app takes a different approach.

The learning content is designed to work directly on-device, making the experience more accessible and more private.

This matters especially for global diaspora communities where internet access, device quality, or digital infrastructure may vary.

The goal is simple:

Make learning available with as few barriers as possible.

More Than Vocabulary

Although the first versions focused heavily on vocabulary learning, the broader vision has always been larger.

Language is connected to:

• culture
• history
• migration
• identity
• memory

Over time, the app continues evolving toward a more complete learning experience that includes:

• guided journeys
• dialect comparison tools
• grammar insights
• cultural context
• interactive learning systems

Not to replace community learning — but to support it.

Looking Forward

Building a multi-dialect language app is not the easiest path.

It requires more structure, more flexibility, and more care.

But languages like Romanes deserve technology that respects their complexity instead of simplifying them into something smaller.

The Romanes app is still evolving.

And there is still much more to build.

But the core idea remains the same as it was at the beginning:

Create a space where people can reconnect with their language, their dialects, and their cultural heritage — without having to leave parts of that identity behind.