The theoretical foundation of the project is compiled in the main concept ["uchitsya-legko.rf — learning to read as decoding a written code"](/concepts/uchitsya-legko-rf-obuchenie-chteniyu-kak-deshifrovke-pismennogo-koda). It is the central point of the project: it describes the general model, current state, and connects specific concepts.

The project is currently at the **Idea** stage. The basic theory of reading as information reconstruction from a written code has been formed. The information entities on which learning is built have been recorded: object and situation, concept, image, spoken word, sound, written word, letters, and larger structural parts of a word.

Key components of the theory:

- [Reading is word recognition and meaning reconstruction, not sequential letter sounding](/concepts/chtenie-eto-raspoznavanie-slova-i-vosstanovlenie-smysla).
- [A written word connects several representations of the same content](/concepts/pismennoe-slovo-svyazyvaet-neskolko-predstavleniy).
- [Learning to read should go from known supports to the unknown code](/concepts/obuchenie-chteniyu-ot-izvestnyh-opor-k-neizvestnomu-kodu).
- [The oral vocabulary is the recognition base when learning to read](/concepts/ustnyy-slovar-baza-raspoznavaniya-pri-obuchenii-chteniyu).
- [A long word must be revealed through familiar structural parts](/concepts/dlinnoe-slovo-cherez-znakomye-strukturnye-chasti).
- [Hints must gradually disappear as connections are mastered](/concepts/podskazki-dolzhny-postepenno-ischezat).

The practical direction is an interactive system where the child starts with recognizable objects and words, confirms their sound, gets acquainted with the spelling, discovers repeating elements of the written code, and then applies the discovered correspondences to decode new words.

Critical principle: the system must not simultaneously require the mastery of several unknown levels. If the child does not know the concept, the spoken word, its sound, and the letters, such a word is poorly suited as starting material. The next task must rely on the already confirmed knowledge of the specific child.

The next stage of the project is to turn the theory into minimal interactive mechanics and test the main criterion: is the child able to transfer mastered correspondences to previously unseen words, rather than just memorizing shown examples.

An interactive project for teaching reading as the gradual decoding of a written code through meanings, images, and spoken words already familiar to the child.

uchitsya-legko.rf

Build a simple web version of the MVP based on the [main concept of the project](/concepts/uchitsya-legko-rf-obuchenie-chteniyu-kak-deshifrovke-pismennogo-koda).

The prototype should be able to:

- display images;
- play recorded pronunciation;
- show the spelling of a word and its individual elements;
- accept the child's choice;
- switch tasks based on a simple mastery state;
- hide individual hints;
- provide at least one control new word to test transfer;
- record answers and the time/order of attempts in sufficient volume for subsequent analysis.

No accounts, payments, complex CMS, large design system layer, or full-fledged game mechanics are needed. The value of the MVP is a working experiment, not a finished product.

Implement a working interactive prototype that goes through a single complete learning cycle without unnecessary platform infrastructure.

Build a browser-based prototype of a minimal MVP

## Context

As part of the `учиться-легко.рф` project, an initial prototype of a speech synthesizer was created using the Web Audio API without audio recordings. Sound is generated parametrically: a voice source, noise, and formant filters define the phoneme state, while the combination of two sounds is structured as a transition between states.

Working hypothesis:

> **An individual sound can be represented as a state of the articulatory-acoustic system, and a combination of sounds as a temporal trajectory of transition between such states.**

This potentially makes it possible not to store ready-made recordings of letters, syllables, and combinations, but to synthesize them dynamically and explore the very mechanism of transition from one sound to another.

## What already exists

The prototype can:

- define Russian vowels and some consonants using a set of parameters;
- generate sound via the Web Audio API;
- play an individual phoneme;
- smoothly interpolate parameters between two phonemes;
- play a transition of the `M → A` type;
- control the transition via a `0..1` slider;
- independently account for voice, noise, formants, nasal component, and volume.

The current implementation is still simplified: most parameters are interpolated simultaneously and linearly.

## What needs to be researched

### 1. Model of Russian sounds

Determine whether a small set of parameters is sufficient for recognizable synthesis of basic Russian sounds.

Minimum to verify:

- vowels `а, о, у, э, ы, и`;
- sonorants `м, н, л, р`;
- fricatives `с, з, ф, в, ш, ж, х`;
- plosives `п, б, т, д, к, г`;
- soft and hard variants of consonants.

It is necessary to understand which sounds can be synthesized relatively easily, and which require a more complex vocal tract model.

### 2. Transitions between sounds

Test the hypothesis that a natural combination cannot be described by simple linear interpolation of all parameters.

For various combinations, research individual temporal trajectories:

- voice;
- noise;
- formant positions;
- nasal tract;
- degree of overlap/constriction;
- conditional position of the tongue and lips;
- duration of holding the first state;
- moment of starting the restructuring to the second state.

Especially check combinations:

