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

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

Tasks

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