Mural: The Language App That Trains You to Leave It
A deep dive into the local-first AI tutor that turns real-time conversation, spaced repetition, and your own API key into a private path to fluency.
- Mural’s real product is not chat, but a feedback loop that turns every conversation into local learning state.
- Its BYOK and on-device storage choices make privacy part of the pedagogy, not just a compliance feature.
- The app pushes against retention-first language learning by optimizing for independence instead of streaks.
- Its native voice UI matters because fluency is emotional, and the interface is built to feel like conversation rather than software.
Mural is a language app with a strange goal: it wants to become unnecessary. It listens, responds, assesses what you missed, stores the result locally, and uses that state to shape the next exchange. The point is not to keep you inside the app. The point is to get you out of it.
That makes Mural an unusually clear rebuttal to the modern language-learning stack. Most apps are built around retention, recurrence, and habit formation. Mural is built around a different metric: whether you can leave the app and still keep speaking.
Why Mural feels different from every other language app
The easiest way to understand Mural is as an anti-retention product. It still has structure, repetition, and reinforcement, but those mechanics are in service of fluency, not engagement. The app does not just want another session. It wants better speech the next time you open your mouth.
| App | Privacy model | Voice support | Business model | Learning loop |
|---|---|---|---|---|
| Mural | Local-first, user API key, on-device learning state | Real-time voice conversation | Open source, BYOK | Conversation updates local progress, then shapes the next prompt |
| Duolingo | Cloud account, platform data | Limited and productized | Subscription and upsells | Streaks, badges, and content progression |
| Speak | Cloud account, vendor-managed | Voice-first AI tutoring | Subscription | Fast conversational practice inside a closed product |
| LinguaCafe | Self-hosted, user-controlled | Mostly text and reading | Open source | Input-heavy study and sentence mining |
| asbplayer | Local tools for subtitle mining | Not voice-first | Open source | Input-first learning from media subtitles |
The language app you eventually delete. A native iPhone companion for learning through conversation.
That README line is the whole thesis in miniature. Mural is not selling endless lessons or a motivational treadmill. It is selling a narrow, private path toward independence.
The architecture behind the philosophy
The repository makes that philosophy concrete. On Android, the app is built in Kotlin with Jetpack Compose. On iOS, it uses SwiftUI and a custom liquid-glass style. The important part is not the UI technology, though. It is where the learning state lives: on the device, alongside the conversation history, the vocabulary record, and the teacher logic.
Three files do the heavy lifting: LearningEngine.kt, TeachingPolicy.kt, and LearningRepository.kt. Together they turn conversation into a closed loop. The engine interprets performance, the repository keeps that state durable, and the teaching policy feeds the result back into the next prompt.
How Mural turns conversation into a learning engine
The interesting move is not that Mural talks to a model. It is that it also grades the conversation after it happens. The Android code updates a local learner model from each assessment, tracks whether a word was used independently or with help, and projects that history into a next goal. That is a small piece of software pedagogy, not just chatbot plumbing.
`LearningRepository.kt` persists the local file, and it does so atomically. If the app closes mid-conversation, recovery logic can process the final assessment on the next launch. That sounds like a small implementation detail. It is actually the backbone of the product promise, because it preserves continuity without needing a cloud account.
`TeachingPolicy.kt` is the other half of the trick. It turns the learner’s state into system instructions, including due words and the next goal. So the model is not merely aware of the user. It is being steered by a local pedagogy layer that changes what the assistant tries to emphasize.
The engine that remembers what you almost know
The core learning model is the part most apps would outsource to a dashboard. Mural keeps it in code. The engine projects across session history, updates word state, and tracks a simple but revealing abstraction: how well a word is anchored, whether it was recalled independently, and how much support it needed in context.
That gives the app a memory of near-misses. In language learning, that matters. A word you almost know is more useful than a word you have never seen, and Mural’s model is built around that difference. The app is not just storing transcripts. It is synthesizing pedagogical state from them.
// Conceptual shape of the loop
val learnerState = learningEngine.project(sessionHistory)
val dueWords = learnerState.dueWords
val nextGoal = learnerState.nextGoal
val systemPrompt = teachingPolicy.build(
targetLanguage = "Spanish",
dueWords = dueWords,
nextGoal = nextGoal
)
val response = llm.respond(userSpeech, systemPrompt)
val assessment = assessor.extract(response)
learningRepository.save(learningEngine.update(assessment))
The elegant part is the feedback timing. A conversation becomes assessment. Assessment becomes state. State becomes instruction. That is why Mural feels less like a tutor bot and more like a learning system that happens to speak.
The UI matters because fluency is emotional
Mural’s orb-driven interface is not decorative. It lowers the cognitive cost of starting a conversation and makes the app feel warm instead of administrative. That matters more than it sounds. If the surface feels like a form, users will treat it like homework. If it feels like a conversation partner, they are more likely to speak.
The mobile-first polish helps too. Native navigation, animated voice interaction, and a compact visual vocabulary keep the experience focused on output. There is no sense that you are managing a curriculum. You are entering a room, speaking, and leaving with a better model of what you know.
What Mural says about the next wave of mobile AI
Mural sits in a useful middle ground. It is more autonomous than Duolingo, more private than Speak, more conversational than LinguaCafe, and more output-oriented than asbplayer. That combination is rare because it is hard to monetize. It also happens to be what a lot of serious learners actually want.
The broader signal is bigger than language learning. Mural shows what AI-native mobile software can look like when it is built around user ownership instead of platform dependence. The app does not just wrap an API. It turns the API into a local system with memory, policy, and a plausible exit.
| Project | Strength | Trade-off | Best for |
|---|---|---|---|
| Mural | Native voice UX with local learning state | Requires your own API key and some setup | Privacy-conscious learners who want output-first practice |
| Duolingo | Mass-market polish and habit loops | Gamification can outrun usefulness | Casual learners who want structure |
| Speak | Fast voice tutoring | Closed platform and subscription lock-in | Users who want convenience over control |
| LinguaCafe | Self-hosted reading and mining | Less natural for live speaking | Input-heavy learners |
| asbplayer | Subtitle-based sentence mining | Not a live tutor | Media learners building vocab from content |
The most interesting thing about Mural is not that it competes well with existing apps. It is that it changes the question. Instead of asking how to keep learners engaged, it asks how to make the app less necessary over time.





