Tiphareth Studio

The Ecosystem · 2026

Fluens

Fluency comes from producing speech in rhythm, so the machine must do what a teacher does, and cut a wrong answer while it is still being spoken.

A desktop teacher for spoken Spanish that pulls full-sentence answers out of you in rhythm, and interrupts a wrong one while it is still being said.

Fluens mid-lesson, a photographed pen on a table above the expected answer

Fluens mid-lesson, a photographed pen on a table above the expected answer "es un bolígrafo", position 2 of 491 in the stage, with replay, skip and stop as the only controls on screen.

The scarce thing

Input is abundant. The teacher's tempo is not.

A language learner today is drowning in materials: graded audio, image association, reference dictionaries, an endless drill feed. And one thing remains scarce enough that people pay for it by the hour, four times a week: a person who forces you to produce full spoken sentences at pace, and cuts you the instant one goes wrong. Every mainstream app fails at exactly that point, and they all fail for the same reason.

  1. The feed that never ends

    Drill apps optimize for the daily visit: an infinite stream of recognition exercises, cleverly variable, deliberately unfinishable. What they train is recognizing the language. What fluency requires is producing it, which is a different muscle exercised almost never.

  2. Tapping is not speaking

    Most exercises resolve by touching a button or assembling word tiles. The mouth, the organ actually being trained, is optional. A learner can hold a three-hundred-day streak without having composed a spoken sentence under any time pressure at all.

  3. Correction arrives as a comment

    When speech is graded, the verdict comes after the utterance: a score, a highlight, a gentle note. A human teacher interrupts inside the wrong word. The difference is not politeness, it is mechanism: one rewires the sentence being formed, the other annotates a sentence already finished.

  4. Translation as a ceiling

    The mainstream apps teach through the learner's own language: instructions, glosses, explanations, every new word translated on contact. That installs a translation step in the middle of processing, and the step does not dissolve on its own: it becomes the permanent ceiling on how fast speech can flow. The Direct Method refuses it outright, and so does this design.

  5. The tutor does not scale

    The live lesson works. It is also expensive, scheduled, and capped at a few hours a week, when the stated goal is closer to daily. The scarce ingredient is not knowledge or content, it is tempo held by another person, and tempo is the one thing nobody has bottled.

  6. No corpus to teach from

    For Spanish there is no usable question-and-answer corpus in this method, so even a perfect engine would have nothing to say. Generating the material, thousands of questions with audio and images, is not tooling around the product. It is half of it.

Where the mechanism dies

a teacher cuts inside the word an app a comment, after the wrong word begins here, in both rows past roughly six hundred milliseconds, a cut stops being a cut
The correction that changes a habit and the correction that merely describes it are the same words at different latencies. A teacher lands inside the utterance; software lands after it. Past roughly six hundred milliseconds a cut stops being a cut and becomes a comment, and the mechanism dies.

The reframe

The lesson, without the teacher, for the days there is no lesson.

Fluens does not compete with the drill apps, or with the live lesson. It bottles the one scarce thing: the Direct Method turn, question asked in the target language, answered aloud in a full sentence, wrong answers cut mid-word and remodeled instantly. The pedagogy is taken as a set of hard interface constraints, not as inspiration.

The machine never explains. It asks, listens, and cuts, in the target language, at the teacher's tempo.
What the apps train What the turn trains
Recognition drills, resolved by tapping Full spoken sentences, produced in rhythm
Feedback after the exercise, as a score A cut inside the utterance, then the correct form
Grammar stated, then practiced Grammar inferred from contrasting examples
Your language as the interface Only the target language, from the first minute
A streak measuring attendance A bench measuring the cut, in milliseconds
Content licensed, or missing entirely Content generated as part of the product

The second reframe: latency is the pedagogy

A human teacher interrupts a wrong answer two to four hundred milliseconds after it goes wrong. Hold that number and the entire project collapses into a single engineering question: what is the fastest correct way to decide, while someone is mid-sentence, that the words are no longer the right ones? Everything else, the interface, the content, the modes, is arranged around protecting that decision.

The budget has a second clause that matters more than speed: zero false positives. Cutting a correct answer, even once, teaches the learner that the teacher cannot be trusted, and an untrusted teacher's cuts stop working. So every design choice is biased the same way: it is acceptable to miss a cut, it is never acceptable to cut a right answer.

What the system carries

One turn, held to a teacher's standard

Each piece exists to keep the turn honest: the cut fast, the rhythm unbroken, the correction spoken, and the whole thing measurable rather than merely felt.

The cut

The answer is decoded live against forms known in advance, and the moment the words diverge the audio stops and the correct sentence is modeled. The hot path holds a hard budget under four hundred milliseconds, because past that the interruption becomes commentary.

rust engine · vosk

The full-sentence unit

Every question demands a complete sentence that reuses the question's own structure. What gets exercised is syntax under time pressure, not vocabulary recall, which is exactly the part no tile-assembling exercise ever touches.

speaking mode

Two layers of listening

Content and pronunciation are separate listeners running in parallel with no barrier. Content decides the cut on the hot path. Pronunciation scores each sound after the utterance and answers in color, never in text and never by interrupting, so the second opinion cannot poison the tempo.

layer 1 · layer 2

The honest bench

Latency is only a number on replayed recordings annotated with the exact onset of the first wrong sound. Live microphone sessions show lag for feel; the bench shows cut latency for truth. The first bench run rejected the obvious decoder design, which is precisely what a bench is for.

