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.

9 to 11 min read • View on GitHub • More from Chuloo

A lone phone glows on a bare desk like a small lantern. Speech bubbles rise from the screen, then resolve into index cards and fade into open space, while a sealed envelope, a key, and a notebook sit nearby as signs of privacy and control. The image explains Mural’s core idea: conversation turns into learning state that the user can carry without the app.
Mural treats conversation as a temporary bridge to fluency, not a loop to trap you in.
Key Takeaways

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.

AppPrivacy modelVoice supportBusiness modelLearning loop
MuralLocal-first, user API key, on-device learning stateReal-time voice conversationOpen source, BYOKConversation updates local progress, then shapes the next prompt
DuolingoCloud account, platform dataLimited and productizedSubscription and upsellsStreaks, badges, and content progression
SpeakCloud account, vendor-managedVoice-first AI tutoringSubscriptionFast conversational practice inside a closed product
LinguaCafeSelf-hosted, user-controlledMostly text and readingOpen sourceInput-heavy study and sentence mining
asbplayerLocal tools for subtitle miningNot voice-firstOpen sourceInput-first learning from media subtitles

The language app you eventually delete. A native iPhone companion for learning through conversation.

Chuloo, Author/Maintainer · Chuloo/mural - GitHub

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.

Mural is not a passive voice client. It is a stateful tutor whose memory changes the next conversation.

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.

A split close-up shows two tutoring systems side by side. On the left are badges, streak flames, and locked progression chains packed tightly together. On the right are a quiet desk, a voice waveform, a notebook, and a small engine made from index cards and gears. The image explains that Mural replaces gamified retention with a calmer feedback loop built around memory and use.
Mural’s learning loop is quieter than the usual language app because it measures progress, not compulsion.

`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.

ProjectStrengthTrade-offBest for
MuralNative voice UX with local learning stateRequires your own API key and some setupPrivacy-conscious learners who want output-first practice
DuolingoMass-market polish and habit loopsGamification can outrun usefulnessCasual learners who want structure
SpeakFast voice tutoringClosed platform and subscription lock-inUsers who want convenience over control
LinguaCafeSelf-hosted reading and miningLess natural for live speakingInput-heavy learners
asbplayerSubtitle-based sentence miningNot a live tutorMedia 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.