BabelDuck: a self-hosted AI conversation partner for language practice

What BabelDuck solves for people practising a spoken language

Speaking practice has a feedback problem. A tutor corrects you in real time, but a plain chat model will happily let a wrong article or a misplaced particle slide because it prioritises continuing the conversation. BabelDuck's answer is to keep the conversation going and put the correction somewhere else. The README describes asking for grammar, translation or expression refinement "without interrupting the current conversation, with customizable quick commands", and when a suggestion is unclear, opening a sub-conversation and then returning to the original thread. That is a specific interaction design, not a generic chatbot wrapper.

The audience is stated directly: language learners of all levels, with the README naming beginners and "minimizing the barriers and cognitive load of oral expression practice" as the focus. The repository also ships a Chinese README and a multilingual interface, so the tool is not only for English speakers learning something else. If you already have an API key and are comfortable running a container, the setup cost is low. If either of those is false, this is not the right starting point.

The architecture: a Next.js client over your own model endpoints

package.json names the project babel-fish and pins Next.js 14.2.12 with React 18. The AI plumbing comes from the Vercel AI SDK (ai ^3.4.33 and @ai-sdk/openai ^0.0.66), state is Redux Toolkit plus immer, and the UI is Radix primitives, PrimeReact, Tailwind and i18next. Speech uses microsoft-cognitiveservices-speech-sdk together with extendable-media-recorder and its WAV encoder, and diff ^7.0.0 is present, which fits the grammar and refinement suggestion flow where a corrected sentence is shown against the original.

The data flow is deliberately short. The .env.example defines the outbound endpoints: OPENAI_CHAT_COMPLETION_URL, OPENAI_API_KEY and OPENAI_MODEL_NAME for chat, and STT_API_URL plus SILICONFLOW_API_KEY for transcription. Requests go from the browser to the Next.js server and out to those URLs. Conversation data is stored locally, which the README lists under key features. There is no database service in the deployment command and no account system mentioned, so the operational surface is one container plus whatever model provider you point it at.

Installing BabelDuck with Docker and running a first exchange

The README gives a four-step Docker path. First clone the repository, then copy the environment template and fill it in. The .env.example is short and its comments explain why each variable exists, including the note that input handlers are currently coupled to OpenAI and that JSON mode is required, so an OpenAI-compatible service is necessary.

git clone https://github.com/Orenoid/BabelDuck

Then rename .env.example to .env and fill in the configurations, as the deployment section instructs. The template lists the chat variables and the two speech variables, with the comment that the speech-to-text feature is coupled to SiliconFlow for now.

OPENAI_CHAT_COMPLETION_URL=
OPENAI_API_KEY=
OPENAI_MODEL_NAME=
STT_API_URL=https://api.siliconflow.cn/v1/audio/transcriptions
SILICONFLOW_API_KEY=

Then start the published image. The README uses port 9000 on both sides and the tag latest.

docker run -d --name babel-duck --env-file .env -p 9000:9000 orenoid/babel-duck:latest

Visit http://localhost:9000. The README says built-in tutorials are included, so the first useful action is to follow one of those rather than guess at the quick-command configuration. A first real exchange: pick a topic, speak or type a sentence, then trigger a grammar or refinement command and read the suggestion in the side panel. If the panel returns nothing, the most likely cause is a chat endpoint that does not support JSON mode, because the .env.example calls that requirement out explicitly.

Where BabelDuck is the wrong tool

The .env.example is unusually candid about two couplings, and both are real constraints. The first: "the implementation of input handlers is coupled with openai at this time", with JSON mode required. If your preferred provider does not expose an OpenAI-compatible chat completions route with JSON mode, chat will not work regardless of how good the model is. The second: speech-to-text is coupled to SiliconFlow, and the template says you need that API URL and key. A learner who wants Whisper running locally, or who wants Azure speech, cannot simply swap the endpoint; the comment says decoupling is planned but not done.

There is also a deployment gap worth naming. No releases were retrieved, and the README's only install path is the published Docker image tagged latest or a build from source. There is no documented rollback procedure and no version pinning guidance in the README, so if a new latest image changes behaviour you have no documented way back. For a personal practice tool that is tolerable. For anything shared across a team, it is a maintenance liability you should price in before adopting.

Finally, consider the fit. BabelDuck is a practice environment, not an assessment tool. Nothing in the README describes scoring, progress tracking or pronunciation grading, so if you want measurable improvement curves, this is not that product.

How it differs from using a chat app with a tutor prompt

The obvious alternative is a general chat client with a system prompt that says "correct my grammar". The difference is where the correction lives. In a flat chat client, a correction is just another message in the same stream, so the conversation and the meta-conversation interleave and the model's persona drifts between partner and teacher. BabelDuck separates them: quick commands run against the current turn, and a sub-conversation can be opened to discuss a suggestion and then closed, returning you to the original thread. That sub-conversation mechanism is the part a prompt cannot replicate, because the prompt has no second context to return from.

The second difference is data location. A hosted chat client keeps your practice history on someone else's servers. BabelDuck stores data locally and the README lists this under privacy. The trade is that you now own the container, the environment file and the API keys. If you value the privacy and dislike the operations, the honest answer is that neither option dominates; it depends on which cost you would rather pay.

Maintenance, licence and the cost of staying current

The repository is not archived, and the last push was on 2026-04-07. That is roughly five months before this writing, so there is recent activity but no basis for calling the project actively developed on a short cadence. No releases were retrieved, which means the practical upgrade path is pulling orenoid/babel-duck:latest again or rebuilding from the Dockerfile. The Dockerfile itself is a standard multi-stage Next.js build: a deps stage that installs from whichever lockfile it finds (package-lock.json is present, so npm ci runs), a builder stage that runs npm run build, and a runner stage that copies public/ and runs as a non-root nextjs user. It also leaves the NEXT_TELEMETRY_DISABLED lines commented out, so Next.js telemetry is on unless you uncomment them and rebuild.

On licensing, the LICENSE file exists at the repository root, but the repository metadata reports NOASSERTION, meaning the licence could not be automatically classified. The README says only that the project is licensed under that file. Read the file before you deploy this publicly or bundle it into anything commercial; I am not going to guess at its terms, and nothing here is legal advice.

The ongoing cost is mostly the two API bills. Chat tokens scale with how much you practise, and transcription scales with how much you speak. Self-hosting removes subscription fees but not inference fees.

Editorial conclusion

BabelDuck fits learners who want a private, self-hosted chat partner with grammar and translation help on the side, and who already hold an OpenAI-compatible API key and a SiliconFlow key. It is a poor fit if you need a hosted service with zero setup, or if you want to point speech-to-text at a provider other than SiliconFlow, because the .env.example states that coupling has not been removed yet. Before deploying, confirm your OpenAI-compatible endpoint supports JSON mode, check the LICENSE file text yourself since the repository reports NOASSERTION, and treat the absence of releases as a sign you should build from source rather than rely on a versioned artifact.

Frequently asked questions

Official sources

1. Issues
2. Orenoid/BabelDuck on GitHub
3. Project website
4. README