1.2.0

• The notification sounds are now the extension's own, the same on every platform: 60 of them in 2.6 MB, generated for it with Stable Audio Open (a default and a handful of alternatives per event, the prompt and seed behind each kept in assets/sounds/prompts.json), loudness-matched and grouped by event in Configure Notification Sounds, with the actions first and the sounds below, next to a sound file of your own and the system sounds as before. The system libraries differ per platform, the Windows ones are quiet, and a name synced from another machine named nothing; a system name this machine does not have now plays the built-in sound for the event. The tool sound (for the tools in notifications.toolFilter, Bash unless changed) and the subagent sound are on by default, each with its own sound; the prompt sound stays a choice, as the person who submits a prompt is already looking at it. The feature is called notification sounds everywhere now; it was "completion sounds" in the menu and "notification" in the settings.
• On Windows without ffplay, the neural engines play through one player kept for the session: it starts a file in under 100 ms, queues the parts of a streamed utterance as PCM on the audio device (winmm) so they play without a gap, pauses mid-word, and takes the volume. A PowerShell started for every file cost about 850 ms of silence per sentence and could do none of that, and playing a file per part through MediaPlayer left 35-90 ms of silence at every seam and up to 250 ms when the part arrived just in time, heard as a stutter every second once the engine streamed a part a second. The host starts at activation and stays for the session (starting it costs 1.5-2 s, which the first sentence after every quiet stretch used to pay). Where ffplay is installed it keeps its place, for its tempo.
• Qwen3 on the PyTorch runtime generates faster than it speaks on an NVIDIA GPU (measured on a laptop: 0.75x realtime, from 1.65x slower than speech), so a message plays continuously from its first sentence, which starts about 1.5 s after the model is ready. The 15 steps that make each frame's codebooks are recorded once as a CUDA graph and replayed (the loop was bound by launching 6,500 GPU kernels per frame from Python, not by the GPU), and the codec decoder keeps its state between the parts of a sentence, so each part costs only its own frames; decoding the whole prefix and the voice's reference for every part had cost more than the generation itself once the generation was fast. The daemon warms up before it reports ready, so the first sentence is no slower than the second. Set Up the Best Voice recommends Qwen3 on a Windows or Linux machine with an NVIDIA driver, and Kokoro, which keeps up with Claude on any machine, where there is none; the cloning engines stay a choice away for a voice of your own.
• Qwen3 on the PyTorch runtime speaks a whole message without pauses between its sentences, and starts sooner: the daemon generates the chunks queued together in one pass (a model step costs the same for eight sentences as for one, measured: seven sentences in 1.1 times the time of one), so every sentence after the first is ready by its turn where before each one was generated while the one before it played and the listener waited for the difference (measured on a laptop with an NVIDIA GPU: a five-sentence paragraph played in 31 s instead of 45, with no gap between sentences instead of 2-4 s each). The wait before the first sentence is a third shorter, because it was buffering the wall-clock shortfall in seconds of audio, which on an engine 1.9x slower than speech is 1.9 times what it needs. The streamed parts of a cloned voice are now decoded with the reference in front, as the whole utterance is: without it the opening seconds of a sentence decoded to other audio than the rest and the voice changed at the seam.
• The first word arrives in seconds on Windows and Linux with Qwen3 (measured: the first audio 1.1 s after the request, then a part every 1.3 s, where the whole chunk took 14 s before). Its PyTorch runtime now streams: the frames the model has made so far are decoded and played while the rest generates (the codec decoder is causal, and it runs in float32 so every part decodes the same), a cancel ends the generation at once rather than after it, and each frame's codebooks are sampled directly instead of through a full generation pass per frame, which measured 20-25% faster. Off Apple Silicon its pace is planned from what that runtime delivers, and its chunks are sized so that the waits fall between sentences.
• On Windows with an NVIDIA GPU, setting up Qwen3 or Chatterbox installs the build of PyTorch that uses it; the build PyPI ships there runs on the CPU, several times slower than speech, and nothing said so. An existing install that runs on the CPU is named in Check Setup and, when the engine loads, in a message; running the engine's setup again installs it for the GPU. Setting an engine up again for the GPU stops the running engine first: Windows cannot delete or overwrite the files a running daemon holds, so the reinstall failed part-way.
• On Windows the built-in voice speaks through one PowerShell process kept for the session, instead of starting a PowerShell and the speech runtime for every sentence: sentences follow each other without the second or two of silence that cost, speech no longer falls behind Claude, and pausing now holds the sentence mid-word rather than after it. Exports of the built-in voice are rendered through the same process. Where that process cannot start, sentences are spoken the old way. A render for export does not start a speech host after the engine was replaced.
• Every download says how far it is: the Kokoro and Piper archives, uv and a translation model report their bytes against the size the server names ("120 of 335 MB (35%)", with the bar following), and an engine install shows the packages uv is fetching by name and size with how much of what it has announced is done, where it used to show uv's last output line. A translation model is fetched by the extension itself rather than by the translation runtime, so it goes through the editor's proxy like every other download.
• Translated tool announcements name the tool and the file: "Writing edit_design.py" went through the translator as a verb in front of a hidden file name, which one model rendered as "tag:" every time; the verb phrase is now translated on its own ("Writing the file") and the file name follows it as written. A sentence whose file names the model drops is no longer left in the source language: it is asked for on its own, and then with the names in the open, so the sentence is heard in the chosen language at the cost of a possibly misspelled name.
• Designing a voice keeps every take. Each rendering comes out different, and "Try again" threw the previous one away; now every take stays in a list that plays each one as you move over it, with rows to render another take or to change the description (the takes so far are kept), and the name step comes back to the list rather than discarding the rendering. The newest take plays as the list opens.
• Designing a voice for a language the designer cannot read now offers to install Chatterbox first, since it is what records the voice in that language; before, the design ran for minutes and then reported that the recording could not be made. Its first recording fetches Chatterbox's own weights (about 2.5 GB), and the notification now says so and shows how far the download is, where it used to say "recording the voice" for those minutes.
• A voice of your own is auditioned with a sentence in the language it was made for, spoken as that language. Every voice read the same English sentence, and a voice designed for another language read it as if it were that language, which was heard as an accent the voice does not have.
• The boxes a flow asks you to type into stay open when the window loses focus. Switching to another window to copy a voice description closed the box as "back", and the step before it closed the same way, so the language list was what you came back to.
• A cloned voice whose reference recording has long pauses inside it (a designed voice's passage rendered with 0.7-0.85 s between its sentences) no longer swallows sentences: the model ended four in ten after two frames, having learnt from the reference that silence is followed by the end. The daemons hand the model a copy of the reference with pauses over 0.4 s shortened to 0.3 s and the edges trimmed; the profile's own recording is untouched.
• Notification sounds play on Windows, at the volume set: the hook started its player detached, and a process started that way exited within 60 ms without playing (measured with a marker file), and the player it used ignored the volume. The player is now started by a launcher of its own with its window hidden, so it outlives the hook and plays to the end without a console window appearing; the hook waits about 200 ms for the launcher. A sound highlighted in the picker is auditioned through the player speech uses, so it is heard on the first highlight rather than after a process start.
• Notification sounds play on Windows 11: the sound each event fell back to when the configured name was not found ("Windows Proceed") no longer ships there, so a machine set up from the defaults heard nothing. Each event now has a chain of sounds present on every Windows. And a Windows with no node installed, which is most of them, runs the hook through the editor's own runtime by way of a batch file the extension writes next to the hook script, rather than through a "node" that is not there.
• Setting up Kokoro on Windows downloads again: the sherpa-onnx release renamed its Windows build ("win-x64-shared-MD-Release"; the plain name was a 404 on a fresh install), and the Linux ARM build ("linux-aarch64-shared-cpu").
• Setting up Chatterbox on Windows and Linux works again: the vowel-mark package it installs for the writing systems that leave them out asks for a numpy the engine cannot use, and the installer refused the pair ("no solution found"). The package runs on the engine's numpy, so it is installed without its dependency list, with what it needs named alongside.
• Voice backups, the Kokoro download and the private uv unpack work on a Windows where Git's tar comes before the system one on PATH: that tar reads the colon of a drive letter as a remote host name ("Cannot connect to C:"), so archives are handed to it by name from their own directory, and directories are written with forward slashes, which it does not unescape (a "\t" in a path became a tab).
• On Windows with Smart App Control on, the guided setup and the engine list say so before anything is downloaded, and keep the built-in voice: the neural engines are built from open-source components Windows will not load while it is on. The error that used to appear afterwards ("An Application Control policy has blocked this file") now explains itself, and Check Setup shows the state. The setting is left to the person; the extension does not ask anyone to switch a security feature off. The notices say what the condition is (the neural engines run only while it is off) and where the setting lives, and do not claim that the setting cannot be turned on again, which current Windows builds allow. The evaluation period, which blocks nothing, no longer stops an install; the state is read again after 30 seconds rather than once per window; and an engine that is asked to speak while it is on is told so at once rather than a minute later when its runtime fails to load.
• A model download shows how far it is where the runtime writes no file listing into its cache (Windows): the total is asked of the hub while the fetch runs, so the notification and the status bar say "1.4 of 4.2 GB (33%)" with a bar rather than the bytes alone. Designing a voice shows that progress in its own notification instead of pointing at the status bar. The listing is asked of the mirror in HF_ENDPOINT when there is one.
• Changing to a voice that needs Qwen3's other checkpoint no longer loses the first sentence after the change: the model swaps at once, and what was in flight for the old voice is dropped, rather than refusing until the engine fell idle. A chunk prepared ahead of time that fails before its turn (the model swapped under it) is synthesized again at its turn instead of being reported as failed; preparing ahead no longer swaps the model under an audition. The player's watchdog on Windows counts from the last part it was fed rather than from the start of the utterance, so a long streamed sentence is not restarted as stuck; and the daemon logs carry a time on each line.
• Short announcements merge into one utterance only up to the engine's own chunk size, and a sentence half again as long as those chunks is cut at its clauses. On the streaming PyTorch runtime two sentence-sized chunks merged into a 130-character one that opened with five seconds of silence and stuttered inside, and a 147-character sentence waited six seconds in one silence where, cut at its comma, it waits twice, briefly. A player that cannot stretch time (the Windows host) buffers a chunk's whole shortfall before playing it rather than two seconds of it, so a wait falls between sentences instead of inside one.
• ~/.claude/settings.json is written aside and renamed into place, never truncated first: a crash or a second window writing at the same moment could leave the file, and everything in it, empty. The hook script and the uninstall script write it the same way.
• Two windows no longer speak the same session at once on Windows: a heartbeat whose rename was refused while another window was reading it dropped the window from the registry for a moment, and a window that could not see itself spoke its own folders while the oldest window spoke them too.
• Exporting the built-in Windows voice works: its audio was rendered onto the file it was then renamed over, which Windows refused while the voice's process still held it, and the entry was lost.
• On macOS, an audio part that cannot be opened no longer stalls the player until its watchdog restarts it.
• Skipping or superseding a sentence prepared ahead of time removes its audio file; a cancelled synthesis left one in the temp directory every time.
• "Storage and Cleanup" and "Remove Everything" open several times faster on Windows: the size of a Python tool environment (tens of thousands of files) is measured many files at a time.
• The Qwen3 PyTorch daemon converts its audio to PCM in one vectorized step rather than a Python loop per sample, keeps at most eight voice prompts on the GPU, and generates without autograd bookkeeping; the daemons keep a bounded, oldest-out list of cancelled requests rather than emptying it wholesale, which un-cancelled queued requests and generated audio nobody would play. A daemon that dies mid-write no longer raises in the extension host, and the last lines of a daemon crash reach its log.