- `ма, мо, му, ми`;
- `са, со, су, си`;
- `па, ба, та, да`;
- voiced/voiceless pairs;
- hard/soft pairs.

### 3. Do not tie oneself to the syllabic model in advance

Do not consider the syllable a mandatory unit of synthesis.

Explore a more general process:

`sequence of letters/phonemes → sequence of states → continuous sound trajectory`

It is necessary to understand whether a child can be taught not to memorize ready-made syllables, but the transition between sounds itself.

Example:

`М → А → М → А`

should potentially turn into a continuously reproduced `мама` without the need to store `МА` as a separate object.

### 4. Interactive control

Test the educational value of manual transition control.

For example:

- `М` is displayed on the left;
- `А` on the right;
- the child moves the slider;
- the sound changes in real time from `/м/` to `/а/`;
- then the system automatically reproduces the entire natural transition.

It is necessary to check whether such mechanics help understand the connection between individual sounds and continuous speech.

### 5. Comparison with articulatory synthesis

Study Modular Pink Trombone / Pink Trombone as an architectural reference, but do not set the goal of transferring the entire system.

It is necessary to determine the minimum level of the physical model sufficient for the reading education task.

Possible options:

1. simplified formant synthesis;
2. a hybrid of formant and articulatory synthesis;
3. a full-fledged vocal tract model only for those sounds where the simplified one is insufficient.

## Research result criteria

The research is considered useful if it is possible to answer at least the following questions:

1. Is it possible to synthesize basic Russian sounds without audio recordings with acceptable recognizability?
2. What parameters are minimally necessary for each class of sounds?
3. How naturally does the transition between two sounds sound with simple `lerp`?
4. Which parameters should start and end the transition at different times?
5. Is it possible to get recognizable `ма`, `са`, `па`, `ми` as trajectories without storing them as separate recordings?
6. Is it possible to build a longer sequence in the same way, for example `мама`?
7. Does manual transition control provide an educational effect and help the child understand how a written sequence turns into speech?

## Result artifact

Following the research, it is desirable to obtain:

- a working browser prototype;
- a description of the phoneme parameter model;
- several tuned Russian sounds;
- several tuned transitions;
- observations on where the simple model breaks down;
- a decision on whether to develop our own synthesizer further or use an existing articulatory engine as a basis.

Test whether parametric speech synthesis can be used for reading instruction: individual Russian sounds as states, and their combinations as controlled transitions.

Research parametric synthesis of Russian sounds and transitions between them

## Goal

Add simple browser-based audio playback for educational materials without a separate TTS backend.

Main scenario:

- a child sees a letter, syllable, or word;
- clicks the play button;
- the browser pronounces the corresponding text.

## Technical Foundation

Use the browser's Web Speech API:

- `SpeechSynthesisUtterance`;
- `window.speechSynthesis.speak()`;
- `window.speechSynthesis.cancel()`;
- `speechSynthesis.getVoices()` to select a suitable Russian voice;
- `utterance.lang = 'ru-RU'`.

## What to Support

- individual letters;
- syllables;
- individual words;
- repeated playback;
- canceling current playback before starting a new one;
- selecting a Russian voice if available;
- handling the asynchronous loading of the voice list via `voiceschanged`.

## Important

At the first stage, the task is only about ready-made browser playback. Do not mix it with experiments on a custom speech synthesizer and PCM analysis.

Use the Web Speech API to play educational units: letters, syllables, and individual words.

Add browser-based voice synthesis for letters, syllables, and individual words

## Goal

Add a system of voice characters (`characters`) to the application, through which a child can choose a suitable voiceover style in a playful way.

Main reason: different children may be more comfortable with different speech rates and pitch levels. Instead of technical `rate` / `pitch` settings, provide a choice through understandable characters.

## Basic Idea

Each character stores a set of settings for `SpeechSynthesisUtterance`:

```ts
type VoiceCharacter = {
  id: string
  name: string
  rate: number
  pitch: number
  volume?: number
  voiceName?: string
  avatar?: string
}
```

Example:

```ts
const characters: VoiceCharacter[] = [
  {
    id: 'calm-bear',
    name: 'Bear Cub',
    rate: 0.75,
    pitch: 0.85,
  },
  {
    id: 'default-friend',
    name: 'Friend',
    rate: 1,
    pitch: 1,
  },
  {
    id: 'fast-bird',
    name: 'Little Bird',
    rate: 1.15,
    pitch: 1.35,
  },
]
```

Usage:

```ts
const utterance = new SpeechSynthesisUtterance(text)

utterance.lang = 'ru-RU'
utterance.rate = character.rate
utterance.pitch = character.pitch
utterance.volume = character.volume ?? 1
```

## Character Selection

A separate character selection UI is needed:

- a card with the name and visual image;
- a preview button;
- active/selected character;
- saving the selection for future exercises;
- the ability to quickly switch to another character.

Ideally, the selection should feel like a game setting rather than a system audio config.

## Character Builder

Provide a separate builder right away where you can create your own character.