replay mode

Content as product

No usable corpus exists for Spanish in this method, so a pipeline generates it: lessons enriched into question-answer pairs, audio synthesized in Peninsular Spanish with distinción, images tied to vocabulary, everything compressed until six stages of material fit inside a desktop app.

generation pipeline

Three doors into the same material

Speaking is the method; writing and dictation are its supporting angles over the same stages, sharing navigation and progress. The lesson stays one body of material approached three ways, not three apps stapled together.

speaking · writing · dictation

Architecture

The whole project is the choice of a decoder

Two structural decisions carry the argument. The first is that the voice feeds two listeners in parallel, and only one of them is allowed to interrupt. The second is that the turn loop lives in Rust, because the latency budget is a load-bearing wall and JavaScript timer jitter alone is enough to knock it down.

Two listeners, one knife

the voice content: are these still the right words? the cut hot path, under four hundred milliseconds, may interrupt pronunciation: was each sound acceptable? answers in color, after off the clock, scores the recording, never interrupts two listeners, no barrier: only one of them holds the knife
Content listening decides the cut on the hot path. Pronunciation listening scores the recording afterward and answers in color. They run in parallel with no barrier, so the slow judgment can be as careful as it likes without ever touching the tempo.

The separation is what makes both jobs solvable. The content layer can be accent-tolerant and brutally fast because it only asks whether the right words are arriving in the right order, against answers known before the learner opens their mouth. The pronunciation layer can be slow and exacting because it has the whole utterance on disk and no deadline. Collapsing the two into one recognizer is how speech feedback usually becomes both late and wrong.

The engine keeps the audio stream open for the entire session, because opening a player per event costs a hundred to three hundred milliseconds, which is the entire budget spent before the first phone is heard. Gap timings between question, repeat, prompt and next turn are configuration, tuned in code to keep the lesson dense: the method's no-dead-air rule, implemented as constants.

One turn, end to end

ask ask again prompt, overlapped listen the answer completes cut, and the correct form modeled next question, sixty milliseconds later no dead air anywhere: the rhythm is the mechanism, the gaps are tuned in code
Ask, ask again, prompt overlapped, listen. From listening there are two exits and both are spoken: the answer completes, or it is cut and the correct form modeled at once. Sixty milliseconds later, the next question.

The loop runs in two modes that deliberately measure different things. Replay mode feeds annotated recordings through the engine in real time, recordings built so the onset of the first wrong sound is a known coordinate rather than an impression, and only there does a latency claim mean anything. Microphone mode is for the real lesson, where the number shown is how far the decision fell behind the audio clock, honest about being a feel, not a measurement.

The first bench run earned its keep immediately: the obvious design, a decoder constrained to a grammar of expected answers, turned out to go silent on a wrong word instead of flagging it, so divergence arrived disguised as a student who had not finished speaking. That design was rejected on the evidence, and detection moved to watching the decoder's confidence frame by frame. The bench did not validate the architecture. It replaced it.

The substrate

Everything is local. The engine, the recognizer, the synthesized audio, the images, the progress files: a single desktop bundle with no account, no server, and no lesson data leaving the machine. Six stages of generated material ship inside it, compressed from gigabytes of raw audio and images down to a fraction the size.

The schema is multi-language from day one even though the first target is Spanish, because the expensive asset, the generation pipeline, is language-shaped rather than Spanish-shaped.

  • Speakingthe method itself, the timed question-answer turn
  • Writingthe same material, typed against the clock of a card
  • Dictationheard sentences, transcribed, across chosen stages
  • Enginethe Rust turn loop, the cut, the budgets
  • Pipelinelessons enriched, voiced, illustrated, compressed

What the bench keeps

The first honest measurement rejected the obvious design

The most valuable artifact so far is not a feature. It is a bench result: proof that the intuitive architecture fails in a way a demo would never reveal, because its failure mode is indistinguishable from a student pausing mid-sentence. A system whose central claim is a number has to be built so the number can be checked, and checking it is what redirected the project.

the recording the wrong sound begins here, known in advance the decoder silence a silence that starts at the mistake looks exactly like a student mid-sentence only the annotated recording could tell them apart: the bench rejected the design
The recording knows where the mistake begins. The decoder's silence begins at the same coordinate, which is exactly why the silence proves nothing on its own: only against the annotation does it become a measurement, and the measurement said no.

Fluens is the successor to the first work of the 2025 lab: three language-app prototypes that all stalled in the same place. The code was never the bottleneck; the content was. They ran out of material after two partial stages of English, and for Spanish no usable corpus exists at all. Naming that failure honestly is what shaped version one, where the generation pipeline is not a build step but half the product, and six stages of question-answer material, voiced and illustrated, ship inside the app.

The name is the thesis. Latin fluens, flowing, the root of fluent: the claim that fluency is a property of speech flow under tempo, not of accumulated vocabulary. The Direct Method has held that position for over a century with a human teacher enforcing it. Fluens is a bet that the enforcement, the rhythm, the cut, the immediate remodeling, can survive being turned into an engine with a latency budget, and that the days between live lessons no longer have to be days off.

It is in daily use by its two intended learners, which is the only success criterion version one was given. What it is not: a product, a subscription, or a general tutor. It teaches exactly one method to exactly two people, and every general claim it makes, about latency, about false positives, about what a bench can reject, was paid for on that small, real scale first.

← All works