Minimum parameters:

- name;
- `rate` — speech rate;
- `pitch` — voice pitch;
- `volume` if necessary;
- selection of one of the available system voices;
- visual image/avatar;
- preview on a test phrase.

Example of builder state:

```ts
type VoiceCharacterDraft = {
  name: string
  rate: number
  pitch: number
  volume: number
  voiceName?: string
  avatar?: string
}
```

## Setting Ranges

Do not show technical values to the child as the main interface. Internally, Web Speech API numeric ranges can be used, but the UI is better made intuitive:

```text
Speed:
slow ←─────●─────→ fast

Pitch:
low ←─────●─────→ high
```

For adults/editors, exact values can be displayed additionally.

## Preview

The builder must have a preview button:

```ts
const previewCharacter = (
  character: VoiceCharacterDraft,
  text = 'Hello! Let\'s learn together.',
) => {
  window.speechSynthesis.cancel()

  const utterance = new SpeechSynthesisUtterance(text)
  utterance.lang = 'ru-RU'
  utterance.rate = character.rate
  utterance.pitch = character.pitch
  utterance.volume = character.volume

  const voice = window.speechSynthesis
    .getVoices()
    .find(item => item.name === character.voiceName)

  if (voice) {
    utterance.voice = voice
  }

  window.speechSynthesis.speak(utterance)
}
```

## Architecture

It is important to separate the character from the voiceover mechanism itself.

```text
VoiceCharacter
↓
speech settings
↓
SpeechPlayer / Pronouncer
↓
SpeechSynthesisUtterance
```

That means `SpeechPlayer` should not know about a specific "Bear Cub" or "Little Bird". It receives ready-made parameters.

## Storage

Provide for:

- built-in application characters;
- user characters;
- active selected character;
- saving user choice between sessions.

Choose specific storage within the project architecture: local state, localStorage, or a server entity if characters need to be synchronized between devices.

## Definition of Done

A child can choose one of the ready-made voice characters, hear the difference in speech rate/pitch, use it for further voiceovers, and also create their own character through a simple builder and immediately listen to the result.

Create game voice characters with different speech rate and pitch settings so children can choose a comfortable option, and add a custom character builder.

Add voice character selection and builder

Develop marketing and positioning

## Context

The current project mechanics effectively cover the first level of writing acquisition: working with familiar words, syllables, combinations, and letters.

The next qualitatively different level is **reading a sentence as a structured written utterance**.

One can transition to this even with partial mastery of the first level: the child does not need to know all words and all letter combinations, but must be able to confidently recognize a significant portion of written units so that attention can shift from individual words to the structure of the utterance.

## What is included in the second level

At least the following must be taken into account:

- word order in a sentence;
- sentence boundaries;
- period;
- comma;
- question mark;
- exclamation mark;
- colon;
- dash;
- quotation marks;
- parentheses and other marks as needed;
- pauses;
- change in intonation;
- logical and syntactic connections between parts of the sentence.

## Difference from the first level

At the first level, the main object of study is the written word and its internal parts.

At the second level, an individual word becomes an element of a larger structure. It is necessary to learn to perceive not only the sequence of words, but also additional written signals that govern how the utterance is read and interpreted.

Punctuation here is not a decorative layer. It encodes structure, pauses, intonation, and relationships between parts of the utterance.

## Specific challenges

### Voicing punctuation marks

With letters and words, direct audio playback of the element can be used. With punctuation marks, this is not as straightforward.

If one simply plays audio for "comma," "period," "question mark," the child learns the name of the symbol, but this does not necessarily explain its function within actual reading.

A separate challenge arises: to show the connection between the visual sign and **what it changes in the sound and structure of the phrase**.

### Explaining the purpose

For punctuation marks, recognizing their shape is not enough. It is necessary to gradually build an understanding of their role:

- where to pause;
- where the thought has ended;
- where the intonation changes;
- where one part of the utterance is separated from another;
- how the exact same set of words can be read differently with different punctuation.

### Contextuality

The meaning and effect of a mark appear not in isolation, but within a sentence. Therefore, the mechanics of the second level will almost certainly require working not with an individual mark, but with its action in the context of the utterance.

## Objective of the task

Not to pre-describe specific implementation mechanics, but to thoroughly elaborate the second level of writing acquisition itself:

- its boundaries;
- composition of skills;
- dependencies on the first level;
- mastery criteria;
- scope of material;
- methods for testing transfer to new sentences.

The specific interactive mechanics will be designed separately after the structure of the level becomes sufficiently clear.

Define and implement the next level after mastering words: reading sentences taking into account the structure of written utterances, punctuation, pauses, and intonation.

Tasks

Develop the second level of writing acquisition: sentence reading and punctuation

Develop marketing and positioning

Add voice character selection and builder

Add browser-based voice synthesis for letters, syllables, and individual words

Research parametric synthesis of Russian sounds and transitions between them

Build a browser-based prototype of a minimal MVP