Skip to content

armgit / nota

Public Imported from GitHub
0

Nota — a free DAW for macOS, Windows and Linux. No subscription, no account — just open it and make music.

(feat) Download interface languages from nota-translations (#476) (#485)

Egor Khindikaynen964150d2aaaa
diff --git a/.agents/skills/release/SKILL.md b/.agents/skills/release/SKILL.md
index 8c85be7e..94431726 100644
--- a/.agents/skills/release/SKILL.md
+++ b/.agents/skills/release/SKILL.md
@@ -272,6 +272,11 @@ already has `develop` as a parent.
after the tag), show the diff and fix it at the source. Don't edit the draft by hand to
make it match. The user reviews the draft and publishes it themselves, then posts
`../media/news/X.Y.Z.{en,ru}.md` with `X.Y.Z.png` to the channels.
+5. Interface languages (spec 077): nota-translations pulls each release's English reference
+ on its own once a day. So that the language list knows this version straight away, start
+ its publish run now: `gh workflow run publish.yml --repo nota-daw/nota-translations`, then
+ check that `reference/X.Y.Z.json` is on its `published` branch
+ (`gh api repos/nota-daw/nota-translations/contents/reference/X.Y.Z.json?ref=published -q .name`).
---
diff --git a/.claude/skills/release/SKILL.md b/.claude/skills/release/SKILL.md
index 8c85be7e..94431726 100644
--- a/.claude/skills/release/SKILL.md
+++ b/.claude/skills/release/SKILL.md
@@ -272,6 +272,11 @@ already has `develop` as a parent.
after the tag), show the diff and fix it at the source. Don't edit the draft by hand to
make it match. The user reviews the draft and publishes it themselves, then posts
`../media/news/X.Y.Z.{en,ru}.md` with `X.Y.Z.png` to the channels.
+5. Interface languages (spec 077): nota-translations pulls each release's English reference
+ on its own once a day. So that the language list knows this version straight away, start
+ its publish run now: `gh workflow run publish.yml --repo nota-daw/nota-translations`, then
+ check that `reference/X.Y.Z.json` is on its `published` branch
+ (`gh api repos/nota-daw/nota-translations/contents/reference/X.Y.Z.json?ref=published -q .name`).
---
diff --git a/.cursor/skills/release/SKILL.md b/.cursor/skills/release/SKILL.md
index 8c85be7e..94431726 100644
--- a/.cursor/skills/release/SKILL.md
+++ b/.cursor/skills/release/SKILL.md
@@ -272,6 +272,11 @@ already has `develop` as a parent.
after the tag), show the diff and fix it at the source. Don't edit the draft by hand to
make it match. The user reviews the draft and publishes it themselves, then posts
`../media/news/X.Y.Z.{en,ru}.md` with `X.Y.Z.png` to the channels.
+5. Interface languages (spec 077): nota-translations pulls each release's English reference
+ on its own once a day. So that the language list knows this version straight away, start
+ its publish run now: `gh workflow run publish.yml --repo nota-daw/nota-translations`, then
+ check that `reference/X.Y.Z.json` is on its `published` branch
+ (`gh api repos/nota-daw/nota-translations/contents/reference/X.Y.Z.json?ref=published -q .name`).
---
diff --git a/.gemini/skills/release/SKILL.md b/.gemini/skills/release/SKILL.md
index 8c85be7e..94431726 100644
--- a/.gemini/skills/release/SKILL.md
+++ b/.gemini/skills/release/SKILL.md
@@ -272,6 +272,11 @@ already has `develop` as a parent.
after the tag), show the diff and fix it at the source. Don't edit the draft by hand to
make it match. The user reviews the draft and publishes it themselves, then posts
`../media/news/X.Y.Z.{en,ru}.md` with `X.Y.Z.png` to the channels.
+5. Interface languages (spec 077): nota-translations pulls each release's English reference
+ on its own once a day. So that the language list knows this version straight away, start
+ its publish run now: `gh workflow run publish.yml --repo nota-daw/nota-translations`, then
+ check that `reference/X.Y.Z.json` is on its `published` branch
+ (`gh api repos/nota-daw/nota-translations/contents/reference/X.Y.Z.json?ref=published -q .name`).
---
diff --git a/.github/skills/release/SKILL.md b/.github/skills/release/SKILL.md
index 8c85be7e..94431726 100644
--- a/.github/skills/release/SKILL.md
+++ b/.github/skills/release/SKILL.md
@@ -272,6 +272,11 @@ already has `develop` as a parent.
after the tag), show the diff and fix it at the source. Don't edit the draft by hand to
make it match. The user reviews the draft and publishes it themselves, then posts
`../media/news/X.Y.Z.{en,ru}.md` with `X.Y.Z.png` to the channels.
+5. Interface languages (spec 077): nota-translations pulls each release's English reference
+ on its own once a day. So that the language list knows this version straight away, start
+ its publish run now: `gh workflow run publish.yml --repo nota-daw/nota-translations`, then
+ check that `reference/X.Y.Z.json` is on its `published` branch
+ (`gh api repos/nota-daw/nota-translations/contents/reference/X.Y.Z.json?ref=published -q .name`).
---
diff --git a/.gitignore b/.gitignore
index 590f1551..a01cb670 100644
--- a/.gitignore
+++ b/.gitignore
@@ -35,5 +35,3 @@ src/managed/Nota.Remote/wwwroot/
.netcoredbg_hist
-# spec 077 migration working file (scripts/loc-migrate.py --plan)
-keymap.tsv
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 88e91f1b..f6a6e6ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,9 @@ Entry categories: `Added`, `Changed`, `Fixed`, `Removed`.
## [Unreleased]
### Added
+- **Preview a translation**: **Load file…** in Settings → Appearance → Language runs Nota in a
+ language file from your disk after a restart and lists the entries it cannot use;
+ `NOTA_UI_LANGUAGE=/path/to/file.json` does the same for one run.
- **Link a group's tracks** (#184): the Link key (a chain link) on a group's header, its
Mixer strip and its menu ties the tracks in the group together — for a dry and an amped
guitar recorded side by side, say. Arming one arms them all; clicking a clip selects the
@@ -186,6 +189,15 @@ Entry categories: `Added`, `Changed`, `Fixed`, `Removed`.
the same way.
### Changed
+- **Interface languages are downloaded** (#476): Nota now ships in English, and every other
+ language comes from the new [nota-translations](https://github.com/nota-daw/nota-translations)
+ repository. **Settings → Appearance → Language** lists the languages there with how complete
+ each is for your version; choosing one downloads it (checked against its published checksum)
+ and it applies after the usual restart. Installed languages work offline, an **Update**
+ appears when a better translation is published, and **Remove** takes one away. If you used
+ French before this version, Nota fetches it in the background on first start and offers the
+ restart in the status bar (with update checks off, the Language row offers the download
+ instead). Translators can fix or add a language with a pull request there, no build needed.
- **Dragging a section now moves its content too** (#192). To move only the section marker,
as before, hold ⌥ (Alt on Windows and Linux) while dragging; resizing a section's edges
still never touches the music.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 42776a8c..f9890829 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -122,10 +122,10 @@ Give it the issue number up front; don't override that check.
The desktop app's interface is translated through one mechanism (specs
[068](specs/068-ui-language/) and [077](specs/077-key-based-localization/)): every text is asked
for by a **key**, and its English lives in one file, the English reference
-`src/managed/Nota.Application/Localization/en.json`. Each other language is one JSON file of the
-same keys, `src/managed/Nota.App/Languages/<code>.json` (French is `fr.json`); the languages are
-moving to their own repository, [nota-daw/nota-translations](https://github.com/nota-daw/nota-translations),
-from the next release.
+`src/managed/Nota.Application/Localization/en.json`. Nota ships English only. Every other
+language lives in [nota-daw/nota-translations](https://github.com/nota-daw/nota-translations) —
+translating, fixing a translation and adding a language happen there, with its own README —
+and Nota downloads it from **Settings → Appearance → Language**.
- **Every new user-visible text goes through `Loc`, by key.** Add the key and its English to
`en.json`, then write `Loc.T("preferences.language.restart")` for a text,
@@ -139,33 +139,26 @@ from the next release.
`device.reverb`); a text used the same way in three or more areas is `common.<what>`
(`common.cancel`). Two meanings of one English word are two keys (`menu.open`, `clip.open`) —
there are no contexts.
-- **Changing English**: edit the text in `en.json` only; no call site and no translation file
+- **Changing English**: edit the text in `en.json` only; no call site and no translation
changes, and every translation stays attached. If the *meaning* or the placeholders change,
make a new key instead and delete the old one, so translators see a new text rather than a
- stale one.
+ stale one. Placeholders are `{0}` … `{9}`, and every text must format.
- The smoke test fails on a key used in the code that is not in `en.json`, an `en.json` key
nothing uses, a key used against its shape (a counted text through `Loc.T`, a pattern with
- `{0}` through `Loc.T`), a new plain literal that reads as interface text, and a key French does
- not cover. Text that is not translated on purpose — user content, device and parameter names,
- proper nouns, units, logs, the Remote web page and MCP — is listed with its reason as `# data:`
- in `tests/Nota.SmokeTest/LocalizationAllowList.txt`.
-- **Add a language**: copy `fr.json` to `<code>.json` (two lowercase letters), set `code`,
- `name` (the language's own name, shown in Preferences → Appearance → Language) and `plural`
- (`one_is_1` when only 1 is singular, as in English; `one_is_0_1` when 0 and 1 are, as in
- French), translate the strings you can and delete the rest — anything missing shows in
- English. Also list the code in `CFBundleLocalizations` of `scripts/bundle-mac.sh` and
- `scripts/package-dmg.sh` (the smoke test checks it), so macOS shows its own text — Hide, Quit,
- the open panels — in that language too. The file format is in
- [specs/077-key-based-localization/contracts/language-file.md](specs/077-key-based-localization/contracts/language-file.md).
-- **Translate or fix a string**: edit its value in the language file; the English it stands for
- is the same key in `en.json`. Keep the placeholders (`{0}`, `{1}`) and give a counted text
- both forms (`one`, `other`). Follow the glossary in
- [specs/068-ui-language/glossary.md](specs/068-ui-language/glossary.md) (infinitive for
- actions, sentence case, a narrow no-break space before `:` `;` `?` `!`). Device and parameter
- names stay in English.
-- **Look at it**: run `NOTA_UI_LANGUAGE=fr` to start in a language for that run without
- touching the saved setting, and check that nothing is clipped or overlaps at each interface
- scale. `NOTA_LOC_WRITE_BASELINE=1` rewrites the allow-list after you wrap or add text.
+ `{0}` through `Loc.T`), an English text that does not format, a translation file inside the
+ app, and a new plain literal that reads as interface text. Text that is not translated on
+ purpose — user content, device and parameter names, proper nouns, units, logs, the Remote web
+ page and MCP — is listed with its reason as `# data:` in
+ `tests/Nota.SmokeTest/LocalizationAllowList.txt`.
+- **New texts reach translators by themselves**: nota-translations pulls `en.json` from
+ `develop` and from every release tag, and checks each language against them. A new key shows
+ in English until a translation for it is merged there — nothing to do in this repository.
+- **Look at it**: `NOTA_UI_LANGUAGE=fr` (an installed language) or
+ `NOTA_UI_LANGUAGE=/path/to/fr.json` (any language file) starts Nota in that language for one
+ run without touching the saved setting; check that nothing is clipped or overlaps at each
+ interface scale. `NOTA_LANGUAGES_URL` points the language list at another copy of
+ nota-translations (a URL, or a local folder with its layout). `NOTA_LOC_WRITE_BASELINE=1`
+ rewrites the allow-list after you wrap or add text.
## Building
diff --git a/FEATURES.md b/FEATURES.md
index abf2c837..9010e2cc 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -1414,14 +1414,22 @@ audio effects after it keep running and keep their settings; saved with the proj
when you select a track or clip** (off by default: a double-click opens it). Also
**AI control (MCP)** on/off, a port field, and "Copy config" (copies a
ready-made client JSON config to the clipboard).
-- **Language** (Appearance): the interface language — **English** (default) or **Français**,
- each shown in its own name in a drop-down. The choice is saved; it applies after a restart,
- and the row beside the list says so, with a **Restart** button that closes Nota by its usual
- path (unsaved changes first) and starts it again. Menus, panels, dialogs, tooltips, status
- and error messages and the command palette follow the language; device and parameter names,
- and anything you typed, stay as they are. Another language is one JSON file in
- `src/managed/Nota.App/Languages/`; a text it does not cover shows in English. On macOS the system's own text (application menu, open and save panels) follows the language from the next start. The Remote
- phone page, MCP tool descriptions and logs are not translated.
+- **Language** (Appearance): the interface language. Nota ships in **English**; every other
+ language is downloaded from [nota-translations](https://github.com/nota-daw/nota-translations).
+ The drop-down lists English, the installed languages and those available for download, each
+ in its own name with how complete it is for this version; choosing one downloads it
+ (checked against its published size and checksum) and keeps it for offline use. **Update**
+ appears when a newer translation is published, **Remove** deletes one, and **Load file…**
+ runs Nota in a language file from disk, listing the entries it cannot use. The choice applies
+ after a restart, and the row says so, with a **Restart** button that closes Nota by its usual
+ path (unsaved changes first). A stored language that is not installed yet is fetched in the
+ background at start and the status bar offers the restart; with update checks off, Nota asks
+ the network only when you click. Menus, panels, dialogs, tooltips, status and error messages
+ and the command palette follow the language; device and parameter names, and anything you
+ typed, stay as they are; a text a language lacks shows in English. `NOTA_UI_LANGUAGE` (a
+ code or a language file's path) sets the language for one run. On macOS the system's own
+ text (application menu, open and save panels) follows the language from the next start. The
+ Remote phone page, MCP tool descriptions and logs are not translated.
- **Shortcuts**: the shortcut list.
- Settings, logs and autosaves live in `~/Library/Application Support/Nota/` (macOS) and
`%APPDATA%\Nota` (Windows).
diff --git a/scripts/loc-migrate.py b/scripts/loc-migrate.py
deleted file mode 100755
index 8bedb112..00000000
--- a/scripts/loc-migrate.py
+++ /dev/null
@@ -1,590 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: AGPL-3.0-only
-# Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
-"""
-One-off migration of interface texts from English-text-as-key to stable keys (spec 077,
-research R2 / R4). Standard library only.
-
- --plan scan the source, build the text -> key map, write keymap.tsv (repo root,
- git-ignored). An existing keymap.tsv is read back first, so keys renamed
- by hand in it stick on the next run.
- --apply write src/managed/Nota.Application/Localization/en.json, convert
- src/managed/Nota.App/Languages/fr.json to format 2 and rewrite every
- Loc.T / Loc.F / Loc.Plural call and every {app:T ...} in place.
- --verify COMMIT compare the tree with COMMIT (before the migration): every call site, in
- order, must now use the key its old text maps to, and en.json / fr.json
- must give that key exactly the old English / French. Exit 1 on any
- difference.
-
-The scanner mirrors tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs (LocT, LocF,
-LocPlural, LocXaml), so it sees exactly the keys the smoke test checks. It fails on any Loc
-call it cannot read rather than guess. Deleted again once spec 077 is done (PR 3).
-"""
-
-import argparse
-import html
-import collections
-import json
-import os
-import re
-import subprocess
-import sys
-
-ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-MANAGED = os.path.join(ROOT, "src", "managed")
-EN_PATH = os.path.join(MANAGED, "Nota.Application", "Localization", "en.json")
-FR_PATH = os.path.join(MANAGED, "Nota.App", "Languages", "fr.json")
-KEYMAP = os.path.join(ROOT, "keymap.tsv")
-
-LIT = r'"(?:[^"\\\n]|\\.)*"'
-RE_T = re.compile(r'\bLoc\.T\(\s*(?P<t>' + LIT + r')(?:\s*,\s*(?:context:\s*)?(?P<c>' + LIT + r'))?')
-RE_F = re.compile(r'\bLoc\.F\(\s*(?P<t>' + LIT + r')')
-RE_PLURAL = re.compile(r'\bLoc\.Plural\((?P<n>[^"]*?),\s*(?P<one>' + LIT + r')\s*,\s*(?P<t>' + LIT + r')'
- r'(?:\s*,\s*(?:context:\s*)?(?P<c>' + LIT + r'))?')
-RE_PLURAL_NEW = re.compile(r'\bLoc\.Plural\(\s*(?P<t>' + LIT + r')\s*,')
-RE_ANY = re.compile(r'\bLoc\.(?:T|F|FC|Plural)\(')
-RE_XAML = re.compile(r"\{app:T\s+(?:'(?P<q>(?:[^'\\]|\\.)*)'|(?P<t>[^\s'},][^},]*?))\s*(?:,\s*Context=(?P<c>[^}\s]+))?\s*\}")
-KEY_RE = re.compile(r'^[a-z0-9_]+(\.[a-z0-9_]+)+$')
-MAX_KEY = 80
-
-SKIP_PREFIXES = ("Nota.Application/Localization/",)
-SKIP_FILES = {"Nota.App/TExtension.cs"}
-
-
-# ---- C# reading ---------------------------------------------------------------------------
-
-def code_of(line):
- """The line without its // comment (a // inside a string stays), as the smoke test's
- CodeOf; returned blank-padded so offsets keep matching the original line."""
- i, n = 0, len(line)
- while i < n:
- ch = line[i]
- if ch == '/' and i + 1 < n and line[i + 1] == '/':
- return line[:i] + ' ' * (n - i)
- if ch in '"\'':
- q = ch
- i += 1
- while i < n and line[i] != q:
- i += 2 if line[i] == '\\' else 1
- i += 1
- continue
- if ch in '@$' and i + 1 < n and line[i + 1] in '"@$':
- # verbatim / interpolated: skip to the closing quote, "" is an escaped quote
- j = i
- while j < n and line[j] != '"':
- j += 1
- verbatim = '@' in line[i:j]
- j += 1
- while j < n:
- if line[j] == '"':
- if verbatim and j + 1 < n and line[j + 1] == '"':
- j += 2
- continue
- break
- j += 2 if (not verbatim and line[j] == '\\') else 1
- i = j + 1
- continue
- i += 1
- return line
-
-
-def blank_code(text):
- return '\n'.join(code_of(l) for l in text.split('\n'))
-
-
-def blank_xml_comments(text):
- return re.sub(r'<!--.*?-->', lambda m: re.sub(r'[^\n]', ' ', m.group(0)), text, flags=re.S)
-
-
-_ESC = {'n': '\n', 't': '\t', 'r': '\r', '0': '\0', '\\': '\\', '"': '"', "'": "'", 'a': '\a',
- 'b': '\b', 'f': '\f', 'v': '\v'}
-
-
-def unescape(body):
- """A C# regular literal body to its text, as .NET Regex.Unescape does for these."""
- out, i = [], 0
- while i < len(body):
- c = body[i]
- if c != '\\' or i + 1 >= len(body):
- out.append(c)
- i += 1
- continue
- e = body[i + 1]
- if e == 'u' and re.match(r'[0-9a-fA-F]{4}', body[i + 2:i + 6]):
- out.append(chr(int(body[i + 2:i + 6], 16)))
- i += 6
- elif e == 'x' and re.match(r'[0-9a-fA-F]{2}', body[i + 2:i + 4]):
- out.append(chr(int(body[i + 2:i + 4], 16)))
- i += 4
- else:
- out.append(_ESC.get(e, e))
- i += 2
- return ''.join(out)
-
-
-def lit(m, g):
- v = m.group(g)
- return None if v is None else unescape(v[1:-1])
-
-
-# ---- scanning -----------------------------------------------------------------------------
-
-Site = collections.namedtuple("Site", "rel line start end kind text ctx one n")
-# kind: T, F, P (plural), X (xaml). start/end: the span to replace in the original text.
-
-
-def source_files():
- for d, dirs, files in os.walk(MANAGED):
- dirs[:] = sorted(x for x in dirs if x not in ("bin", "obj"))
- for f in sorted(files):
- if f.endswith(".cs") or f.endswith(".axaml"):
- p = os.path.join(d, f)
- yield os.path.relpath(p, MANAGED).replace(os.sep, "/"), p
-
-
-def line_of(text, index):
- return text.count('\n', 0, index) + 1
-
-
-def scan_text(rel, text):
- """All Loc sites of one file, in source order, plus problems."""
- sites, problems = [], []
- if rel.endswith(".axaml"):
- b = blank_xml_comments(text)
- for m in RE_XAML.finditer(b):
- t = m.group('q') if m.group('q') is not None else m.group('t')
- t = html.unescape(t).replace("\\'", "'")
- sites.append(Site(rel, line_of(b, m.start()), m.start(), m.end(), "X", t, m.group('c'), None, None))
- return sites, problems
- b = blank_code(text)
- taken = []
- for m in RE_PLURAL.finditer(b):
- sites.append(Site(rel, line_of(b, m.start()), m.start(), m.end(), "P", lit(m, 't'), lit(m, 'c'),
- lit(m, 'one'), m.group('n').strip()))
- taken.append(m.start())
- for m in RE_PLURAL_NEW.finditer(b): # the migrated form, Loc.Plural("key", n) — for --verify
- depth, j = 1, m.end()
- while j < len(b) and depth:
- depth += {'(': 1, ')': -1}.get(b[j], 0)
- j += 1
- sites.append(Site(rel, line_of(b, m.start()), m.start(), j - 1, "P", lit(m, 't'), None, None,
- b[m.end():j - 1].strip()))
- taken.append(m.start())
- for m in RE_T.finditer(b):
- sites.append(Site(rel, line_of(b, m.start()), m.start(), m.end(), "T", lit(m, 't'), lit(m, 'c'), None, None))
- taken.append(m.start())
- rest = b[m.end():].lstrip()
- if not rest.startswith(')'):
- problems.append(f"{rel}:{line_of(b, m.start())}: Loc.T text is not the whole argument")
- for m in RE_F.finditer(b):
- sites.append(Site(rel, line_of(b, m.start()), m.start(), m.end(), "F", lit(m, 't'), None, None, None))
- taken.append(m.start())
- rest = b[m.end():].lstrip()
- if not (rest.startswith(',') or rest.startswith(')')):
- problems.append(f"{rel}:{line_of(b, m.start())}: Loc.F pattern is not the whole first argument")
- for m in RE_ANY.finditer(b):
- if m.start() not in taken:
- problems.append(f"{rel}:{line_of(b, m.start())}: Loc call not readable: {b[m.start():m.start() + 70]!r}")
- sites.sort(key=lambda s: s.start)
- return sites, problems
-
-
-def scan_tree(read=None):
- """Sites per file. `read(rel)` returns a file's text (for a git commit), else the working tree."""
- out, problems = collections.OrderedDict(), []
- if read is None:
- files = [(rel, open(p, encoding='utf-8').read()) for rel, p in source_files()]
- else:
- files = read()
- for rel, text in files:
- if rel in SKIP_FILES or rel.startswith(SKIP_PREFIXES):
- continue
- if "Loc." not in text and "app:T" not in text:
- continue
- s, p = scan_text(rel, text)
- problems += p
- if s:
- out[rel] = s
- return out, problems
-
-
-# ---- keys ---------------------------------------------------------------------------------
-
-def snake(name):
- s = re.sub(r'(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])', '_', name)
- return re.sub(r'[^a-z0-9]+', '_', s.lower()).strip('_')
-
-
-STEM_SUFFIXES = ("InstrumentCard", "DeviceBody", "MidiBody", "ViewModel", "Views", "View", "Window",
- "Service", "Card", "Kit", "Viz", "Graph", "Curve", "Scope")
-
-
-def strip_suffix(stem):
- for suf in STEM_SUFFIXES:
- if stem.endswith(suf) and len(stem) > len(suf):
- return stem[:-len(suf)]
- return stem
-
-
-AREA_OVERRIDES = {
- "Nota.App/MainWindow": "main", "Nota.App/App": "app", "Nota.App/MenuKit": "menu",
- "Nota.App/MacAppMenu": "menu.mac", "Nota.App/TextBoxMenu": "menu.text_box",
- "Nota.Presentation/ViewModels/MainWindowViewModel": "main",
- "Nota.App/DeviceCards/PluginCard": "device.plugin",
- "Nota.App/DeviceCards/SidechainSourcePicker": "device.sidechain",
- "Nota.App/DeviceCards/Midi/MidiCardHeader": "device.midi",
- "Nota.App/DeviceCards/Rack/MacroPanel": "device.rack.macros",
- "Nota.App/DeviceCards/Rack/RackKindProfile": "device.rack",
- "Nota.App/DeviceCards/Rack/RackCardView": "device.rack",
- "Nota.App/DeviceCards/Sampler/SamplerViews": "device.sampler",
- "Nota.App/DeviceCardKit": "device.card",
- "Nota.App/Remote/ConnectPhoneView": "remote.connect", "Nota.App/Remote/RemoteService": "remote",
- "Nota.Application/Palette/BuiltinDeviceCatalog": "palette.devices",
- "Nota.Application/Palette/CommandCatalog": "commands",
- "Nota.Application/Palette/ModularCatalog": "palette.modular",
- "Nota.Application/Palette/DeviceCategories": "palette.categories",
-}
-
-CONTROL_DEVICES = ("AutoFilter", "AutoShift", "BeatRepeat", "Ceiling", "Comp", "Consort", "Crush",
- "DynamicEq", "Eq8", "FluxReact", "Keys", "OperatorAlgo", "Pendulum", "Reverb",
- "Rhythm", "Shutter", "Synth", "Utility", "Vocoder")
-
-
-def area_of(rel):
- """Key prefix for a file: area[.sub-area from the partial-file suffix] (research R2)."""
- path = rel.rsplit('.', 1)[0] if rel.endswith(".cs") or rel.endswith(".axaml") else rel
- if path.endswith(".axaml"):
- path = path[:-6]
- d, _, fname = path.rpartition('/')
- parts = fname.split('.')
- stem, sub = parts[0], (parts[1] if len(parts) > 1 else None)
- base = f"{d}/{stem}"
- if base in AREA_OVERRIDES:
- area = AREA_OVERRIDES[base]
- elif d == "Nota.App/Controls":
- s = strip_suffix(stem)
- area = ("device." + snake(s)) if any(stem.startswith(c) for c in CONTROL_DEVICES) else "control." + snake(s)
- elif d.startswith("Nota.App/DeviceCards/Rack"):
- area = "device.rack"
- elif d.startswith("Nota.App/DeviceCards"):
- area = "device." + snake(strip_suffix(stem))
- elif d == "Nota.App" or d == "Nota.Presentation" or d == "Nota.Presentation/ViewModels":
- area = snake(strip_suffix(stem))
- elif d.startswith("Nota.Application/") or d.startswith("Nota.Infrastructure/"):
- area = snake(d.split('/')[1])
- rest = snake(strip_suffix(stem))
- if rest.startswith(area + "_"): # Midi/MidiTransforms -> midi.transforms
- rest = rest[len(area) + 1:]
- if rest != area:
- area += "." + rest
- else:
- raise SystemExit(f"loc-migrate: no area for {rel} — extend area_of()")
- if sub:
- sub = snake(sub)
- if not area.endswith("." + sub) and area.split('.')[-1] != sub:
- area += "." + sub
- return area
-
-
-def slug(text, limit):
- words = re.findall(r"[A-Za-z0-9]+", re.sub(r"\{\d+[^}]*\}", " ", text.replace("’", "").replace("'", "")))
- words = [w.lower() for w in words][:5]
- s = "_".join(words) or "pattern" # "{0} · {1}": punctuation only
- s = s[:limit].rstrip('_') or "pattern"
- if re.search(r"[A-Z]{2}", text) and not re.search(r"[a-z]", text):
- s += "_caps" # "TRACK" beside "Track"
- return s
-
-
-def ident(site):
- """What a key stands for: English text (other form), singular form, context, kind."""
- return (site.text, site.one if site.kind == "P" else None, site.ctx or "", "P" if site.kind == "P" else "T")
-
-
-def old_key(text, ctx):
- return text if not ctx else text + "|" + ctx
-
-
-def top_area(area):
- """The group a text is shared within: the first segment, or device.<name> for devices."""
- parts = area.split('.')
- return '.'.join(parts[:2]) if parts[0] == "device" and len(parts) > 1 else parts[0]
-
-
-def groups_of(tree):
- """ident -> {top area -> {full areas}} over the whole tree."""
- g = collections.defaultdict(lambda: collections.defaultdict(set))
- for rel, sites in tree.items():
- a = area_of(rel)
- for s in sites:
- g[ident(s)][top_area(a)].add(a)
- return g
-
-
-def slot(site, rel, groups):
- """What one key stands for: a text (ident) in one group — "common" when three or more
- groups use it (research R2), else the group of the file it is used in."""
- idt = ident(site)
- return (idt, "common" if len(groups[idt]) >= 3 else top_area(area_of(rel)))
-
-
-def build_map(tree, previous):
- """slot -> key. `previous` (from keymap.tsv) wins for slots it knows."""
- groups = groups_of(tree)
- slots = {}
- for rel, sites in tree.items():
- for s in sites:
- sl = slot(s, rel, groups)
- idt, grp = sl
- slots[sl] = "common" if grp == "common" else (
- next(iter(groups[idt][grp])) if len(groups[idt][grp]) == 1 else grp)
- out, taken = {}, set()
- for sl, key in previous.items():
- if sl in slots:
- out[sl] = key
- taken.add(key)
- for sl in sorted(slots, key=lambda x: (bool(re.search(r"\{\d", x[0][0])), slots[x], x)):
- if sl in out:
- continue
- (text, one, ctx, kind), prefix = sl[0], slots[sl]
- base = slug(text, MAX_KEY - len(prefix) - 9 - (len(ctx) + 1 if ctx else 0))
- if ctx:
- base += "_" + snake(ctx)
- key, n = f"{prefix}.{base}", 2
- if key in taken and re.search(r"\{\d", text):
- key = f"{prefix}.{base}_n" # "Audio" beside "Audio {0}"
- while key in taken:
- key, n = f"{prefix}.{base}_{n}", n + 1
- out[sl] = key
- taken.add(key)
- return out
-
-
-def read_keymap():
- prev = {}
- if not os.path.exists(KEYMAP):
- return prev
- with open(KEYMAP, encoding='utf-8') as f:
- next(f, None)
- for line in f:
- p = line.rstrip('\n').split('\t')
- if len(p) < 7:
- continue
- key, group, kind, ctx, text, one = p[0], p[1], p[2], p[3], json.loads(p[4]), (json.loads(p[5]) if p[5] else None)
- prev[((text, one, ctx, kind), group)] = key
- return prev
-
-
-def write_keymap(m, tree):
- groups = groups_of(tree)
- files = collections.defaultdict(set)
- for rel, sites in tree.items():
- for s in sites:
- files[slot(s, rel, groups)].add(rel)
- with open(KEYMAP, 'w', encoding='utf-8') as f:
- f.write("key\tgroup\tkind\tcontext\ttext\tone\tfiles\n")
- for sl, key in sorted(m.items(), key=lambda kv: kv[1]):
- (text, one, ctx, kind), group = sl
- f.write(f"{key}\t{group}\t{kind}\t{ctx}\t{json.dumps(text, ensure_ascii=False)}\t"
- f"{json.dumps(one, ensure_ascii=False) if one is not None else ''}\t{','.join(sorted(files[sl]))}\n")
-
-
-def check_map(m):
- bad, seen = [], {}
- for idt, key in m.items():
- if not KEY_RE.match(key) or len(key) > MAX_KEY:
- bad.append(f"bad key {key!r}")
- if key in seen:
- bad.append(f"key {key!r} used for two texts: {seen[key][0][0]!r} and {idt[0][0]!r}")
- seen[key] = idt
- return bad
-
-
-# ---- writing ------------------------------------------------------------------------------
-
-def dump_table(header, strings):
- """A language file: header fields, then strings one per line, keys in order given."""
- out = ["{"]
- for k, v in header.items():
- out.append(f" {json.dumps(k)}: {json.dumps(v, ensure_ascii=False)},")
- out.append(' "strings": {')
- items = list(strings.items())
- for i, (k, v) in enumerate(items):
- comma = "," if i + 1 < len(items) else ""
- if isinstance(v, dict):
- inner = ", ".join(f"{json.dumps(a)}: {json.dumps(b, ensure_ascii=False)}" for a, b in v.items())
- out.append(f" {json.dumps(k)}: {{ {inner} }}{comma}")
- else:
- out.append(f" {json.dumps(k)}: {json.dumps(v, ensure_ascii=False)}{comma}")
- out.append(" }")
- out.append("}")
- return "\n".join(out) + "\n"
-
-
-def en_strings(m):
- strings = {}
- for (idt, _), key in sorted(m.items(), key=lambda kv: kv[1]):
- text, one, ctx, kind = idt
- strings[key] = {"one": one, "other": text} if kind == "P" else text
- return strings
-
-
-def fr_strings(m, fr_old):
- strings, used = {}, set()
- for (idt, _), key in sorted(m.items(), key=lambda kv: kv[1]):
- text, one, ctx, kind = idt
- ok = old_key(text, ctx)
- if ok in fr_old:
- strings[key] = fr_old[ok]
- used.add(ok)
- orphans = sorted(set(fr_old) - used)
- return strings, orphans
-
-
-def rewrite(rel, text, sites, m, groups):
- out, pos = [], 0
- for s in sites:
- key = m[slot(s, rel, groups)]
- out.append(text[pos:s.start])
- if s.kind == "X":
- out.append("{app:T '" + key + "'}")
- elif s.kind == "P":
- out.append(f'Loc.Plural("{key}", {s.n}')
- else:
- out.append(f'Loc.{s.kind}("{key}"')
- pos = s.end
- out.append(text[pos:])
- return "".join(out)
-
-
-# ---- commands -----------------------------------------------------------------------------
-
-def cmd_plan():
- tree, problems = scan_tree()
- if problems:
- print("\n".join(problems), file=sys.stderr)
- return 1
- m = build_map(tree, read_keymap())
- bad = check_map(m)
- write_keymap(m, tree)
- n_sites = sum(len(s) for s in tree.values())
- commons = sum(1 for k in m.values() if k.startswith("common."))
- print(f"{n_sites} call sites in {len(tree)} files -> {len(m)} keys ({commons} common.*); keymap.tsv written")
- if bad:
- print("\n".join(bad), file=sys.stderr)
- return 1
- return 0
-
-
-def cmd_apply():
- tree, problems = scan_tree()
- if problems:
- print("\n".join(problems), file=sys.stderr)
- return 1
- if not os.path.exists(KEYMAP):
- print("run --plan first", file=sys.stderr)
- return 1
- m = build_map(tree, read_keymap())
- bad = check_map(m)
- if bad:
- print("\n".join(bad), file=sys.stderr)
- return 1
- fr = json.load(open(FR_PATH, encoding='utf-8'))
- if fr.get("formatVersion") != 1:
- print("fr.json is not format 1 — already migrated?", file=sys.stderr)
- return 1
- with open(EN_PATH, 'w', encoding='utf-8') as f:
- f.write(dump_table({"formatVersion": 2, "code": "en", "name": "English", "plural": "one_is_1",
- "notes": "The English reference: every interface text of Nota by key (spec 077). "
- "Change a text here; a new meaning or new placeholders get a new key."},
- en_strings(m)))
- frs, orphans = fr_strings(m, fr["strings"])
- notes = fr.get("notes", "")
- notes = re.sub(r" A key is the English text.*?French counts 0 and 1 as one\.",
- " Keys are the English reference's keys (Nota.Application/Localization/en.json); counted texts "
- "take {\"one\", \"other\"} and French counts 0 and 1 as one.", notes)
- with open(FR_PATH, 'w', encoding='utf-8') as f:
- f.write(dump_table({"formatVersion": 2, "code": "fr", "name": fr.get("name", "Français"),
- "plural": "one_is_0_1", "notes": notes}, frs))
- groups = groups_of(tree)
- for rel, sites in tree.items():
- p = os.path.join(MANAGED, rel)
- text = open(p, encoding='utf-8').read()
- new = rewrite(rel, text, sites, m, groups)
- if new != text:
- with open(p, 'w', encoding='utf-8') as f:
- f.write(new)
- print(f"en.json: {len(m)} keys; fr.json: {len(frs)} entries, {len(orphans)} orphans dropped; "
- f"{sum(len(s) for s in tree.values())} call sites rewritten in {len(tree)} files")
- for o in orphans:
- print(" orphan:", o)
- return 0
-
-
-def git_files(commit):
- names = subprocess.run(["git", "-C", ROOT, "ls-tree", "-r", "--name-only", commit, "src/managed"],
- capture_output=True, text=True, check=True).stdout.split()
- for n in names:
- if not (n.endswith(".cs") or n.endswith(".axaml")) or "/bin/" in n or "/obj/" in n:
- continue
- text = subprocess.run(["git", "-C", ROOT, "show", f"{commit}:{n}"], capture_output=True, check=True).stdout
- yield n[len("src/managed/"):], text.decode('utf-8')
-
-
-def cmd_verify(commit):
- old_tree, p1 = scan_tree(lambda: list(git_files(commit)))
- new_tree, p2 = scan_tree()
- fr_old = json.loads(subprocess.run(["git", "-C", ROOT, "show", f"{commit}:src/managed/Nota.App/Languages/fr.json"],
- capture_output=True, check=True).stdout)["strings"]
- en = json.load(open(EN_PATH, encoding='utf-8'))["strings"]
- fr = json.load(open(FR_PATH, encoding='utf-8'))["strings"]
- diffs = list(p1) + list(p2)
- if set(old_tree) != set(new_tree):
- diffs.append(f"files differ: {sorted(set(old_tree) ^ set(new_tree))}")
- for rel in old_tree:
- olds, news = old_tree[rel], new_tree.get(rel, [])
- if len(olds) != len(news):
- diffs.append(f"{rel}: {len(olds)} sites before, {len(news)} now")
- continue
- for o, n in zip(olds, news):
- key = n.text # the literal now is the key
- where = f"{rel}:{n.line}"
- if (o.kind == "P") != (n.kind == "P"):
- diffs.append(f"{where}: plural changed")
- continue
- e = en.get(key)
- want = {"one": o.one, "other": o.text} if o.kind == "P" else o.text
- if e != want:
- diffs.append(f"{where}: en[{key}] = {e!r}, was {want!r}")
- ok = old_key(o.text, o.ctx)
- if ok in fr_old and fr.get(key) != fr_old[ok]:
- diffs.append(f"{where}: fr[{key}] = {fr.get(key)!r}, was {fr_old[ok]!r}")
- if ok not in fr_old and key in fr:
- diffs.append(f"{where}: fr[{key}] appeared")
- if o.kind == "P" and n.n != o.n:
- diffs.append(f"{where}: count expression {n.n!r}, was {o.n!r}")
- n = sum(len(s) for s in old_tree.values())
- if diffs:
- print("\n".join(diffs[:200]), file=sys.stderr)
- print(f"{len(diffs)} differences over {n} call sites", file=sys.stderr)
- return 1
- print(f"verified {n} call sites in {len(old_tree)} files: English and French unchanged")
- return 0
-
-
-def main():
- ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
- g = ap.add_mutually_exclusive_group(required=True)
- g.add_argument("--plan", action="store_true")
- g.add_argument("--apply", action="store_true")
- g.add_argument("--verify", metavar="COMMIT")
- a = ap.parse_args()
- if a.plan:
- return cmd_plan()
- if a.apply:
- return cmd_apply()
- return cmd_verify(a.verify)
-
-
-if __name__ == "__main__":
- sys.exit(main())
diff --git a/specs/077-key-based-localization/contracts/index.md b/specs/077-key-based-localization/contracts/index.md
index 063dbd61..d3d0a28f 100644
--- a/specs/077-key-based-localization/contracts/index.md
+++ b/specs/077-key-based-localization/contracts/index.md
@@ -1,7 +1,8 @@
# Contract: `index.json` (nota-translations)
-Generated by `publish.yml` on every push to `main`; never edited by hand. The app reads
-`<base>/main/index.json`, `<base>` = `https://raw.githubusercontent.com/nota-daw/nota-translations`
+Generated by `publish.yml` on the `published` branch after every push to `main` (main stays under
+pull requests with no bypass; `published` holds generated files only); never edited by hand. The
+app reads `<base>/published/index.json`, `<base>` = `https://raw.githubusercontent.com/nota-daw/nota-translations`
(overridable with `NOTA_LANGUAGES_URL`).
```json
diff --git a/specs/077-key-based-localization/contracts/language-row.md b/specs/077-key-based-localization/contracts/language-row.md
index ef806015..b59e70c4 100644
--- a/specs/077-key-based-localization/contracts/language-row.md
+++ b/specs/077-key-based-localization/contracts/language-row.md
@@ -21,7 +21,9 @@ Order: English, installed by code, a separator, available by code.
| Stored language newer in the index | `Update available` + **Update** (downloads, then restart note if it is the running one) |
| Selected item is an installed non-English language | **Remove** (a running one keeps working until restart, then English) |
| Always | **Load file…** (opens a JSON file; problems listed below the row) |
-| Index unreachable | `More languages are available online` (muted) |
+| Index unreachable or unreadable | `Couldn't get the language list — <reason>` (muted); with checks off **Show available languages** stays to retry |
+| A download in progress | the list and **Load file…** are disabled until it ends |
+| A running language updated this run | the restart note, as for a new choice |
| `CheckForUpdates` off and index not fetched this run | **Show available languages** |
| Stored language missing, checks on | `Downloading Français…`, then `Français is ready` + **Restart** (story 5) |
| Stored language missing, checks off or offline | `Français will be downloaded when Nota is online` / **Download Français** |
diff --git a/specs/077-key-based-localization/quickstart.md b/specs/077-key-based-localization/quickstart.md
index e149bf10..4e835f7a 100644
--- a/specs/077-key-based-localization/quickstart.md
+++ b/specs/077-key-based-localization/quickstart.md
@@ -24,7 +24,7 @@ Baseline (pre-migration) commit: `7b58fe881bc6503e0ff7508dc1bd4c180dc909bd` (`or
## PR 2 — nota-translations (story 2, SC-004)
1. `gh workflow run publish.yml --repo nota-daw/nota-translations` → `reference/develop.json`
- and `index.json` appear on `main`, committed by the bot.
+ and `index.json` appear on the `published` branch, committed by the bot.
2. Open a PR that breaks a placeholder in `languages/fr.json` → `check.yml` fails naming the
key, in < 5 min; fix it → passes and reports French coverage.
3. Run `tools/validate.py --fixtures` and the app smoke test's fixture parity check → same
@@ -33,7 +33,7 @@ Baseline (pre-migration) commit: `7b58fe881bc6503e0ff7508dc1bd4c180dc909bd` (`or
## PR 3 — downloading (stories 3–5, SC-005…008)
Serve a test copy: `python3 -m http.server -d <nota-translations checkout>` and
-`export NOTA_LANGUAGES_URL=http://127.0.0.1:8000` (layout `<base>/main/index.json`,
+`export NOTA_LANGUAGES_URL=http://127.0.0.1:8000` (layout `<base>/published/index.json`,
`<base>/<commit>/<path>` reproduced by the smoke fixture builder).
1. Clean data dir, open Preferences → Language: English + Français · 100% (available).
diff --git a/specs/077-key-based-localization/research.md b/specs/077-key-based-localization/research.md
index c18ab128..1895239c 100644
--- a/specs/077-key-based-localization/research.md
+++ b/specs/077-key-based-localization/research.md
@@ -134,12 +134,14 @@ per-code rules in the app (today) — breaks "add a language without an app rele
README.md translator guide
LICENSE AGPL-3.0-only text
languages/<code>.json one file per language (formatVersion 2), never English
-reference/<ver>.json en.json of Nota release <ver>; reference/develop.json = develop head
-index.json generated — what the app reads
tools/validate.py the checks (stdlib Python)
tools/sync_references.py
.github/workflows/check.yml PRs: validate every language against every reference
-.github/workflows/publish.yml push to main / schedule / dispatch: sync references, regenerate index.json, commit
+.github/workflows/publish.yml push to main / schedule / dispatch: sync references, regenerate index.json, commit both to `published`
+
+(branch published)
+reference/<ver>.json en.json of Nota release <ver>; reference/develop.json = develop head
+index.json generated — what the app reads
```
- **References are pulled, not pushed**: `publish.yml` lists `nota` tags `v*` and the
@@ -147,8 +149,9 @@ tools/sync_references.py
at each one lacking a reference (daily schedule + `workflow_dispatch`). No cross-repository
secret. The nota release workflow is unchanged; the `release` skill gains a step "run
publish in nota-translations" for an immediate sync.
-- `publish.yml` commits to `main` as `github-actions[bot]`: the ruleset `main: PR, squash`
- gets the GitHub Actions integration as a bypass actor.
+- `publish.yml` commits generated files to a separate `published` branch as
+ `github-actions[bot]`; `main` keeps its ruleset (`main: PR, squash`) with no bypass for
+ automation (decided 2026-11-04 instead of a GitHub Actions bypass).
- `develop.json` lets translators work on keys before they ship; the app uses it only in dev
builds (version `0.0.0-dev`).
@@ -156,7 +159,7 @@ tools/sync_references.py
**Decision**: `LanguageCatalog` (Infrastructure, next to `ModelStore`):
-- Reads `https://raw.githubusercontent.com/nota-daw/nota-translations/main/index.json`
+- Reads `https://raw.githubusercontent.com/nota-daw/nota-translations/published/index.json`
(`NOTA_LANGUAGES_URL` overrides the base, for tests and staging).
- Each language entry pins `commit`, `path`, `size`, `sha256`; the file URL is
`…/nota-translations/<commit>/<path>`, so the hash always matches what is fetched (no race
diff --git a/specs/077-key-based-localization/tasks.md b/specs/077-key-based-localization/tasks.md
index 22645ac6..7146b590 100644
--- a/specs/077-key-based-localization/tasks.md
+++ b/specs/077-key-based-localization/tasks.md
@@ -95,18 +95,18 @@ R12), and the constitution makes it the PR gate.
**Independent test**: quickstart § PR 2.
-- [ ] T025 [P] [US2] Add `nota-translations/LICENSE` (full AGPL-3.0 text, same as nota's `LICENSE`)
-- [ ] T026 [P] [US2] Write `nota-translations/README.md`: what the repo is, file shape (link to a copy of the contract in `nota-translations/FORMAT.md`), keys and the English reference (`reference/<version>.json`, `develop.json`), plurals and rule ids, placeholders, coverage, how to open a PR, how to preview a file in Nota (Load file…), licence
-- [ ] T027 [P] [US2] Copy `specs/077-key-based-localization/contracts/language-file.md` and `contracts/index.md` into `nota-translations/FORMAT.md` (translator-facing wording, same rules)
-- [ ] T028 [US2] Write `nota-translations/tools/validate.py` (stdlib; SPDX header): implements `contracts/language-file.md` exactly as `TranslationTable` (T003–T005): parse, key regex, plural rule ids, shape/placeholder checks against each `reference/*.json`, unknown key = error when in no reference / warning when only in older ones, coverage per key-set hash; `--fixtures tools/fixtures` mode compares against `verdicts.json`; exit non-zero with `languages/<code>.json: <key> — <problem>` lines
-- [ ] T029 [P] [US2] Copy the fixtures and `verdicts.json` from `tests/Nota.SmokeTest/Fixtures/Languages/` (T009) into `nota-translations/tools/fixtures/`
-- [ ] T030 [US2] Write `nota-translations/tools/sync_references.py` (stdlib): list `nota-daw/nota` tags `v*` and the `develop` head via the public GitHub API, fetch `src/managed/Nota.Application/Localization/en.json` at each tag lacking `reference/<version>.json` (skip tags whose file is missing or format < 2), always refresh `reference/develop.json`
-- [ ] T031 [US2] Add index generation to `nota-translations/tools/validate.py` (`--write-index`): `index.json` per `contracts/index.md` — `formatVersion: 1`, `generated`, `references` (version → key-set hash), per valid language `code`, `name`, `version` (previous index version + 1 when the file's sha256 changed, else kept), `commit` (the `HEAD` being indexed), `path`, `size`, `sha256`, `coverage` per hash
-- [ ] T032 [US2] Add `nota-translations/.github/workflows/check.yml`: on pull_request → `python3 tools/validate.py --fixtures tools/fixtures` and `python3 tools/validate.py languages/*.json`; job name `check`
-- [ ] T033 [US2] Add `nota-translations/.github/workflows/publish.yml`: on push to `main`, daily schedule, `workflow_dispatch` → sync references, validate, write index, commit `reference/` + `index.json` as `github-actions[bot]` only if changed; the commit's own SHA is not the indexed one, so index `commit` = the content commit before the bot commit (document in the workflow)
-- [ ] T034 [US2] Move French: `git mv`-equivalent import of `src/managed/Nota.App/Languages/fr.json` (v2, from PR 1) into `nota-translations/languages/fr.json`, with the commit message crediting its translators from `git log --format='%an' -- src/managed/Nota.App/Languages/fr.json` in nota (FR-012)
-- [ ] T035 [US2] Repository settings via `gh api`: add the GitHub Actions integration (id 15368) as a bypass actor to ruleset `main: PR, squash` (id 26514643); after the first green `check` run, add `check` as a required status check
-- [ ] T036 [US2] Push the initial content (README, LICENSE, FORMAT, tools, workflows, `languages/fr.json`) as the first commit on `main` (sets the default branch), run `gh workflow run publish.yml`, confirm `reference/develop.json` and `index.json` land; then open a test PR breaking a placeholder → `check` fails naming the key; close it
+- [X] T025 [P] [US2] Add `nota-translations/LICENSE` (full AGPL-3.0 text, same as nota's `LICENSE`)
+- [X] T026 [P] [US2] Write `nota-translations/README.md`: what the repo is, file shape (link to a copy of the contract in `nota-translations/FORMAT.md`), keys and the English reference (`reference/<version>.json`, `develop.json`), plurals and rule ids, placeholders, coverage, how to open a PR, how to preview a file in Nota (Load file…), licence
+- [X] T027 [P] [US2] Copy `specs/077-key-based-localization/contracts/language-file.md` and `contracts/index.md` into `nota-translations/FORMAT.md` (translator-facing wording, same rules)
+- [X] T028 [US2] Write `nota-translations/tools/validate.py` (stdlib; SPDX header): implements `contracts/language-file.md` exactly as `TranslationTable` (T003–T005): parse, key regex, plural rule ids, shape/placeholder checks against each `reference/*.json`, unknown key = error when in no reference / warning when only in older ones, coverage per key-set hash; `--fixtures tools/fixtures` mode compares against `verdicts.json`; exit non-zero with `languages/<code>.json: <key> — <problem>` lines
+- [X] T029 [P] [US2] Copy the fixtures and `verdicts.json` from `tests/Nota.SmokeTest/Fixtures/Languages/` (T009) into `nota-translations/tools/fixtures/`
+- [X] T030 [US2] Write `nota-translations/tools/sync_references.py` (stdlib): list `nota-daw/nota` tags `v*` and the `develop` head via the public GitHub API, fetch `src/managed/Nota.Application/Localization/en.json` at each tag lacking `reference/<version>.json` (skip tags whose file is missing or format < 2), always refresh `reference/develop.json`
+- [X] T031 [US2] Add index generation to `nota-translations/tools/validate.py` (`--write-index`): `index.json` per `contracts/index.md` — `formatVersion: 1`, `generated`, `references` (version → key-set hash), per valid language `code`, `name`, `version` (previous index version + 1 when the file's sha256 changed, else kept), `commit` (the `HEAD` being indexed), `path`, `size`, `sha256`, `coverage` per hash
+- [X] T032 [US2] Add `nota-translations/.github/workflows/check.yml`: on pull_request → `python3 tools/validate.py --fixtures tools/fixtures` and `python3 tools/validate.py languages/*.json`; job name `check`
+- [X] T033 [US2] Add `nota-translations/.github/workflows/publish.yml`: on push to `main`, daily schedule, `workflow_dispatch` → sync references, validate, write index, commit `reference/` + `index.json` to the `published` branch as `github-actions[bot]` only if changed; index `commit` = main's HEAD, which holds the language files
+- [X] T034 [US2] Move French: `git mv`-equivalent import of `src/managed/Nota.App/Languages/fr.json` (v2, from PR 1) into `nota-translations/languages/fr.json`, with the commit message crediting its translators from `git log --format='%an' -- src/managed/Nota.App/Languages/fr.json` in nota (FR-012)
+- [X] T035 [US2] Repository settings: after the first green `check` run, add `check` as a required status check on ruleset `main: PR, squash` (id 26514643); generated files go to the `published` branch, so no bypass is added
+- [X] T036 [US2] Push the initial content (README, LICENSE, FORMAT, tools, workflows, `languages/fr.json`) as the first commit on `main` (sets the default branch), run `gh workflow run publish.yml`, confirm `reference/develop.json` and `index.json` land; then open a test PR breaking a placeholder → `check` fails naming the key; close it
**Checkpoint (PR 2)**: quickstart § PR 2 passes.
@@ -118,15 +118,15 @@ R12), and the constitution makes it the PR gate.
**Independent test**: quickstart § PR 3 steps 1–4, 7–8.
-- [ ] T037 [P] [US3] Create `src/managed/Nota.Infrastructure/Languages/InstalledLanguages.cs`: root `<data>/languages` (from `NotaPaths`); per code `<code>.json` + `<code>.meta.json` `{ "source": "repository" | "local", "path"?, "version"?, "commit"?, "sha256"?, "installed" }`; `List()`, `Load(code)` (repository → file, local → stored path), `InstallFrom(stagingFile, meta)` with atomic move, `Remove(code)`, cleanup of leftover `.staging-<code>.json` on start
-- [ ] T038 [US3] Create `src/managed/Nota.Infrastructure/Languages/LanguageCatalog.cs`: fetch `<base>/main/index.json` (`<base>` = `https://raw.githubusercontent.com/nota-daw/nota-translations`, `NOTA_LANGUAGES_URL` overrides) once per run (cached); ignore an index with a higher `formatVersion` major ("update Nota to see more languages"); fit by own key-set hash, else the newest reference with version ≤ the app's (contracts/index.md § App behaviour); `DownloadAsync(entry)` via `RegistryClient.DownloadAsync(<base>/<commit>/<path>, size, sha256, staging, …)`, then parse + validate before `InstalledLanguages.InstallFrom`; any failure leaves the installed copy
-- [ ] T039 [US3] Register `LanguageCatalog` and `InstalledLanguages` in the app's service setup (where `ModelStore` is registered) and expose `UpdateAvailable(code)` comparing installed `version` with the index
-- [ ] T040 [US3] Update `src/managed/Nota.App/Languages/NotaLanguages.cs`: offered languages = embedded English + `InstalledLanguages.List()`; `Find(code)` loads installed files through `TranslationTable.Parse` + `ValidateAgainst(english)` (problems logged); no network on this path
-- [ ] T041 [US3] Rebuild `src/managed/Nota.App/PreferencesWindow.Language.cs` per `contracts/language-row.md`: combo items English / installed (`· 97%` muted, or `· local file`) / separator / available (`· 82%` + download glyph); picking an available one downloads with inline `Downloading…` progress, then the existing restart note; failure `Couldn't download <Name> — <reason>` and the combo returns to the running language; `Update available` + **Update**; **Remove**; `More languages are available online` when the index is unreachable; follows `DESIGN.md` (Studio) — every new text via `Loc.T` with new keys in `en.json`
-- [ ] T042 [US3] Network policy (research R10) in `PreferencesWindow.Language.cs` and the launch path: fetch the index when the row is shown, and at launch with the daily update check only when `Settings.CheckForUpdates` is on; when off, show **Show available languages** (fetch on click) and never request on Nota's own initiative
-- [ ] T043 [US3] Remove `src/managed/Nota.App/Languages/fr.json` and its embedding: `src/managed/Nota.App/Nota.App.csproj` embeds no language file (remove the `Languages\*.json` item and its comment at line ~56)
-- [ ] T044 [US3] Smoke: create `tests/Nota.SmokeTest/LanguageCatalogTests.cs` with an in-process `HttpMessageHandler` serving a fixture index + files (`tests/Nota.SmokeTest/Fixtures/Languages/index/`): list + fit + coverage, install, checksum mismatch keeps the old copy, higher index `formatVersion` ignored, offline → installed only, update offered when `version` grows, remove, `CheckForUpdates` off → zero requests at start; wire into `tests/Nota.SmokeTest/Program.cs`
-- [ ] T045 [US3] Smoke: in `DesignTokenCheck.RunLocalization` drop the embedded-French coverage checks (French is validated in nota-translations) and add "the app embeds only `en.json`" (SC-008); switch `tests/Nota.SmokeTest/LanguageProjectTests.cs` from `fr.json` to the `xx.json` fixture
+- [X] T037 [P] [US3] Create `src/managed/Nota.Infrastructure/Languages/InstalledLanguages.cs`: root `<data>/languages` (from `NotaPaths`); per code `<code>.json` + `<code>.meta.json` `{ "source": "repository" | "local", "path"?, "version"?, "commit"?, "sha256"?, "installed" }`; `List()`, `Load(code)` (repository → file, local → stored path), `InstallFrom(stagingFile, meta)` with atomic move, `Remove(code)`, cleanup of leftover `.staging-<code>.json` on start
+- [X] T038 [US3] Create `src/managed/Nota.Infrastructure/Languages/LanguageCatalog.cs`: fetch `<base>/published/index.json` (`<base>` = `https://raw.githubusercontent.com/nota-daw/nota-translations`, `NOTA_LANGUAGES_URL` overrides) once per run (cached); ignore an index with a higher `formatVersion` major ("update Nota to see more languages"); fit by own key-set hash, else the newest reference with version ≤ the app's (contracts/index.md § App behaviour); `DownloadAsync(entry)` via `RegistryClient.DownloadAsync(<base>/<commit>/<path>, size, sha256, staging, …)`, then parse + validate before `InstalledLanguages.InstallFrom`; any failure leaves the installed copy
+- [X] T039 [US3] Register `LanguageCatalog` and `InstalledLanguages` in the app's service setup (where `ModelStore` is registered) and expose `UpdateAvailable(code)` comparing installed `version` with the index
+- [X] T040 [US3] Update `src/managed/Nota.App/Languages/NotaLanguages.cs`: offered languages = embedded English + `InstalledLanguages.List()`; `Find(code)` loads installed files through `TranslationTable.Parse` + `ValidateAgainst(english)` (problems logged); no network on this path
+- [X] T041 [US3] Rebuild `src/managed/Nota.App/PreferencesWindow.Language.cs` per `contracts/language-row.md`: combo items English / installed (`· 97%` muted, or `· local file`) / separator / available (`· 82%` + download glyph); picking an available one downloads with inline `Downloading…` progress, then the existing restart note; failure `Couldn't download <Name> — <reason>` and the combo returns to the running language; `Update available` + **Update**; **Remove**; `More languages are available online` when the index is unreachable; follows `DESIGN.md` (Studio) — every new text via `Loc.T` with new keys in `en.json`
+- [X] T042 [US3] Network policy (research R10) in `PreferencesWindow.Language.cs` and the launch path: fetch the index when the row is shown, and at launch with the daily update check only when `Settings.CheckForUpdates` is on; when off, show **Show available languages** (fetch on click) and never request on Nota's own initiative
+- [X] T043 [US3] Remove `src/managed/Nota.App/Languages/fr.json` and its embedding: `src/managed/Nota.App/Nota.App.csproj` embeds no language file (remove the `Languages\*.json` item and its comment at line ~56)
+- [X] T044 [US3] Smoke: create `tests/Nota.SmokeTest/LanguageCatalogTests.cs` with an in-process `HttpMessageHandler` serving a fixture index + files (`tests/Nota.SmokeTest/Fixtures/Languages/index/`): list + fit + coverage, install, checksum mismatch keeps the old copy, higher index `formatVersion` ignored, offline → installed only, update offered when `version` grows, remove, `CheckForUpdates` off → zero requests at start; wire into `tests/Nota.SmokeTest/Program.cs`
+- [X] T045 [US3] Smoke: in `DesignTokenCheck.RunLocalization` drop the embedded-French coverage checks (French is validated in nota-translations) and add "the app embeds only `en.json`" (SC-008); switch `tests/Nota.SmokeTest/LanguageProjectTests.cs` from `fr.json` to the `xx.json` fixture
**Checkpoint**: quickstart § PR 3 steps 1–4, 7–8 pass.
@@ -140,9 +140,9 @@ R12), and the constitution makes it the PR gate.
*P1 but placed after US3: it is built on the catalog and installed store from US3.*
-- [ ] T046 [US5] In `src/managed/Nota.App/App.axaml.cs` after the main window is shown: if `Settings.Language` ≠ `en`, has no valid installed file and `CheckForUpdates` is on, download it in the background through `LanguageCatalog` (start-up never waits); on success raise a "language ready" state shared with the Language row
-- [ ] T047 [US5] Show the "<Name> is ready" + **Restart** notice once per run in the status bar in `src/managed/Nota.App/MainWindow.Updates.cs` (same pattern as the app update notice), and in the Language row; offline / checks off → row text `<Name> will be downloaded when Nota is online` or **Download <Name>** (contracts/language-row.md)
-- [ ] T048 [US5] Smoke in `tests/Nota.SmokeTest/LanguageCatalogTests.cs`: stored `fr`, empty `languages/` → English this run, background install, ready state set; handler offline → English, stored choice kept, no install
+- [X] T046 [US5] In `src/managed/Nota.App/App.axaml.cs` after the main window is shown: if `Settings.Language` ≠ `en`, has no valid installed file and `CheckForUpdates` is on, download it in the background through `LanguageCatalog` (start-up never waits); on success raise a "language ready" state shared with the Language row
+- [X] T047 [US5] Show the "<Name> is ready" + **Restart** notice once per run in the status bar in `src/managed/Nota.App/MainWindow.Updates.cs` (same pattern as the app update notice), and in the Language row; offline / checks off → row text `<Name> will be downloaded when Nota is online` or **Download <Name>** (contracts/language-row.md)
+- [X] T048 [US5] Smoke in `tests/Nota.SmokeTest/LanguageCatalogTests.cs`: stored `fr`, empty `languages/` → English this run, background install, ready state set; handler offline → English, stored choice kept, no install
---
@@ -152,27 +152,27 @@ R12), and the constitution makes it the PR gate.
**Independent test**: quickstart § PR 3 step 6.
-- [ ] T049 [US4] Add **Load file…** to `src/managed/Nota.App/PreferencesWindow.Language.cs`: file picker for `.json`, parse + validate against English, store `source: local` + path through `InstalledLanguages`, select it, restart note; list up to 10 `key — problem` lines then `…and N more (see the log)`; a local language is never replaced by a download
-- [ ] T050 [US4] `NOTA_UI_LANGUAGE` accepts a path to a language file as well as a code (this run only, never saved) in `App.axaml.cs` `InstallLanguage`; update its doc comment
-- [ ] T051 [US4] Smoke in `tests/Nota.SmokeTest/LanguageCatalogTests.cs`: local `xx-broken.json` → loads, valid entries translated, broken ones English, problems match `verdicts.json`; missing local path at start → English + problem
+- [X] T049 [US4] Add **Load file…** to `src/managed/Nota.App/PreferencesWindow.Language.cs`: file picker for `.json`, parse + validate against English, store `source: local` + path through `InstalledLanguages`, select it, restart note; list up to 10 `key — problem` lines then `…and N more (see the log)`; a local language is never replaced by a download
+- [X] T050 [US4] `NOTA_UI_LANGUAGE` accepts a path to a language file as well as a code (this run only, never saved) in `App.axaml.cs` `InstallLanguage`; update its doc comment
+- [X] T051 [US4] Smoke in `tests/Nota.SmokeTest/LanguageCatalogTests.cs`: local `xx-broken.json` → loads, valid entries translated, broken ones English, problems match `verdicts.json`; missing local path at start → English + problem
---
## Phase 8: Polish & Cross-Cutting
-- [ ] T052 Delete `scripts/loc-migrate.py` and the `keymap.tsv` ignore line in `.gitignore` (research R4)
-- [ ] T053 [P] Finalise `CONTRIBUTING.md` § Translating Nota: translations live in `nota-daw/nota-translations`; adding a text in the app = `en.json` only
-- [ ] T054 [P] Add the "sync references" step (`gh workflow run publish.yml --repo nota-daw/nota-translations` after the tag build) to `.claude/skills/release/SKILL.md`, then run `scripts/sync-agent-skills.sh`
-- [ ] T055 [P] Fixture parity: confirm `tests/Nota.SmokeTest/Fixtures/Languages/verdicts.json` and `nota-translations/tools/fixtures/verdicts.json` are identical and both checks agree (R11)
-- [ ] T056 Run every step of `specs/077-key-based-localization/quickstart.md` and note results in the PR descriptions
+- [X] T052 Delete `scripts/loc-migrate.py` and the `keymap.tsv` ignore line in `.gitignore` (research R4)
+- [X] T053 [P] Finalise `CONTRIBUTING.md` § Translating Nota: translations live in `nota-daw/nota-translations`; adding a text in the app = `en.json` only
+- [X] T054 [P] Add the "sync references" step (`gh workflow run publish.yml --repo nota-daw/nota-translations` after the tag build) to `.claude/skills/release/SKILL.md`, then run `scripts/sync-agent-skills.sh`
+- [X] T055 [P] Fixture parity: confirm `tests/Nota.SmokeTest/Fixtures/Languages/verdicts.json` and `nota-translations/tools/fixtures/verdicts.json` are identical and both checks agree (R11)
+- [X] T056 Run every step of `specs/077-key-based-localization/quickstart.md` and note results in the PR descriptions
### Nota closing tasks *(PR gates — run for each nota PR)*
- [X] T057 Run `scripts/build.sh` (and `scripts/build-linux.sh` / `scripts/build-win.ps1` via CI) until native + managed + smoke test are green
- [X] T058 AGPL-3.0-only SPDX two-line header on every new source file (`scripts/loc-migrate.py`, `LanguageCatalog.cs`, `InstalledLanguages.cs`, `LanguageCatalogTests.cs`, nota-translations `tools/*.py`)
- [X] T059 New dependency: none → N/A
-- [ ] T060 `CHANGELOG.md` `[Unreleased]`: PR 1 → none (no user-visible change; mention in the PR); PR 3 → Changed "Languages other than English are downloaded from Preferences → Language and kept up to date; the app ships with English only" + Added "Load a language file to preview a translation"
-- [ ] T061 FEATURES.md via the `nota-features` skill and the user manual via `nota-docs` (EN + RU page on choosing, updating and previewing a language; shots harness uses `NOTA_UI_LANGUAGE=<path>` for French); `nota-docs/scripts/shortcuts.mjs` reads `PreferencesWindow.ShortcutGroups` by literal text — make it resolve `Loc.T("key")` through `src/managed/Nota.Application/Localization/en.json` (needed as soon as PR 1 is on `develop`); shortcuts: N/A
+- [X] T060 `CHANGELOG.md` `[Unreleased]`: PR 1 → none (no user-visible change; mention in the PR); PR 3 → Changed "Languages other than English are downloaded from Preferences → Language and kept up to date; the app ships with English only" + Added "Load a language file to preview a translation"
+- [X] T061 FEATURES.md via the `nota-features` skill and the user manual via `nota-docs` (EN + RU page on choosing, updating and previewing a language; shots harness uses `NOTA_UI_LANGUAGE=<path>` for French); `nota-docs/scripts/shortcuts.mjs` reads `PreferencesWindow.ShortcutGroups` by literal text — make it resolve `Loc.T("key")` through `src/managed/Nota.Application/Localization/en.json` (needed as soon as PR 1 is on `develop`); shortcuts: N/A
- [X] T062 Engine behaviour change: none → N/A
---
@@ -224,3 +224,11 @@ Task: "Copy fixtures into nota-translations/tools/fixtures/"
2. **PR 2 (US2)**: repository and checks; no app change, safe to merge any time after PR 1.
3. **PR 3 (US3 + US5 + US4)**: downloads, then the upgrade path, then local preview; merge
only with PR 2 live, and ship PR 2's content and PR 3 in the same release.
+
+## Phase 9: Convergence
+
+- [X] T063 Offer a **Download <Name>** button in the Language row when the stored language is not installed and Nota may not check on its own, in `src/managed/Nota.App/PreferencesWindow.Language.cs` per FR-021 (partial)
+- [X] T064 Separate installed from available languages in the Language combo in `src/managed/Nota.App/PreferencesWindow.Language.cs` per contracts/language-row.md (partial)
+- [X] T065 Fetch the language list in the background at start when the running language came from the repository and update checks are on, so **Update** is offered without a fetch on opening Settings, in `src/managed/Nota.App/LanguageDownloads.cs` per plan: research R10 (partial)
+- [X] T066 Run the quickstart steps for PR 3 and note the results in the pull request per T056 (partial)
+
diff --git a/src/managed/Nota.App/App.axaml.cs b/src/managed/Nota.App/App.axaml.cs
index c5c2d183..67d9f23f 100644
--- a/src/managed/Nota.App/App.axaml.cs
+++ b/src/managed/Nota.App/App.axaml.cs
@@ -48,6 +48,8 @@ public partial class App : Avalonia.Application
services.AddSingleton<ISampleAnalyzer, SampleAnalyzer>();
services.AddSingleton<ISampleIndex, SampleLibraryIndex>();
services.AddSingleton<IModelStore>(_ => new ModelStore());
+ services.AddSingleton(_ => NotaLanguages.Installed);
+ services.AddSingleton<LanguageCatalog>();
services.AddSingleton<IAppUpdater>(_ => new AppUpdater(AppInfo.Version));
services.AddSingleton<IClipAi, ClipAi>();
services.AddSingleton<IPresetLibrary, PresetLibrary>();
@@ -202,23 +204,40 @@ public partial class App : Avalonia.Application
}
/// <summary>Installs the interface language for this run. The saved choice, unless
- /// NOTA_UI_LANGUAGE names one — which holds for this run only and is never saved, for
- /// screenshots and layout checks. The OS language is deliberately not consulted: English
- /// is the default everywhere (spec 068). An unknown code reads as English.</summary>
+ /// NOTA_UI_LANGUAGE names one — a code, or the path of a language file (spec 077) — which
+ /// holds for this run only and is never saved, for screenshots, layout checks and
+ /// translators. The OS language is deliberately not consulted: English is the default
+ /// everywhere (spec 068). A language that is not installed reads as English; the stored
+ /// choice is left as written, so it can still be downloaded (LanguageStartup).</summary>
private static void InstallLanguage(Settings settings, ILogSink log)
{
+ var wanted = Environment.GetEnvironmentVariable("NOTA_UI_LANGUAGE");
+ bool isPath = !string.IsNullOrWhiteSpace(wanted)
+ && (wanted.EndsWith(".json", StringComparison.OrdinalIgnoreCase) || System.IO.File.Exists(wanted));
+ TranslationTable? fromFile = null;
+ if (isPath)
+ {
+ fromFile = NotaLanguages.FromFile(wanted, out var fileError);
+ if (fromFile is null) log.Error($"Interface language — {wanted}: {fileError}", null);
+ }
foreach (var err in NotaLanguages.LoadErrors) log.Error($"Interface language — {err}", null);
// A key in no table, not even English, shows as itself: the smoke test rules it out.
Loc.MissingKey += key => log.Warn($"Interface text key not found: {key}");
- var wanted = Environment.GetEnvironmentVariable("NOTA_UI_LANGUAGE");
- var code = UiLanguage.Normalize(string.IsNullOrWhiteSpace(wanted) ? settings.Language : wanted, NotaLanguages.Codes);
+ string code;
+ TranslationTable? table;
+ if (fromFile is not null) { code = fromFile.Code; table = fromFile; }
+ else
+ {
+ code = UiLanguage.Normalize(isPath || string.IsNullOrWhiteSpace(wanted) ? settings.Language : wanted, NotaLanguages.Codes);
+ table = NotaLanguages.Find(code);
+ }
// A text asked for before this point was built in English and will not follow the language.
if (Loc.UsedBeforeInstall) log.Warn("Interface text was built before the language was installed");
- // English is the default whatever the OS language is: only the stored choice (or the test override above) is read.
- Loc.Install(NotaLanguages.Find(code), code);
+ // English is the default whatever the OS language is: only the stored choice (or the override above) is read.
+ Loc.Install(table, code);
// The system's own text (application menu, open panels) follows an explicit choice from the next start.
if (code != UiLanguage.Default) MacSystemLanguage.Set(code);
- log.Info($"Interface language · {code}");
+ log.Info($"Interface language · {code}" + (fromFile is not null ? $" (file {wanted})" : ""));
}
// App.axaml is loaded in Initialize(), before the language is installed, so the macOS
diff --git a/src/managed/Nota.App/LanguageDownloads.cs b/src/managed/Nota.App/LanguageDownloads.cs
new file mode 100644
index 00000000..f7de6e18
--- /dev/null
+++ b/src/managed/Nota.App/LanguageDownloads.cs
@@ -0,0 +1,203 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
+//
+// The app's one view of the languages it can download (spec 077): the language list from
+// nota-translations, a download in progress, and a language that is installed and waiting for a
+// restart. It lives for the app, so Settings → Appearance → Language and the main window's status
+// bar notice show the same state and share one download. All members are used on the UI thread.
+//
+// Network policy (research R10): Nota asks for the list on its own only when Settings → Updates →
+// "Check for updates" is on — when the Language row is shown, and at start when the stored
+// language is not installed (an update from a Nota that had French built in: story 5). With
+// checks off it asks only when the user clicks. Starting never waits for any of it.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia.Threading;
+using Microsoft.Extensions.DependencyInjection;
+using Nota.Application;
+using Nota.Application.Localization;
+using Nota.Infrastructure;
+
+namespace Nota.App;
+
+internal sealed class LanguageDownloads
+{
+ public static LanguageDownloads Shared { get; } = new();
+
+ private Task? _fetching;
+ private CancellationTokenSource? _download;
+
+ /// <summary>The list, once fetched (or read from the cache) this run.</summary>
+ public LanguageIndex? Index { get; private set; }
+
+ /// <summary>Why the list could not be had, if it could not.</summary>
+ public string? IndexError { get; private set; }
+
+ /// <summary>The code being downloaded, and how far (0–1, or -1 unknown).</summary>
+ public string? Downloading { get; private set; }
+ public double Progress { get; private set; } = -1;
+
+ /// <summary>The last download that failed: its code and why.</summary>
+ public (string Code, string Message)? Failed { get; private set; }
+
+ /// <summary>A language installed this run that is the stored choice but not the running one:
+ /// the restart the status bar offers (story 5).</summary>
+ public LanguageInfo? Ready { get; private set; }
+
+ /// <summary>The status bar notice was dismissed for this run.</summary>
+ public bool Dismissed { get; private set; }
+
+ /// <summary>Languages downloaded this run: a running one that was updated reads its new
+ /// version only after a restart, which the row and the status bar say.</summary>
+ public IReadOnlySet<string> UpdatedThisRun => _updated;
+ private readonly HashSet<string> _updated = new(StringComparer.Ordinal);
+
+ /// <summary>Something other than download progress changed (the list, a download began or
+ /// ended): listeners may re-read what is installed.</summary>
+ public event Action? Changed;
+
+ /// <summary>Only the progress of the running download moved.</summary>
+ public event Action? ProgressChanged;
+
+ private static ISettingsService Settings => App.Services.GetRequiredService<ISettingsService>();
+ private static LanguageCatalog Catalog => App.Services.GetRequiredService<LanguageCatalog>();
+ private static InstalledLanguages Installed => App.Services.GetRequiredService<InstalledLanguages>();
+
+ /// <summary>Whether Nota may ask GitHub on its own (Settings → Updates).</summary>
+ public static bool MayCheck => Settings.Current.CheckForUpdates;
+
+ /// <summary>This Nota's key set and version, for coverage (contracts/index.md).</summary>
+ public static int? CoverageOf(LanguageIndex index, CatalogLanguage l)
+ => LanguageCatalog.CoverageFor(index, l, Loc.English.KeySetHash(), AppInfo.Version);
+
+ /// <summary>The list without the network: the cache, if any. Leaves <see cref="Index"/> alone
+ /// when it already has a fresher one.</summary>
+ public void LoadCached()
+ {
+ if (Index is null && Catalog.Cached() is { } cached) { Index = cached; Raise(); }
+ }
+
+ /// <summary>Fetch the list (once per run unless <paramref name="refresh"/>). The cache serves
+ /// while it is a day fresh and when offline.</summary>
+ public Task FetchAsync(bool refresh = false)
+ {
+ if (_fetching is { IsCompleted: false }) return _fetching;
+ if (Index is not null && IndexError is null && !refresh && _fetchedThisRun) return Task.CompletedTask;
+ return _fetching = Run();
+
+ async Task Run()
+ {
+ try
+ {
+ var index = await Task.Run(() => Catalog.FetchAsync(refresh));
+ Index = index;
+ IndexError = null;
+ _fetchedThisRun = true;
+ }
+ catch (Exception e) when (e is StoreException or System.Text.Json.JsonException or System.IO.IOException)
+ {
+ IndexError = e.Message;
+ }
+ Raise();
+ }
+ }
+ private bool _fetchedThisRun;
+
+ /// <summary>Download and install one language. True on success; on failure <see cref="Failed"/>
+ /// says why and the installed copy, if any, is unchanged.</summary>
+ public async Task<bool> DownloadAsync(CatalogLanguage language)
+ {
+ if (Downloading is not null) return false;
+ Downloading = language.Code;
+ Progress = -1;
+ Failed = null;
+ _download = new CancellationTokenSource();
+ Raise();
+ var progress = new Progress<StoreProgress>(p => { Progress = p.Fraction; RaiseProgress(); });
+ try
+ {
+ await Task.Run(() => Catalog.DownloadAsync(language, progress, _download.Token));
+ Downloading = null;
+ _updated.Add(language.Code);
+ NoteReady(language.Code, language.Name);
+ Raise();
+ return true;
+ }
+ catch (Exception e) when (e is StoreException or System.IO.IOException or OperationCanceledException or UnauthorizedAccessException)
+ {
+ Downloading = null;
+ Failed = (language.Code, e is OperationCanceledException ? Loc.T("language_downloads.cancelled") : e.Message);
+ Raise();
+ return false;
+ }
+ }
+
+ public void CancelDownload() => _download?.Cancel();
+
+ public void Dismiss() { Dismissed = true; Raise(); }
+
+ /// <summary>After an install or a removal: whether a restart now changes the language.</summary>
+ public void NoteReady(string code, string name)
+ {
+ Ready = IsPendingRestart(code) ? new LanguageInfo(code, name) : null;
+ }
+
+ /// <summary>Whether a restart changes what is shown for the stored language: it is not the
+ /// running one, or it is and a newer version of it was installed this run.</summary>
+ public bool IsPendingRestart(string code)
+ => Settings.Current.Language == code && (Loc.Language != code || _updated.Contains(code));
+
+ public void ClearReady() { Ready = null; Raise(); }
+
+ /// <summary>Once the main window is up, when Nota may check on its own: if the stored language
+ /// is not installed (Nota used to ship French, story 5) fetch it in the background; if a
+ /// language from the repository is running, fetch the list so an update is known.</summary>
+ public void StartupCheck(ILogSink log)
+ {
+ var stored = Settings.Current.Language?.Trim().ToLowerInvariant() ?? "";
+ // A language from the repository is running: learn about a newer translation in the
+ // background, so Settings offers Update straight away (research R10).
+ if (stored.Length == 0 || stored == UiLanguage.Default || !InstalledLanguages.IsSafeCode(stored)) return;
+ var mine = Installed.Read(stored);
+ // A translator's own file is never replaced by a download, even when it does not load
+ // today (moved, mid-edit): the row says what is wrong with it.
+ if (mine is { Meta.IsLocal: true }) return;
+ if (Loc.Language == stored)
+ {
+ if (MayCheck && mine is { Table: not null }) _ = FetchAsync();
+ return;
+ }
+ if (mine is { Table: not null }) return; // installed, only not running (e.g. NOTA_UI_LANGUAGE)
+ if (!MayCheck) { LoadCached(); return; }
+ _ = Run();
+
+ async Task Run()
+ {
+ await FetchAsync();
+ if (Index?.Languages.FirstOrDefault(l => l.Code == stored) is not { } language)
+ {
+ log.Warn($"Interface language {stored} is not installed and not offered: {IndexError ?? "not in the language list"}");
+ return;
+ }
+ log.Info($"Interface language {stored} is not installed: downloading it");
+ if (await DownloadAsync(language)) log.Info($"Interface language {stored} installed; applies after a restart");
+ else log.Warn($"Interface language {stored} could not be downloaded: {Failed?.Message}");
+ }
+ }
+
+ private void RaiseProgress()
+ {
+ if (Dispatcher.UIThread.CheckAccess()) ProgressChanged?.Invoke();
+ else Dispatcher.UIThread.Post(() => ProgressChanged?.Invoke());
+ }
+
+ private void Raise()
+ {
+ if (Dispatcher.UIThread.CheckAccess()) Changed?.Invoke();
+ else Dispatcher.UIThread.Post(() => Changed?.Invoke());
+ }
+}
diff --git a/src/managed/Nota.App/Languages/NotaLanguages.cs b/src/managed/Nota.App/Languages/NotaLanguages.cs
index 4efae80c..5c79f437 100644
--- a/src/managed/Nota.App/Languages/NotaLanguages.cs
+++ b/src/managed/Nota.App/Languages/NotaLanguages.cs
@@ -1,36 +1,38 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
-// The interface languages (spec 068, keyed since spec 077). English is the reference built into
-// Loc; Languages/<code>.json is where a translation lives, embedded as Nota.Languages.<code>.json
-// and read here at startup, checked against the English reference. The
-// picker lists whatever loads, so adding a language is adding a file. Like the colour-theme
-// loader, this validates rather than trusts: a file that fails is left out and noted in
-// LoadErrors, never thrown at the UI, and Nota still starts in English.
+// The interface languages this Nota can start in (specs 068 and 077). English is the reference
+// built into Loc; every other language is one Nota downloaded from nota-translations or a file a
+// translator loaded, both kept by InstalledLanguages under the data folder. Read once at start-up
+// with no network: what is installed is what Nota can run in. Like the colour-theme loader, this
+// validates rather than trusts — a file that cannot be read is left out and noted in LoadErrors,
+// an entry that cannot be used shows English, and Nota always starts.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Nota.Application.Localization;
+using Nota.Infrastructure;
namespace Nota.App;
-/// <summary>One offered language: its code ("fr") and its own name ("Français").</summary>
+/// <summary>One language Nota can start in: its code ("fr") and its own name ("Français").</summary>
public sealed record LanguageInfo(string Code, string Name);
public static class NotaLanguages
{
- private const string Prefix = "Nota.Languages.";
- private const string Suffix = ".json";
-
private static IReadOnlyDictionary<string, TranslationTable>? _tables;
private static readonly List<string> _loadErrors = new();
+ private static InstalledLanguages? _installed;
+
+ /// <summary>The languages folder (created on first use).</summary>
+ public static InstalledLanguages Installed => _installed ??= new InstalledLanguages();
- /// <summary>Why a language file was left out, if any was. Logged at startup.</summary>
+ /// <summary>Why a language was left out or which of its entries show English. Logged at start.</summary>
public static IReadOnlyList<string> LoadErrors { get { _ = Tables; return _loadErrors; } }
- /// <summary>The languages the picker offers: English first, then the rest by code.</summary>
+ /// <summary>English first, then the installed languages by code.</summary>
public static IReadOnlyList<LanguageInfo> Available
=> Tables.Values
.OrderBy(t => t.Code == UiLanguage.Default ? 0 : 1).ThenBy(t => t.Code, StringComparer.Ordinal)
@@ -39,36 +41,50 @@ public static class NotaLanguages
/// <summary>The codes of <see cref="Available"/>, for <see cref="UiLanguage.Normalize"/>.</summary>
public static IReadOnlyCollection<string> Codes => Tables.Keys.ToList();
- /// <summary>The loaded table for a code, or null if there is none.</summary>
+ /// <summary>The table for a code, or null if that language is not installed.</summary>
public static TranslationTable? Find(string code) => Tables.TryGetValue(code, out var t) ? t : null;
+ /// <summary>A language file read from a path (NOTA_UI_LANGUAGE=/path/to/de.json): this run
+ /// only, never installed. Null with a reason when it cannot be used.</summary>
+ public static TranslationTable? FromFile(string path, out string? error)
+ {
+ try
+ {
+ var table = TranslationTable.Parse(File.ReadAllText(path), out error);
+ if (table is not null) Report(table.Code, table);
+ return table;
+ }
+ catch (Exception e) when (e is IOException or UnauthorizedAccessException)
+ {
+ error = e.Message;
+ return null;
+ }
+ }
+
private static IReadOnlyDictionary<string, TranslationTable> Tables => _tables ??= Load();
private static IReadOnlyDictionary<string, TranslationTable> Load()
{
var tables = new Dictionary<string, TranslationTable>(StringComparer.Ordinal);
- var asm = typeof(NotaLanguages).Assembly;
- foreach (var resource in asm.GetManifestResourceNames().Where(n => n.StartsWith(Prefix) && n.EndsWith(Suffix)).Order(StringComparer.Ordinal))
- {
- var fileCode = resource[Prefix.Length..^Suffix.Length];
- string json;
- using (var s = asm.GetManifestResourceStream(resource))
- {
- if (s is null) { _loadErrors.Add($"{fileCode}: language file not readable"); continue; }
- using var r = new StreamReader(s);
- json = r.ReadToEnd();
- }
- var table = TranslationTable.Parse(json, out var error);
- if (table is null) { _loadErrors.Add($"{fileCode}: {error}"); continue; }
- if (table.Code != fileCode) { _loadErrors.Add($"{fileCode}: file declares code '{table.Code}'"); continue; }
- if (table.Code == UiLanguage.Default) continue; // English is the built-in reference
- var (problems, _) = table.ValidateAgainst(Loc.English);
- foreach (var p in problems) _loadErrors.Add($"{fileCode}: {p.Key} — {p.Problem} (English is shown)");
- tables[table.Code] = table;
- }
- // English is the reference of every text, built into Loc (spec 077); it is always offered.
if (Loc.EnglishError is { } englishError) _loadErrors.Add($"en: {englishError}");
tables[UiLanguage.Default] = Loc.English;
+ IReadOnlyList<InstalledLanguage> installed;
+ try { installed = Installed.List(); }
+ catch (Exception e) when (e is IOException or UnauthorizedAccessException) { _loadErrors.Add("languages folder: " + e.Message); installed = Array.Empty<InstalledLanguage>(); }
+ foreach (var l in installed)
+ {
+ if (l.Table is null) { _loadErrors.Add($"{l.Code}: {l.Error} — the language is not offered"); continue; }
+ if (l.Code == UiLanguage.Default) continue; // English is the built-in reference
+ Report(l.Code, l.Table);
+ tables[l.Code] = l.Table;
+ }
return tables;
}
+
+ private static void Report(string code, TranslationTable table)
+ {
+ var (problems, _) = table.ValidateAgainst(Loc.English);
+ foreach (var p in problems.Take(50)) _loadErrors.Add($"{code}: {p.Key} — {p.Problem} (English is shown)");
+ if (problems.Count > 50) _loadErrors.Add($"{code}: …and {problems.Count - 50} more entries that show English");
+ }
}
diff --git a/src/managed/Nota.App/Languages/fr.json b/src/managed/Nota.App/Languages/fr.json
deleted file mode 100644
index b94b4756..00000000
--- a/src/managed/Nota.App/Languages/fr.json
+++ /dev/null
@@ -1,3759 +0,0 @@
-{
- "formatVersion": 2,
- "code": "fr",
- "name": "Français",
- "plural": "one_is_0_1",
- "notes": "Glossary and register: specs/068-ui-language/glossary.md. Actions use the infinitive; sentence case; device and parameter names stay English. Keys are the English reference's keys (Nota.Application/Localization/en.json); counted texts take {\"one\", \"other\"} and French counts 0 and 1 as one.",
- "strings": {
- "about.2026_egor_khindikaynen_ambertape": "© 2026 Egor Khindikaynen (Ambertape)",
- "about.desktop_daw_agplv3": "DAW de bureau · AGPLv3",
- "about.engine": "Moteur {0}",
- "about.free_software_under_the_gnu": "Logiciel libre sous licence GNU AGPLv3.",
- "about.includes_third_party_software_juce": "Inclut des logiciels tiers (JUCE, Avalonia, miniaudio, RtMidi, dr_libs, Signalsmith, HIIR). Voir LICENSES/THIRD-PARTY-NOTICES.md pour les mentions de droits d’auteur et d’attribution.",
- "ai.clip_ai.loading_the_model": "Chargement du modèle…",
- "ai.clip_ai.preparing_audio": "Préparation de l’audio…",
- "ai.clip_ai.separating_stems": "Séparation des stems…",
- "ai.clip_ai.writing_stems": "Écriture des stems…",
- "ai.onnx_runtime_loader.nota_couldnt_load_the_ai": "Nota n’a pas pu charger le moteur d’IA. Le supprimer dans Réglages → Téléchargements → Modèles d’IA puis le réinstaller.",
- "ai.onnx_runtime_loader.the_ai_model_file_is": "Le fichier du modèle d’IA est endommagé. Le supprimer dans Réglages → Téléchargements → Modèles d’IA puis le réinstaller.",
- "app.settings": "Réglages…",
- "app_updates.couldnt_download_the_update": "Impossible de télécharger la mise à jour : {0}",
- "arrangement.add_audio_track": "Ajouter une piste audio",
- "arrangement.add_instrument_track": "Ajouter une piste d’instrument",
- "arrangement.add_return_track": "Ajouter une piste de retour",
- "arrangement.add_track": "Ajouter une piste",
- "arrangement.auto_editor.copy_automation": "Copier l’automation",
- "arrangement.auto_editor.cut_automation": "Couper l’automation",
- "arrangement.auto_editor.delete_automation": "Supprimer l’automation",
- "arrangement.auto_editor.paste_automation": "Coller l’automation",
- "arrangement.automation.band": "Bande {0}",
- "arrangement.automation.choose_parameter": "Choisir un paramètre…",
- "arrangement.automation.filter_parameters": "Filtrer les paramètres…",
- "arrangement.automation.learn_touch_a_control_in": "Apprendre (toucher une commande dans le plug-in)",
- "arrangement.automation.param": "Param",
- "arrangement.automation.stage": "Étape {0}",
- "arrangement.bars": { "one": "{0} mesure", "other": "{0} mesures" },
- "arrangement.beats": "{0:0.##} temps",
- "arrangement.controls.clear_loop_region": "Effacer la région de boucle",
- "arrangement.controls.click_to_add_master_volume": "cliquer pour ajouter des points de volume master",
- "arrangement.controls.turn_loop_off": "Désactiver la boucle",
- "arrangement.controls.turn_loop_on": "Activer la boucle",
- "arrangement.copied_clip_to_session_scene": "Clip copié vers la scène {0} de la session",
- "arrangement.copied_clips_to_the_session": "{0} clips copiés vers la session à partir de la scène {1}",
- "arrangement.ext": "Ext",
- "arrangement.group_tracks": "Grouper les pistes",
- "arrangement.in": "Entrée",
- "arrangement.key_moves.no_track_above_takes_these": "Aucune piste au-dessus n’accepte ces clips",
- "arrangement.key_moves.no_track_below_takes_these": "Aucune piste en dessous n’accepte ces clips",
- "arrangement.key_moves.unfold_the_group_to_move": "Déplier le groupe pour déplacer ces clips entre les pistes",
- "arrangement.lane_control.activate": "Activer",
- "arrangement.lane_control.add_an_instrument_from_the": "Ajouter un instrument depuis le navigateur",
- "arrangement.lane_control.audio_clip": "Clip audio",
- "arrangement.lane_control.clips": { "one": "{0} clip", "other": "{0} clips" },
- "arrangement.lane_control.consolidate_selection": "Consolider la sélection",
- "arrangement.lane_control.convert": "Convertir",
- "arrangement.lane_control.copy_to_scene": "Copier vers la scène",
- "arrangement.lane_control.copy_to_session": "Copier vers Session",
- "arrangement.lane_control.couldnt_take_the_clips_audio": "Impossible de récupérer l’audio du clip : {0}",
- "arrangement.lane_control.deactivate": "Désactiver",
- "arrangement.lane_control.drums_to_new_midi_track": "Batterie vers une nouvelle piste MIDI",
- "arrangement.lane_control.edit_selected_clips_together": "Éditer ensemble les clips sélectionnés",
- "arrangement.lane_control.get_the_ai_model_for": "Obtenir le modèle d’IA pour la mélodie et l’harmonie…",
- "arrangement.lane_control.harmony_to_new_midi_track": "Harmonie vers une nouvelle piste MIDI",
- "arrangement.lane_control.insert_midi_clip": "Insérer un clip MIDI",
- "arrangement.lane_control.melody_to_new_midi_track": "Mélodie vers une nouvelle piste MIDI",
- "arrangement.lane_control.midi_clip": "Clip MIDI",
- "arrangement.lane_control.new_track": "Nouvelle piste",
- "arrangement.lane_control.rec": "Rec",
- "arrangement.lane_control.release_to_load_the_clip": "Relâcher pour charger le clip dans {0}",
- "arrangement.lane_control.scene": "Scène {0}",
- "arrangement.lane_control.separate_stems": "Séparer les stems…",
- "arrangement.lane_control.slice_to_new_midi_track": "Tranches vers une nouvelle piste MIDI",
- "arrangement.lane_control.split_here": "Découper ici",
- "arrangement.link.link_tracks_arming_and_clip": "Lier les pistes — l’armement et l’édition des clips agissent sur toutes les pistes du groupe · ⌥-clic sur un clip ou un bouton d’armement pour n’agir que sur une piste",
- "arrangement.link.linked_with": "Liée à {0}",
- "arrangement.link.the_groups_tracks_are_linked": "Les pistes du groupe sont liées",
- "arrangement.link_tracks": "Lier les pistes",
- "arrangement.loop_selection": "Boucler la sélection",
- "arrangement.master_cant_be_monitored_it": "Le master ne peut pas être écouté (il y aurait un larsen)",
- "arrangement.midi_from": "MIDI depuis",
- "arrangement.monitor_input_hear_it_live": "Écoute de l’entrée : l’entendre en direct à travers cette piste",
- "arrangement.monitoring_input_click_to_stop": "Écoute de l’entrée — cliquer pour arrêter",
- "arrangement.moved_across_tracks_device_automation": "Déplacé entre les pistes — l’automation des appareils est restée sur la source",
- "arrangement.new_track_drop.couldnt_move_the_clips_to": "Impossible de déplacer les clips vers de nouvelles pistes",
- "arrangement.new_track_drop.moved_to_new_tracks_device": "Déplacé vers de nouvelles pistes — l’automation des appareils est restée sur la source",
- "arrangement.overview.bar": "mesure {0}–{1} / {2}",
- "arrangement.overview.overview": "Aperçu",
- "arrangement.overview.the_project_appears_here": "le projet apparaît ici",
- "arrangement.paste_a_midi_clip_onto": "Coller un clip MIDI sur une piste MIDI, de l’audio sur de l’audio.",
- "arrangement.paste_track": "Coller la piste",
- "arrangement.played_from_a_phone": "Joué depuis un téléphone : {0}",
- "arrangement.processing": "Traitement…",
- "arrangement.sections.add_section_here": "Ajouter une section ici",
- "arrangement.sections.already_has_its_automatic_name": "{0} a déjà son nom automatique",
- "arrangement.sections.automatic_name": "Nom automatique",
- "arrangement.sections.back_to_the_automatic_name": "Retour au nom automatique ({0}), qui suit la position de la section",
- "arrangement.sections.couldnt_delete": "Impossible de supprimer {0}",
- "arrangement.sections.couldnt_duplicate": "Impossible de dupliquer {0}",
- "arrangement.sections.couldnt_move_there": "Impossible de déplacer {0} à cet endroit",
- "arrangement.sections.custom_name": "Nom personnalisé",
- "arrangement.sections.delete_all_sections": "Supprimer toutes les sections",
- "arrangement.sections.delete_with_content": "Supprimer avec le contenu",
- "arrangement.sections.deleted_with_its_content": "{0} supprimée avec son contenu",
- "arrangement.sections.drag_here_to_mark_a": "glisser ici pour marquer une section",
- "arrangement.sections.duplicate_with_content": "Dupliquer avec le contenu",
- "arrangement.sections.duplicated_with_its_content": "{0} dupliquée avec son contenu",
- "arrangement.sections.is_again": "“{0}” redevient {1}",
- "arrangement.sections.is_already_the_first_section": "{0} est déjà la première section",
- "arrangement.sections.is_already_the_last_section": "{0} est déjà la dernière section",
- "arrangement.sections.loop_section": "Boucler la section",
- "arrangement.sections.move_earlier": "Déplacer plus tôt",
- "arrangement.sections.move_later": "Déplacer plus tard",
- "arrangement.sections.moved_earlier": "{0} déplacée plus tôt",
- "arrangement.sections.moved_later": "{0} déplacée plus tard",
- "arrangement.sections.no_section_at_the_playhead": "Aucune section à la tête de lecture",
- "arrangement.sections.overlaps_another_section_separate_them": "{0} chevauche une autre section — les séparer pour déplacer son contenu avec elle",
- "arrangement.sections.reset_to_default": "Rétablir par défaut",
- "arrangement.sections.reset_to_default_name": "Rétablir le nom par défaut",
- "arrangement.sections.section_bars": { "one": "Section · {0} mesure", "other": "Section · {0} mesures" },
- "arrangement.sections.sections": "Sections",
- "arrangement.sections.select_section": "Sélectionner la section",
- "arrangement.send": "Envoi {0} · {1}",
- "arrangement.sends.show_sends_in_track_headers": "Afficher les envois dans les en-têtes de piste",
- "arrangement.takes.delete_take": "Supprimer la prise",
- "arrangement.takes.flatten_takes": "Aplatir les prises",
- "arrangement.takes.hide_takes": "Masquer les prises",
- "arrangement.takes.show_takes": "Afficher {0} prises",
- "arrangement.takes.take": "Prise {0}",
- "arrangement.takes.use_whole_take": "Utiliser la prise entière",
- "arrangement.tracks.height": "Hauteur",
- "arrangement.tracks.large": "Grand",
- "arrangement.tracks.standard": "Standard",
- "arrangement.tracks.tracks": "{0} pistes",
- "arrangement.ungroup": "Dégrouper",
- "arrangement.vol": "Vol",
- "arrangement.zoom": "Zoom",
- "audio_clip_editor.a_session_slot_plays_on": "Un emplacement de Session joue sur sa propre horloge de boucle — le lancer pour jouer depuis le début",
- "audio_clip_editor.beats": "Beats",
- "audio_clip_editor.click_point_drag_move_right": "Clic — point · glisser — déplacer · clic droit — supprimer",
- "audio_clip_editor.complex": "Complex",
- "audio_clip_editor.complex_pro": "Complex Pro",
- "audio_clip_editor.detect_tempo": "Détecter le tempo",
- "audio_clip_editor.detect_the_files_tempo_and": "Détecter le tempo du fichier et l’adapter au projet",
- "audio_clip_editor.detected": "Détecté",
- "audio_clip_editor.double_click_the_wave_marker": "Double-clic sur la forme d’onde — marqueur · glisser — aligner",
- "audio_clip_editor.double_the_tempo_the_clip": "Double du tempo — le clip couvre deux fois plus de temps",
- "audio_clip_editor.drag_a_handle_double_click": "Glisser une poignée · double-clic — réinitialiser",
- "audio_clip_editor.envelope": "Enveloppe",
- "audio_clip_editor.gain": "Gain",
- "audio_clip_editor.half_the_tempo_the_clip": "Moitié du tempo — le clip couvre deux fois moins de temps",
- "audio_clip_editor.markers": { "one": "{0} repère", "other": "{0} repères" },
- "audio_clip_editor.mono": "Mono",
- "audio_clip_editor.off": "désactivé",
- "audio_clip_editor.pin_a_marker_on_every": "Placer un marqueur sur chaque attaque pour caler la batterie sur la grille",
- "audio_clip_editor.play_the_whole_sample_at": "Jouer tout l’échantillon à plein niveau",
- "audio_clip_editor.playback": "Lecture",
- "audio_clip_editor.reset": "Réinitialiser",
- "audio_clip_editor.snap_needs_warp_turn_on": "Le magnétisme nécessite Warp — activer Warp pour voir la grille et s’y caler",
- "audio_clip_editor.stereo": "Stéréo",
- "audio_clip_editor.tempo": "Tempo",
- "audio_clip_editor.texture": "Texture",
- "audio_clip_editor.the_tempo_the_audio_was": "Le tempo auquel l’audio a été enregistré. Nota l’étire jusqu’au tempo du projet. ×2 / ÷2 corrigent une détection en demi-temps ou en double temps.",
- "audio_clip_editor.to_transients": "Aux transitoires",
- "audio_clip_editor.tones": "Tones",
- "audio_clip_editor.warp": "Warp",
- "audition.preset_audition.kits.kit_not_found": "Kit introuvable.",
- "audition.preset_audition.plug_in_presets_cant_be": "Les préréglages de plug-in ne peuvent pas être pré-écoutés — charger le plug-in pour les entendre.",
- "audition.preset_audition.preset_not_found": "Préréglage introuvable.",
- "audition.preset_audition.racks_play_what_their_chains": "Les racks jouent ce que contiennent leurs chaînes — rien à pré-écouter seul.",
- "audition.preset_audition.the_effect_rack_plays_what": "L’Effect Rack joue ce que contiennent ses chaînes — rien à pré-écouter seul.",
- "browser.add_audio_files_to_your": "Ajouter des fichiers audio au dossier d’échantillons (Réglages → Bibliothèque) ou installer des packs gratuits depuis Réglages → Téléchargements → Packs d’échantillons, puis les parcourir ici sous forme d’arborescence. Des fichiers peuvent aussi être glissés depuis le Finder.",
- "browser.add_to_favorites": "Ajouter aux favoris",
- "browser.analysing": " · analyse {0} %",
- "browser.any_key": "Toutes les tonalités",
- "browser.any_tempo": "Tous les tempos",
- "browser.arpeggiator_chord_scale_and_more": "Arpégiateur, accord, gamme et plus — ils traitent les notes avant un instrument : en déposer un à gauche d’un instrument dans une piste.",
- "browser.audio_effect": "Effet audio",
- "browser.audio_effects": "Effets audio",
- "browser.audio_effects_2": "Effets audio",
- "browser.bpm_caps": "BPM",
- "browser.built_in": "{0} intégrés · {1}",
- "browser.built_in_caps": "Intégrés",
- "browser.category_chips": "Pastilles de catégorie",
- "browser.collapse": "Replier",
- "browser.collapse_browser": "Replier le navigateur",
- "browser.couldnt_analyse_that_sample": "Impossible d’analyser cet échantillon",
- "browser.create_multisample": "Créer un multi-échantillon…",
- "browser.delete": "Supprimer…",
- "browser.edit_tags": "Modifier les étiquettes…",
- "browser.expand": "Déplier",
- "browser.expand_browser": "Déplier le navigateur",
- "browser.external_drop_named_no_files": "Le dépôt externe ne contenait aucun fichier lisible par Nota. Formats : {0}",
- "browser.favorites": "Favoris",
- "browser.favorites_first": "Favoris en premier",
- "browser.files": "Fichiers",
- "browser.filter_by_key_a_key": "Filtrer par tonalité — une tonalité montre aussi sa relative (A mineur ↔ C majeur)",
- "browser.filter_by_tempo": "Filtrer par tempo",
- "browser.finding_sounds_like": "Recherche de sons proches de {0}…",
- "browser.folder": "Dossier",
- "browser.group_by_source": "Grouper par source",
- "browser.history": "Historique",
- "browser.key": "Tonalité",
- "browser.like": "Comme {0}",
- "browser.loops": "Boucles",
- "browser.loops_within_5_of_bpm": "Les boucles à moins de 5 % de {0} BPM s’y calent proprement",
- "browser.map_the_folders_samples_by": "Assigner les échantillons du dossier selon leurs noms dans des préréglages Nota Mosaic",
- "browser.midi_effect": "Effet MIDI",
- "browser.midi_effects": "Effets MIDI",
- "browser.midi_effects_2": "Effets MIDI",
- "browser.midi_file": "Fichier MIDI",
- "browser.midi_map": "Carte MIDI",
- "browser.new_tag": "Nouvelle étiquette…",
- "browser.no_audio_effects_yet": "Aucun effet audio pour l’instant",
- "browser.no_instruments_yet": "Aucun instrument pour l’instant",
- "browser.no_matches": "Aucun résultat",
- "browser.no_matches_yet": "Aucun résultat pour l’instant",
- "browser.no_midi_effects_yet": "Aucun effet MIDI pour l’instant",
- "browser.no_presets_yet": "Aucun préréglage pour l’instant",
- "browser.no_projects_yet": "Aucun projet pour l’instant",
- "browser.no_samples_yet": "Aucun échantillon pour l’instant",
- "browser.nota_is_still_analysing_your": "Nota analyse encore les échantillons — d’autres résultats apparaissent au fur et à mesure.",
- "browser.nota_kits": "Nota Kits",
- "browser.notas_built_in_effects_plus": "Les effets intégrés de Nota et vos plug-ins VST/AU. Analyser vos plug-ins dans Réglages → Plug-ins pour en ajouter.",
- "browser.notas_built_in_synths_plus": "Les synthés intégrés de Nota et vos plug-ins VST/AU. Analyser vos plug-ins dans Réglages → Plug-ins pour en ajouter.",
- "browser.one_shots": "One-shots",
- "browser.packs": "Packs",
- "browser.plug_ins": { "one": "{0} plug-in", "other": "{0} plug-ins" },
- "browser.plug_ins_caps": "Plug-ins",
- "browser.preset": "Préréglage",
- "browser.presets": "Préréglages",
- "browser.presets_n": { "one": "{0} préréglage", "other": "{0} préréglages" },
- "browser.project": "Projet",
- "browser.project_key": "Tonalité du projet · {0}",
- "browser.project_tempo_5": "Tempo du projet ±5 %",
- "browser.projects": "Projets",
- "browser.projects_n": { "one": "{0} projet", "other": "{0} projets" },
- "browser.remove_from_favorites": "Retirer des favoris",
- "browser.right_click_a_device_header": "Clic droit sur l’en-tête d’un appareil puis « Enregistrer le préréglage » : il apparaît ici, groupé par catégorie et par appareil.",
- "browser.sample_packs_installed_from_settings": "packs d’échantillons installés depuis Réglages → Téléchargements",
- "browser.samples": { "one": "{0} échantillon", "other": "{0} échantillons" },
- "browser.save_a_project_s_into": "Enregistrer un projet (⌘S) dans le dossier Projets (Réglages → Bibliothèque) : il apparaît ici.",
- "browser.search": "Rechercher",
- "browser.show_similar_sounds": "Afficher les sons similaires",
- "browser.show_type_tags": "Afficher les étiquettes de type",
- "browser.sort_and_view": "Tri et affichage",
- "browser.sounds_like_closest_first_click": "Sons proches de {0}, les plus proches d’abord — cliquer pour revenir à tous les échantillons",
- "browser.tags": "Étiquettes",
- "browser.track_inspector": "Inspecteur de piste",
- "browser.transpose_to_project_key": "Transposer à la tonalité du projet",
- "browser.try_a_different_search_or": "Essayer une autre recherche ou effacer les filtres.",
- "browser.warp_loops_to_project_tempo": "Warper les boucles au tempo du projet",
- "clip_adsr.attack": "Attaque {0}",
- "clip_adsr.decay_sustain": "Déclin {0} · Maintien {1}",
- "clip_adsr.release": "Relâchement {0}",
- "clip_editor.click_to_add_a_point": "Clic pour ajouter un point",
- "clip_editor.click_to_add_a_point_2": "Clic pour ajouter un point · glisser pour déplacer · clic droit pour supprimer",
- "clip_editor.clip_the_selected_clip_track": "Clip : le clip sélectionné · Piste : tous les clips de la piste",
- "clip_editor.delete_every_note_outside_the": "Supprimer toutes les notes hors de la gamme",
- "clip_editor.env": "Env",
- "clip_editor.envelopes": "Enveloppes",
- "clip_editor.fit": "Ajuster",
- "clip_editor.fit_to_notes_f": "Ajuster aux notes (⇧F)",
- "clip_editor.fold": "Replier",
- "clip_editor.fold_show_f": "Replier : afficher {0} (⌥⇧F)",
- "clip_editor.hear_notes_as_you_place": "Entendre les notes quand on les place, les clique ou les fait glisser",
- "clip_editor.notes": "Notes",
- "clip_editor.only_the_notes_in_use": "seulement les notes utilisées",
- "clip_editor.only_the_pads": "seulement les pads",
- "clip_editor.only_the_scales_notes": "seulement les notes de la gamme",
- "clip_editor.remove_out_of_scale": "Supprimer hors gamme",
- "clip_editor.scale": "Gamme",
- "clip_editor.tools": "Outils",
- "clip_editor.track_clip": "Clip de la piste {0}",
- "clip_props.beat": "temps",
- "clip_props.beats": "temps",
- "clip_props.clips_always_loop": "Les clips bouclent toujours",
- "clip_props.double_click_add_or_delete": "Double-clic — ajouter ou supprimer · bord — longueur · Shift — ajouter à la sélection",
- "clip_props.no_notes_selected": "Aucune note sélectionnée",
- "clip_props.notes": "Notes",
- "clip_props.selection": "Sélection",
- "clip_props.strength": "Intensité",
- "clip_props.transpose": "Transposer",
- "command_palette.1_result": "1 résultat",
- "command_palette.add_stay": "ajouter et rester",
- "command_palette.add_to_canvas": "ajouter au canevas",
- "command_palette.all": "Tous",
- "command_palette.filter": "filtrer",
- "command_palette.insert": "insérer",
- "command_palette.load": "charger",
- "command_palette.new_track": "nouvelle piste",
- "command_palette.nothing_matches_try_a_role": "Aucun résultat. Essayer un rôle (reverb, comp), un caractère (warm, dark) ou une source (vocals, drums).",
- "command_palette.open_in_devices": "ouvrir dans Appareils",
- "command_palette.replace": "remplacer",
- "command_palette.results": "{0} résultats",
- "command_palette.run": "exécuter",
- "command_palette.search_actions_tracks_devices_presets": "Rechercher des actions, pistes, appareils, préréglages…",
- "command_palette.select": "sélectionner",
- "command_palette.showing_results_for": "Résultats pour ",
- "command_palette.typed_in_the_other_keyboard": " · saisi dans l’autre disposition de clavier",
- "commands.activate_deactivate_clip": "Activer / désactiver le clip",
- "commands.auto_arm_selected_track": "Armement automatique de la piste sélectionnée",
- "commands.clip_editor_fills_the_window": "L’éditeur de clips remplit la fenêtre",
- "commands.command_palette": "Palette de commandes",
- "commands.connect_phone": "Connecter un téléphone…",
- "commands.copy_clips_to_session_arrangement": "Copier les clips vers Session / Arrangement",
- "commands.cycle_clip_names": "Faire défiler les noms de clips",
- "commands.delete_section_with_content": "Supprimer la section avec son contenu",
- "commands.duplicate_section_with_content": "Dupliquer la section avec son contenu",
- "commands.edit_selected_clips_together": "Éditer ensemble les clips sélectionnés",
- "commands.exit_nota": "Quitter Nota",
- "commands.export_audio": "Exporter de l’audio…",
- "commands.fit_to_notes": "Ajuster aux notes",
- "commands.fold_the_piano_roll": "Replier le piano roll",
- "commands.follow_playhead": "Suivre la tête de lecture",
- "commands.freeze_track": "Geler la piste",
- "commands.group_tracks": "Grouper les pistes",
- "commands.help": "Aide",
- "commands.import_audio": "Importer de l’audio…",
- "commands.insert_scene": "Insérer une scène",
- "commands.launch_scene": "Lancer la scène",
- "commands.lock_envelopes": "Verrouiller les enveloppes",
- "commands.loop_record_overdub_replace": "Enregistrement en boucle : superposition / remplacement",
- "commands.midi_learn": "Apprentissage MIDI",
- "commands.mixer_in_its_own_window": "Mixeur dans sa propre fenêtre",
- "commands.move_section_earlier": "Déplacer la section plus tôt",
- "commands.move_section_later": "Déplacer la section plus tard",
- "commands.narrow_grid": "Réduire la grille",
- "commands.new_audio_track": "Nouvelle piste audio",
- "commands.new_midi_track": "Nouvelle piste MIDI",
- "commands.new_return_track": "Nouvelle piste de retour",
- "commands.open_devices_in_a_window": "Ouvrir les appareils dans une fenêtre",
- "commands.open_project": "Ouvrir un projet…",
- "commands.play_pause": "Lecture / pause",
- "commands.quantize_notes": "Quantifier les notes",
- "commands.redo": "Rétablir",
- "commands.remove_out_of_scale_notes": "Supprimer les notes hors gamme",
- "commands.reset_section_name": "Rétablir le nom de la section",
- "commands.save_project": "Enregistrer le projet",
- "commands.save_project_as": "Enregistrer le projet sous…",
- "commands.save_version_with_note": "Enregistrer une version avec note…",
- "commands.select_all_clips": "Sélectionner tous les clips",
- "commands.session": "Session",
- "commands.settings_appearance": "Réglages : Apparence",
- "commands.settings_audio": "Réglages : Audio",
- "commands.settings_downloads": "Réglages : Téléchargements",
- "commands.settings_gamepads": "Réglages : Manettes",
- "commands.settings_library": "Réglages : Bibliothèque",
- "commands.settings_midi": "Réglages : MIDI",
- "commands.settings_plug_ins": "Réglages : Plug-ins",
- "commands.settings_remote": "Réglages : Télécommande",
- "commands.settings_shortcuts": "Réglages : Raccourcis",
- "commands.settings_updates": "Réglages : Mises à jour",
- "commands.show_arrangement": "Afficher l’arrangement",
- "commands.show_devices": "Afficher les appareils",
- "commands.show_mixer": "Afficher le mixeur",
- "commands.show_modular": "Afficher la vue Modular",
- "commands.show_playhead": "Afficher la tête de lecture",
- "commands.show_session": "Afficher la vue Session",
- "commands.show_version_history": "Afficher l’historique des versions",
- "commands.split_at_playhead": "Découper à la tête de lecture",
- "commands.stop_all_clips": "Arrêter tous les clips",
- "commands.tap_tempo": "Tap tempo",
- "commands.toggle_adaptive_grid": "Activer / désactiver la grille adaptative",
- "commands.toggle_automation_mode": "Activer / désactiver le mode automation",
- "commands.toggle_browser": "Afficher/masquer le navigateur",
- "commands.toggle_clip_editor_track_mode": "Activer / désactiver le mode piste de l’éditeur de clips",
- "commands.toggle_detail_panel": "Afficher/masquer le panneau de détail",
- "commands.toggle_full_screen": "Activer/quitter le plein écran",
- "commands.toggle_loop": "Activer / désactiver la boucle",
- "commands.toggle_overview": "Afficher/masquer l’aperçu",
- "commands.toggle_sections": "Afficher/masquer les sections",
- "commands.toggle_snap_to_grid": "Activer / désactiver le magnétisme sur la grille",
- "commands.toggle_triplet_grid": "Activer / désactiver la grille en triolets",
- "commands.track_headers_on_the_right": "En-têtes de piste à droite",
- "commands.transpose_notes_down_an_octave": "Transposer les notes d’une octave vers le bas",
- "commands.transpose_notes_up_an_octave": "Transposer les notes d’une octave vers le haut",
- "commands.ungroup_tracks": "Dégrouper les pistes",
- "commands.view": "Affichage",
- "commands.widen_grid": "Élargir la grille",
- "common.1_bar": "1 mesure",
- "common.about_nota": "À propos de Nota",
- "common.attack": "Attaque",
- "common.audio": "Audio",
- "common.audio_n": "Audio {0}",
- "common.auto": "Auto",
- "common.cancel": "Annuler",
- "common.check_for_updates": "Rechercher des mises à jour…",
- "common.clear": "Effacer",
- "common.clear_all": "Tout effacer",
- "common.clip": "Clip",
- "common.close": "Fermer",
- "common.compact": "Compact",
- "common.consolidate": "Consolider",
- "common.copy": "Copier",
- "common.couldnt_load": "Impossible de charger {0}.",
- "common.cut": "Couper",
- "common.decay": "Déclin",
- "common.delete": "Supprimer",
- "common.documentation": "Documentation",
- "common.download": "Télécharger",
- "common.downloading_nota": "Téléchargement de Nota {0}…",
- "common.duplicate": "Dupliquer",
- "common.duplicate_time": "Dupliquer le temps",
- "common.edit": "Édition",
- "common.file": "Fichier",
- "common.freeze": "Geler",
- "common.gate": "Gate",
- "common.grid": "Grille",
- "common.group": "Groupe",
- "common.hz_runs_the_lfo_free": "Hz fait tourner le LFO librement ; Sync prend sa vitesse du tempo et le cale sur la mesure pendant la lecture",
- "common.input": "Entrée",
- "common.insert_silence": "Insérer du silence",
- "common.instrument": "Instrument",
- "common.instruments": "Instruments",
- "common.length": "Longueur",
- "common.loop": "Boucle",
- "common.macro": "Macro {0} · {1}",
- "common.master": "Master",
- "common.metronome": "Métronome",
- "common.midi_latency_0_smp": "MIDI · latence 0 éch.",
- "common.min": "Min",
- "common.mix_at_zero_only_the": "Mix à zéro : seul le signal sec s’entend",
- "common.mixer": "Mixeur",
- "common.modular": "Modular",
- "common.mute": "Muet",
- "common.new_project": "Nouveau projet",
- "common.none": "Aucune",
- "common.nota": "Nota",
- "common.off": "Désactivé",
- "common.open": "Ouvrir",
- "common.other": "Autre",
- "common.output": "Sortie",
- "common.pan": "Pan",
- "common.paste": "Coller",
- "common.paste_bounced_audio": "Coller l’audio rendu",
- "common.pattern": "Motif",
- "common.pattern_n": "{0} · {1}",
- "common.piano_roll": "Piano roll",
- "common.pitch": "Hauteur",
- "common.play_stop": "Lecture / arrêt",
- "common.quantize": "Quantifier",
- "common.range": "Plage",
- "common.rate_the_free_lfo_rate": "Rate — la vitesse libre du LFO, 0,02 … 8 Hz",
- "common.recent": "Récents",
- "common.record": "Enregistrement",
- "common.record_input": "Entrée d’enregistrement",
- "common.release": "Relâchement",
- "common.rename": "Renommer…",
- "common.return": "Retour",
- "common.return_n": "Retour {0}",
- "common.reverse": "Inverser",
- "common.sample": "Échantillon",
- "common.save_preset": "Enregistrer le préréglage",
- "common.select_a_track_first": "Sélectionner d’abord une piste.",
- "common.send": "Envoi {0}",
- "common.sends": "Envois",
- "common.settings": "Réglages",
- "common.show": "Afficher",
- "common.solo": "Solo",
- "common.start": "Début",
- "common.stereo_map": "Carte stéréo",
- "common.stop": "Arrêt",
- "common.sustain": "Maintien",
- "common.the_lfo_rate_in_hz": "La vitesse du LFO : en Hz, ou la valeur de note prise sur le tempo",
- "common.track": "Piste",
- "common.track_n": "Piste {0}",
- "common.transport": "Transport",
- "common.try_again": "Réessayer",
- "common.type_value": "Saisir une valeur…",
- "common.undo": "Annuler",
- "common.unpacking": "Décompression de {0}…",
- "common.update": "Mettre à jour",
- "common.velocity": "Vélocité",
- "common.version": "Version {0}",
- "common.volume": "Volume",
- "common.wet_only_send": "Wet only (envoi)",
- "common.whats_new": "Nouveautés",
- "control.clear_the_peak_hold": "Effacer le maintien de crête",
- "control.meter_fader.drag_to_set_the_volume": "Glisser pour régler le volume · cliquer pour effacer le maintien de crête",
- "control.na_badge.not_available_yet": "Pas encore disponible",
- "control.value_entry.parameter": "Paramètre",
- "control.value_entry.reset_to_default": "Rétablir par défaut",
- "control.value_entry.value": "Valeur",
- "detail.devices_clip": "Appareils / Clip",
- "device.active_click_to_bypass": "Actif — cliquer pour contourner",
- "device.arp.hold_keep_arpeggiating_after_the": "Hold : continuer l’arpège après le relâchement des touches",
- "device.arp.midi_out_ch_1": "Sortie MIDI · can. 1",
- "device.arp.midi_waiting_for_notes": "MIDI · en attente de notes",
- "device.arp.next_groove_lane": "Voie de groove suivante",
- "device.arp.no_notes_yet": "aucune note pour l’instant",
- "device.arp.notes_oct_cycle_steps": "{0} notes · {1} oct · cycle de {2} pas",
- "device.arp.oct": "{0} · {1} oct",
- "device.arp.restart_the_pattern_from_step": "Relancer le motif depuis le pas 1",
- "device.arp.step": "pas {0} · {1}",
- "device.aurora.8_in_use": "{0} / 8 utilisés",
- "device.aurora.click_for_the_next_macros": "Cliquer pour les macros suivantes, clic droit pour les précédentes",
- "device.aurora.click_for_the_next_target": "Cliquer pour la cible suivante, clic droit pour la précédente",
- "device.aurora.drag_a_cell_up_adds": "glisser une cellule — vers le haut ajoute, vers le bas retranche · ⌥-clic pour saisir · double-clic pour effacer",
- "device.aurora.drag_or_turn_to_change": "{0} · glisser ou tourner pour modifier, double-clic pour saisir",
- "device.aurora.drag_to_change_double_click": " · glisser pour modifier, double-clic pour réinitialiser",
- "device.aurora.shape_lfo": "Shape · LFO {0}",
- "device.aurora.shape_lfo_1_caps": "Shape · LFO 1",
- "device.aurora.the_oscillator_whose_table_and": "L’oscillateur dont cette tranche modifie la table et le mode de warp",
- "device.aurora.zero_every_route_in_the": "Remettre à zéro toutes les routes de la matrice",
- "device.auto_filter.analog_a_gentle_saturation_after": "Analog — une légère saturation après le filtre, comme un circuit analogique",
- "device.auto_filter.cutoff_over_time": "Coupure au fil du temps",
- "device.auto_filter.cutoff_the_base_the_modulation": "Cutoff — la base d’où part la modulation ; le repère en pointillés indique la valeur actuelle. Double-clic pour réinitialiser, ⌥-clic pour saisir une valeur.",
- "device.auto_filter.drag_sideways_for_the_cutoff": "Glisser latéralement pour la fréquence de coupure, vers le haut et le bas pour la résonance. La bande turquoise montre jusqu’où l’enveloppe et le LFO peuvent déplacer la coupure ; la courbe en pointillés indique où elle se trouve maintenant.",
- "device.auto_filter.envelope_follower_on_off": "Suiveur d’enveloppe activé / désactivé",
- "device.auto_filter.envelope_not_assigned": "enveloppe non assignée",
- "device.auto_filter.hold_keep_the_envelope_at": "Hold — garde l’enveloppe à son pic pendant le temps HOLD avant le relâchement (∞ la fige)",
- "device.auto_filter.lfo_not_assigned": "LFO non assigné",
- "device.auto_filter.lfo_on_off": "LFO activé / désactivé",
- "device.auto_filter.no_modulation_assigned": "aucune modulation assignée",
- "device.auto_filter.none_this_tracks_input": "Aucun — entrée de cette piste",
- "device.auto_filter.resonance_the_peak_at_the": "Resonance — le pic à la coupure ; le repère en pointillés indique la valeur actuelle. Double-clic pour réinitialiser, ⌥-clic pour saisir une valeur.",
- "device.auto_filter.retrig_restart_the_lfo_on": "Retrig — relance le LFO à chaque attaque d’entrée (−24 dBFS) et au démarrage de la lecture",
- "device.auto_filter.sidechain_key_envelope_source_caps": "Clé sidechain — source de l’enveloppe",
- "device.auto_filter.sidechain_key_the_envelope_follows": "Clé sidechain — l’enveloppe suit une autre piste au lieu de celle-ci. L’activer pour choisir la source et le gain de clé ; clic droit pour la modifier.",
- "device.auto_filter.stereo_phase_the_right_channels": "Stereo phase — le LFO du canal droit avance sur celui du gauche (90° une fois activé ; clic droit par pas de 45° … 180°)",
- "device.auto_filter.the_inputs_envelope_teal_and": "L’enveloppe de l’entrée (turquoise) et la coupure qu’elle pilote (neutre), la coupure de base en pointillés. Glisser vers le haut ou le bas pour la quantité.",
- "device.auto_filter.the_lfos_movement_over_the": "Le mouvement du LFO sur la fenêtre — forme brute en pointillés, ce que suit le filtre (après Smooth) en neutre, le canal droit en rose quand la stéréo est activée. Glisser vers le haut ou le bas pour la quantité, latéralement pour la phase de départ.",
- "device.auto_gain.auto_rides_the_gain_to": "Auto amène le gain vers la cible sur Window ; Manual garde le fader là où il est placé (Match le règle sur l’écart à la cible)",
- "device.auto_gain.ceiling_6_0_dbtp_drag": "Ceiling, −6 … 0 dBTP — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour revenir à −1,0",
- "device.auto_gain.fixed_target_no_reference": "Cible fixe — pas de référence",
- "device.auto_gain.input_loudness_on_the_chosen": "Volume d’entrée sur l’échelle choisie (LUFS) ; le repère turquoise est la cible",
- "device.auto_gain.input_silent_the_measurement_and": "Entrée silencieuse : la mesure et le gain sont maintenus",
- "device.auto_gain.leveler_bypassed_the_output_equals": "Leveler contourné : la sortie est égale à l’entrée",
- "device.auto_gain.limited_by_max_cut": "limité par la coupe max.",
- "device.auto_gain.limited_by_max_gain": "limité par le gain max.",
- "device.auto_gain.limited_by_true_peak": "limité par le true-peak",
- "device.auto_gain.match_set_the_manual_gain": "Match — règle le gain manuel sur l’écart entre l’entrée mesurée et la cible",
- "device.auto_gain.max_gain_the_most_the": "Max gain — le renfort ou l’atténuation maximum de la correction, 0 … 24 dB",
- "device.auto_gain.output_loudness_on_the_chosen": "Volume de sortie sur l’échelle choisie (LUFS) ; le repère turquoise est la cible",
- "device.auto_gain.output_lu_from_the_target": "Sortie à {0} LU de la cible · Match règle {1} dB",
- "device.auto_gain.output_true_peak_dbtp_the": "True peak de sortie (dBTP) ; le repère turquoise est le plafond tant que True-peak safe est activé",
- "device.auto_gain.reset_restart_the_measurement_from": "Reset — relance la mesure à partir du volume actuel, pour que l’ajustement rattrape aussitôt",
- "device.auto_gain.response_slow_glides_over_the": "Response — Slow glisse sur toute la fenêtre Window avec 20 ms d’anticipation ; Fast sur un quart de celle-ci avec 5 ms",
- "device.auto_gain.scale_what_the_correction_reads": "Scale — ce que lit la correction : Momentary (400 ms, rapide et nerveux), Short-term (3 s) ou Integrated (12 s avec gating BS.1770, le plus stable)",
- "device.auto_gain.target_loudness_36_0_lufs": "Volume cible, −36 … 0 LUFS. Cliquer sur la valeur pour les standards ou pour s’aligner sur le volume d’une autre piste (une référence) ; glisser la ligne en pointillés du graphique pour la même chose",
- "device.auto_gain.the_correction_applied_max_gain": "La correction appliquée, ±Max Gain autour de 0 dB (trim non inclus)",
- "device.auto_gain.the_correction_around_0_db": "La correction autour de 0 dB, ±Max Gain. En Manual, la glisser (Maj pour les pas fins) ; ⌥-clic pour saisir, double-clic pour revenir à 0 dB. En Auto, elle montre l’ajustement",
- "device.auto_gain.the_last_8_s_input": "Les 8 dernières secondes : entrée, sortie et cible avec sa bande de ±1 LU (volume momentané). Glisser vers le haut / bas pour déplacer la cible ; ⌥-clic pour saisir, double-clic pour la réinitialiser",
- "device.auto_gain.trim_a_fixed_offset_after": "Trim — un décalage fixe après la correction, −12 … +12 dB (la sortie s’écarte alors d’autant de la cible)",
- "device.auto_gain.true_peak_safe_a_look": "True-peak safe — un limiteur à anticipation maintient la sortie sous le plafond (ajoute 5 / 20 ms de latence, compensée)",
- "device.auto_gain.waiting_for_signal": "en attente de signal",
- "device.auto_gain.waiting_for_signal_the_gain": "En attente de signal — le gain est maintenu jusqu’à la mesure de l’entrée",
- "device.auto_gain.what_the_leveler_is_doing": "Ce que fait le leveler en ce moment",
- "device.auto_gain.window_how_long_the_ride": "Window — le temps que met l’ajustement à atteindre la cible, 0,4 … 10 s (Fast : un quart de ce temps)",
- "device.auto_pan.0_tremolo_both_channels_together": "0° — trémolo : les deux canaux ensemble",
- "device.auto_pan.180_auto_pan_one_side": "180° — auto-pan : un côté monte quand l’autre descend",
- "device.auto_pan.90_a_quarter_cycle_apart": "90° — un quart de cycle d’écart : le son tourne en cercle",
- "device.auto_pan.above_8_hz_the_movement": "Au-delà de 8 Hz, le mouvement s’entend comme un flottement et non comme un panoramique",
- "device.auto_pan.amount_or_mix_at_zero": "Amount ou Mix à zéro : rien ne bouge",
- "device.auto_pan.amount_the_depth_each_channel": "Amount — la profondeur : chaque canal descend à 1 − Amount au creux du LFO",
- "device.auto_pan.both_channels_gain_over_two": "Gain des deux canaux sur deux cycles du LFO — L neutre, R turquoise, Phase plus tard — avec le plancher atteint par la profondeur. Glisser vers le haut / bas pour Amount, à gauche / droite pour Phase ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
- "device.auto_pan.gain_2_cycles_caps": "Gain · 2 cycles",
- "device.auto_pan.mix_the_moving_signal_against": "Mix — le signal en mouvement face au signal sec",
- "device.auto_pan.panner_bypassed_the_signal_passes": "Panner contourné : le signal passe inchangé",
- "device.auto_pan.phase_0_l_and_r": "Phase 0° : L et R bougent ensemble, le niveau descend à ",
- "device.auto_pan.phase_the_right_lfo_against": "Phase — le LFO droit par rapport au gauche : 0° trémolo, 90° panoramique circulaire, 180° auto-pan",
- "device.auto_pan.rate_the_free_lfo_rate": "Rate — la vitesse libre du LFO, 0,01 … 40 Hz",
- "device.auto_pan.rate_the_note_value_of": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/32 avec valeurs pointées (D) et en triolets (T)",
- "device.auto_pan.shape_sharpens_sine_tri_and": "Shape — durcit Sine, Tri et Saw vers un carré ; sur S&H c’est Glide, le glissement d’un pas au suivant",
- "device.auto_pan.the_channels_output_peak_60": "La crête de sortie du canal, −60 … 0 dBFS, et le gain que le LFO lui donne en ce moment, dB",
- "device.auto_pan.the_lfo_shape_s_h": "La forme du LFO. S&H tire un pas aléatoire à chaque cycle ; le canal droit joue les mêmes pas avec un décalage Phase",
- "device.auto_pan.what_the_phase_makes_tremolo": "Effet de la phase : trémolo près de 0°, auto-pan près de 180°, un panoramique décalé entre les deux",
- "device.auto_pan.where_the_sound_sits_now": "Où se trouve le son entre gauche et droite en ce moment, sur l’excursion couverte par le LFO",
- "device.auto_shift.amount_how_far_the_voice": "Amount — l’attraction de la voix vers la note",
- "device.auto_shift.amount_how_far_the_voice_2": "Amount — l’attraction de la voix vers la note cible",
- "device.auto_shift.bend_the_widest_move_between": "Bend — le plus grand écart entre notes qui glisse via Glide ; les sauts plus larges sont directs",
- "device.auto_shift.custom_edit_on_the_scale": "Custom — à modifier dans l’onglet Scale",
- "device.auto_shift.follow_copy_the_key_and": "Follow — copie la tonalité et la gamme d’un effet MIDI Nota Scale",
- "device.auto_shift.follow_copy_the_key_and_2": "Follow — copie la tonalité et la gamme d’un effet MIDI Nota Scale (celui de cette piste, de la source MIDI, ou le premier trouvé)",
- "device.auto_shift.follow_scale_device": "Suivre l’appareil Scale",
- "device.auto_shift.from_the_instrument_track_whose": "From — la piste d’instrument dont les notes définissent la cible (ses clips et effets MIDI, même muette)",
- "device.auto_shift.glide_how_long_the_target": "Glide — la durée du glissement de la cible d’une note à la suivante (Pitch bend from MIDI)",
- "device.auto_shift.how_long_each_note_was": "La durée de chaque note chantée (les ~16 dernières mesures) sur les notes de la gamme — neutre dans la gamme, turquoise en dehors. Cliquer une colonne pour ajouter ou retirer sa note",
- "device.auto_shift.human_keeps_vibrato_and_slow": "Human — garde le vibrato et la dérive lente autour de la note corrigée (0 = plat)",
- "device.auto_shift.key_source_auto_follows_the": "Key source — Auto suit la tonalité chantée, Manual utilise la tonalité et la gamme réglées, MIDI prend la cible dans les notes d’une autre piste (onglet MIDI)",
- "device.auto_shift.key_source_is_not_midi": "Key Source n’est pas MIDI",
- "device.auto_shift.key_the_tonic_the_scales": "Key — la tonique ; les notes de la gamme sont comptées à partir d’elle",
- "device.auto_shift.latch_holds_the_target_between": "latch maintient la cible entre les notes",
- "device.auto_shift.latch_keep_the_last_target": "Latch — garde la dernière cible entre les notes (off = aucune correction tant qu’aucune note n’est tenue)",
- "device.auto_shift.learn_listen_to_what_is": "Learn — écoute ce qui est chanté, puis cliquer à nouveau pour régler la tonalité et la gamme qui conviennent le mieux",
- "device.auto_shift.no_correction_between_notes": "aucune correction entre les notes",
- "device.auto_shift.no_note_held": "aucune note tenue",
- "device.auto_shift.note_the_voice_goes_to": "Note — la voix va à la dernière note tenue ; Scale — les notes tenues forment la gamme",
- "device.auto_shift.oct_lock_the_notes_own": "Oct lock — l’octave propre de la note (off = l’octave de la note la plus proche de la voix)",
- "device.auto_shift.out_of_scale": "hors gamme",
- "device.auto_shift.pick_a_track_in_from": "choisir une piste dans FROM",
- "device.auto_shift.pitch_bend_from_midi": "Pitch bend depuis le MIDI",
- "device.auto_shift.pitch_bend_from_midi_moves": "Pitch bend from MIDI — les passages d’une note à l’autre glissent via Glide s’ils restent dans Bend ; off = la cible saute",
- "device.auto_shift.preserve_formants_the_vowel_colour": "Preserve formants — la couleur des voyelles reste en place quand la hauteur bouge (off = elle suit la hauteur, comme une bande accélérée)",
- "device.auto_shift.range_the_largest_correction_a": "Range — la plus grande correction ; une note plus éloignée n’est ramenée que de cette valeur",
- "device.auto_shift.scale_chromatic_major_minor_pentatonic": "Scale — Chromatic, Major, Minor, Pentatonic (majeure ou mineure — cliquer à nouveau pour alterner) ou Custom (les notes ci-dessous)",
- "device.auto_shift.scale_the_notes_the_voice": "Scale — les notes vers lesquelles la voix est attirée",
- "device.auto_shift.sing_a_few_bars": "chanter quelques mesures",
- "device.auto_shift.skip_sibilants_s_sh_t": "Skip sibilants — s, ch, t et le souffle passent sans transposition, pour ne pas devenir métalliques",
- "device.auto_shift.source_sets_the_detection_range": "Source — définit la plage de détection pour un type de voix ou un instrument",
- "device.auto_shift.speed_how_fast_the_retune": "Speed — la vitesse du glissement de la correction (2 ms = hard tune)",
- "device.auto_shift.speed_how_fast_the_voice": "Speed — la vitesse à laquelle la voix suit la cible",
- "device.auto_shift.the_correction_now_up_or": "La correction actuelle — vers le haut ou le bas depuis le centre, pleine hauteur = 2 demi-tons",
- "device.auto_shift.the_detected_pitch_low_to": "La hauteur détectée, du grave à l’aigu sur la plage de détection (onglet Detect)",
- "device.auto_shift.the_detected_pitch_teal_dots": "La hauteur détectée (points turquoise) et la sortie corrigée (neutre) sur les deux dernières secondes, sur les voies de notes de la gamme ; la voie cible est allumée",
- "device.auto_shift.the_key_that_fits_what": "La tonalité qui correspond à ce qui a été chanté (profils de Krumhansl sur les ~16 dernières mesures), et la seconde. Learn la règle ; Auto la suit",
- "device.auto_shift.the_source_tracks_notes_neutral": "Les notes de la piste source (blocs neutres, accent pendant qu’elles sonnent) et la voix (turquoise) sur les deux dernières secondes — avec Key Source MIDI, la voix est attirée vers les notes",
- "device.auto_shift.what_the_detector_hears_now": "Ce que le détecteur entend en ce moment et la correction appliquée — ou, avec Key Source MIDI, la note vers laquelle la voix est attirée",
- "device.bass.cut_pitch_wheel": "→ coupure/hauteur · molette",
- "device.bass.mod_wheel_opens_the_lfo": "Mod wheel — ouvre le LFO sur la coupure",
- "device.bass.slide_into_a_note_played": "Glisser vers une note jouée par-dessus une note tenue, sans nouvelle attaque",
- "device.beat_repeat.capture_and_repeat": "Capturer et répéter",
- "device.beat_repeat.captured_sound_repeating": "Son capturé · répétition",
- "device.beat_repeat.chance_how_likely_each_interval": "Chance — la probabilité que chaque intervalle déclenche une répétition",
- "device.beat_repeat.each_repeat_lower_and_narrower": "chaque répétition plus basse et plus étroite",
- "device.beat_repeat.each_repeat_lower_same_band": "chaque répétition plus basse, même bande",
- "device.beat_repeat.filter_off_or_a_low": "Filter — Off, ou un passe-bas, passe-bande ou passe-haut sur les répétitions",
- "device.beat_repeat.freq_the_filters_frequency": "Freq — la fréquence du filtre",
- "device.beat_repeat.gate_how_long_the_burst": "Gate — la durée de la rafale, en seizièmes de l’intervalle",
- "device.beat_repeat.grid_the_length_of_the": "Grid — la durée de la tranche qui se répète",
- "device.beat_repeat.interval_how_often_it_rolls": "Interval — la fréquence à laquelle Chance est tiré",
- "device.beat_repeat.interval_how_often_it_rolls_2": "Interval — la fréquence à laquelle Chance est tiré : 1/8, 1/4, 1/2 note, ou toutes les 1, 2, 4 mesures",
- "device.beat_repeat.latch_the_repeat_button_stays": "Latch — le bouton Repeat reste actif après un clic au lieu de l’être seulement tant qu’il est tenu",
- "device.beat_repeat.mode_mix_the_repeats_play": "Mode — Mix : les répétitions jouent par-dessus le signal sec ; Insert : elles le remplacent pendant qu’elles jouent ; Gate : seule la rafale sonne",
- "device.beat_repeat.narrow_with_repeats": "Narrow with repeats",
- "device.beat_repeat.narrow_with_repeats_each_repeat": "Narrow with repeats — chaque répétition rétrécit la bande et la déplace avec la hauteur",
- "device.beat_repeat.offset_where_in_the_interval": "Offset — à quel endroit de l’intervalle il se déclenche, en seizièmes",
- "device.beat_repeat.pitch_decay_each_repeat_drops": "Pitch decay — chaque répétition descend plus bas, jusqu’à 6 demi-tons par répétition",
- "device.beat_repeat.pitch_the_repeats_transposed_12": "Pitch — les répétitions transposées, ±12 demi-tons",
- "device.beat_repeat.repeat_filter_off": "Repeat filter · off",
- "device.beat_repeat.repeat_filter_the_repeats_go": "Repeat filter — les répétitions passent par le filtre (onglet Filter)",
- "device.beat_repeat.repeat_repeat_the_current_slice": "Repeat — répète la tranche actuelle maintenant, tant qu’il est tenu (avec Latch : un clic pour activer, un clic pour arrêter)",
- "device.beat_repeat.reset_stop_the_repeat_and": "Reset — arrête la répétition et efface la ligne de temps et les vumètres",
- "device.beat_repeat.the_grid_holds_still": "la grille reste immobile",
- "device.beat_repeat.the_input_level": "Le niveau d’entrée",
- "device.beat_repeat.the_last_intervals_sound_teal": "Le son du dernier intervalle (turquoise) sur la grille : le gate à partir de l’offset est ombré et la tranche capturée est en laiton. Glisser latéralement la ligne d’offset ou la fin du gate ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.beat_repeat.the_repeat_filter_only_the": "Le filtre des répétitions — seules les répétitions le traversent. Plein : la première répétition ; turquoise en pointillés : une suivante quand la bande se resserre et suit la hauteur. Glisser le nœud pour la fréquence, un bord de bande pour la largeur ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.beat_repeat.the_repeats_level_after_pitch": "Le niveau des répétitions — après hauteur, filtre, déclin et volume",
- "device.beat_repeat.the_repeats_pass_unfiltered": "les répétitions passent sans filtre",
- "device.beat_repeat.the_same_on_every_repeat": "identique à chaque répétition",
- "device.beat_repeat.triplet_the_grid_in_triplets": "Triplet — la grille en triolets (un tiers plus court)",
- "device.beat_repeat.two_intervals_on_the_grid": "Deux intervalles sur la grille : chaque pas est le niveau de l’entrée — pâle quand il est sec, plein là où la tranche est capturée, plus pâle à chaque répétition au fil du déclin. Les repères en haut marquent où l’intervalle se déclenche.",
- "device.beat_repeat.variation_the_grid_floats_up": "Variation — la grille varie jusqu’à ce nombre de pas (double / moitié) à chaque déclenchement",
- "device.beat_repeat.what_the_repeater_is_doing": "Ce que fait le répéteur en ce moment — attendre l’intervalle, capturer la tranche, ou la répéter — et où en est le transport",
- "device.beat_repeat.width_the_band_in_octaves": "Width — la largeur de la bande en octaves (passe-bas et passe-haut : moins, c’est plus résonant)",
- "device.bypassed": "Contourné",
- "device.bypassed_click_to_enable": "Contourné — cliquer pour activer",
- "device.card.bypassed": "Contourné",
- "device.card.changed_since_you_loaded_choose": "Modifié depuis le chargement de {0} · choisir un préréglage",
- "device.card.choose_a_preset": "Choisir un préréglage",
- "device.card.init": "Init",
- "device.card.next_preset": "Préréglage suivant",
- "device.card.previous_preset": "Préréglage précédent",
- "device.card.value": "Valeur",
- "device.ceiling.auto_release_the_release_slows": "Auto release — le relâchement ralentit quand la réduction s’accentue (jusqu’à 5× à 7 dB), pour que les passages denses ne pompent pas",
- "device.ceiling.ceiling_the_output_never_goes": "Ceiling — la sortie ne le dépasse jamais (en dBTP avec True peak activé)",
- "device.ceiling.character_clean_transparent_the_fastest": "Character — Clean : transparent, l’attaque la plus rapide ; Punch : une attaque plus lente laisse passer le transitoire jusqu’à l’écrêtage ; Glue : un relâchement lent et un genou doux sous le plafond",
- "device.ceiling.delta_hear_what_it_removes": "Delta · entendre ce qui est retiré",
- "device.ceiling.delta_play_the_difference_between": "Delta — jouer la différence entre l’entrée et la sortie : ce que retire le limiteur",
- "device.ceiling.gain_how_hard_the_signal": "Gain — la force avec laquelle le signal est poussé vers le plafond",
- "device.ceiling.gain_reduction_0_24_db": "Réduction de gain, 0 … 24 dB",
- "device.ceiling.hearing_what_it_removes": "écoute de ce qui est retiré",
- "device.ceiling.integrated_loudness_since_the_last": "Volume intégré depuis le dernier Reset, avec gate (BS.1770), par rapport à Target",
- "device.ceiling.internal_this_track": "Interne — cette piste",
- "device.ceiling.key_source_internal_limits_on": "Key source — Internal limite selon les crêtes de cette piste ; choisir une autre piste pour ducker celle-ci quand l’autre atteint son pic",
- "device.ceiling.lets_the_attack_through": "laisse passer l’attaque",
- "device.ceiling.level_and_reduction": "Niveau et réduction",
- "device.ceiling.momentary_teal_short_term_neutral": "Volume momentané (turquoise), à court terme (neutre) et intégré (rose) sur les 60 dernières secondes autour de la cible, ±1 LU ombré. Glisser la ligne de cible ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.ceiling.release_how_fast_the_gain": "Release — la vitesse de retour du gain (le caractère la module ; Auto rel laisse le signal décider)",
- "device.ceiling.reset_peaks_clear_the_peak": "Reset peaks — efface les maintiens de crête, la réduction maximale et le compte d’écrêtages",
- "device.ceiling.reset_start_the_integrated_loudness": "Reset — relance le volume intégré, la plage et les crêtes",
- "device.ceiling.slow_and_dense": "lent et dense",
- "device.ceiling.target_the_loudness_the_meters": "Target — le volume auquel les vumètres se comparent : −14 pour le streaming, −16 pour les podcasts, −23 pour la diffusion. Cela ne change pas le son ; glisser la ligne en pointillés pour toute valeur",
- "device.ceiling.the_difference_in_out": "la différence entrée − sortie",
- "device.ceiling.the_gain_reduction_over_the": "La réduction de gain sur les 4 dernières secondes : turquoise là où un transitoire est passé jusqu’à l’écrêtage, la ligne en pointillés est la moyenne",
- "device.ceiling.the_input_after_gain_with": "L’entrée après Gain, avec le plafond marqué",
- "device.ceiling.the_last_4_s_the": "Les 4 dernières secondes : l’entrée (turquoise), la partie au-dessus du plafond (rouge) et la sortie (neutre), avec la réduction en dessous. Glisser la ligne du plafond ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.ceiling.true_peak_4": "true peak · 4×",
- "device.ceiling.true_peak_the_detector_reads": "True peak — le détecteur lit la crête inter-échantillons (4×), pour que le plafond tienne en dBTP après conversion",
- "device.ceiling.what_the_limiter_listens_to": "Ce qu’écoute le limiteur — ou, avec Delta activé, que l’on n’entend que ce qu’il retire",
- "device.chamber.algorithm_share_of_the_blend": "Part de l’algorithme dans le mélange (entraîne Blend)",
- "device.chamber.at_the_input_before_both": "à l’entrée, avant les deux moteurs",
- "device.chamber.at_the_output_dry_wet": "à la sortie, sec + traité",
- "device.chamber.blend_convolution_slate_top_algorithm": "Blend — convolution (ardoise, haut) ⇄ algorithme (neutre, bas). Double-clic : 50 / 50",
- "device.chamber.concert_hall_wide": "Concert Hall · Wide",
- "device.chamber.convolution_share_of_the_blend": "Part de la convolution dans le mélange (entraîne Blend)",
- "device.chamber.drag_a_marker_to_set": "Glisser un repère pour régler le RT60 de cette bande (mid = Decay ; low / high le suivent en rapports). Le potentiomètre Damping règle le crossover haut. · ⌥-clic pour saisir",
- "device.chamber.drag_the_trim_lines_to": "Glisser les lignes de découpe pour recadrer la réponse impulsionnelle (Start · Decay) ; ⌥-clic pour saisir, double-clic pour réinitialiser. Déposer un fichier audio ici pour le charger.",
- "device.chamber.drop_an_impulse_response_here": "Déposer une réponse impulsionnelle ici (WAV / FLAC / MP3) ou cliquer sur Load…",
- "device.chamber.dry_wet_double_click_resets": "Dry/Wet — double-clic pour réinitialiser",
- "device.chamber.ducking_the_wet_dips_up": "Ducking — le signal traité baisse (jusqu’à 24 dB) tant que l’entrée joue",
- "device.chamber.eco_ir_up_to_3": "Eco : réponse jusqu’à 3 s · Mid : 6 s · High : 10 s + modulation de l’algorithme interpolée en cubique",
- "device.chamber.feed_shimmer_back": "Réinjecter le shimmer",
- "device.chamber.freeze_hold_the_algorithm_tail": "Freeze — maintient la queue de l’algorithme indéfiniment ; l’entrée est coupée",
- "device.chamber.hold_in_keep_feeding_the": "Hold in — continue d’envoyer l’entrée dans la queue gelée (superposition)",
- "device.chamber.impulse_response_built_in_rooms": "Impulse response — pièces intégrées, ou votre propre fichier (le déposer sur la forme d’onde)",
- "device.chamber.left_handle_low_cut_x": "Poignée gauche : coupe-bas (X) + shelf grave (Y) · poignée droite : coupe-haut (X) + shelf aigu (Y) · ⌥-clic pour saisir",
- "device.chamber.load": "Charger…",
- "device.chamber.load_an_impulse_response_wav": "Charger une réponse impulsionnelle (WAV / FLAC / MP3 — mono, stéréo ou vrai stéréo 4 canaux)",
- "device.chamber.load_impulse_response": "Charger une réponse impulsionnelle…",
- "device.chamber.on_exact_convolution_timing_at": "On : timing de convolution exact à 0 ms de predelay (tête FIR, plus de CPU). Off : plus léger — le premier bloc arrive en retard et est absorbé dans le predelay.",
- "device.chamber.on_the_tail_before_dry": "sur la queue, avant Dry/Wet",
- "device.chamber.parallel_both_engines_hear_the": "Parallel : les deux moteurs entendent l’entrée · Serial : la convolution alimente l’algorithme",
- "device.chamber.shimmer_pitch_shift": "Shimmer · pitch shift",
- "device.chamber.shimmer_pitch_shift_caps": "Shimmer · pitch shift",
- "device.chamber.shimmer_shimmer_mode_only": "Shimmer · mode shimmer uniquement",
- "device.chamber.user_ir_none_loaded": "Réponse perso (aucune chargée)",
- "device.chamber.user_ir_none_loaded_2": "Réponse perso — aucune chargée",
- "device.chamber.wet_only_100_wet_no": "Wet only — 100 % traité, sans signal sec : pour une piste de retour / d’envoi",
- "device.chord.custom_your_own_shifts": "Custom : vos propres décalages",
- "device.chord.drop_added_notes_outside_a": "Ramener d’un demi-ton dans {0} les notes ajoutées hors de celle-ci",
- "device.chord.drop_added_notes_outside_the": "Ramener d’un demi-ton dans la gamme les notes ajoutées hors de celle-ci",
- "device.chord.fold_key_click_for_the": "Fold key — cliquer pour la suivante, Maj-clic pour la précédente",
- "device.chord.fold_scale_major_natural_minor": "Fold scale — majeure / mineure naturelle",
- "device.chord.in_voices": "En {0} · {1} · {2} voix",
- "device.chord.in_voices_strum_ms_spread": "En {0} · {1} · {2} voix · strum {3} ms · spread {4}",
- "device.chord.play_the_note_you_pressed": "Jouer la note appuyée en plus des notes ajoutées",
- "device.chord.set_the_shifts_to": "{0} : régler les décalages sur {1}",
- "device.chord.shift_drag_up_down_12": "Décalage {0} : glisser vers le haut / bas (±12 demi-tons) · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "device.chord.shift_on_off": "Décalage {0} activé / désactivé",
- "device.chord.shift_velocity_offset_drag_sideways": "Décalage de vélocité {0} — glisser latéralement, ⌥-clic pour saisir, double-clic pour réinitialiser",
- "device.chorus.amount_at_zero_the_voices": "Quantité à zéro : les voix restent immobiles, un ",
- "device.chorus.amount_how_far_the_lfo": "Amount — l’amplitude du LFO sur le retard de chaque voix : plus c’est grand, plus le désaccord est large",
- "device.chorus.chorus_bypassed_the_signal_passes": "Chorus contourné : le signal passe inchangé",
- "device.chorus.classic_two_voices_left_and": "Classic — deux voix, gauche et droite ; Ensemble — trois voix à 120°, un scintillement de string machine ; Vibrato — l’oscillation de hauteur seule, sans signal sec",
- "device.chorus.detune_up_to": "Désaccord jusqu’à ±",
- "device.chorus.draws_each_voices_delay_ct": "τ trace le retard de chaque voix ; ct son désaccord — de combien le retard mobile infléchit la hauteur",
- "device.chorus.each_voice_over_two_lfo": "Chaque voix sur deux cycles du LFO — son retard (τ) ou son désaccord (ct) — et sa position actuelle. Glisser vers le haut / bas pour Amount ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.chorus.feedback_the_voices_fed_back": "Feedback — les voix réinjectées dans la ligne, ±90 % : un peu épaissit, au-delà de 60 % le son devient métallique comme un flanger",
- "device.chorus.how_many_voices_sing_or": "Le nombre de voix qui chantent, ou le fait que le feedback le fait sonner (au-delà de 60 %), ou que Vibrato joue uniquement le signal traité",
- "device.chorus.hpf_a_high_pass_on": "HPF — un passe-haut sur l’entrée traitée (20 Hz … 2 kHz), pour que les graves restent secs et centrés ; tout à gauche, il est désactivé",
- "device.chorus.mix_0_dry_50_dry": "Mix — 0 % sec, 50 % sec et traité à égalité, 100 % les voix seules. Vibrato est toujours traité",
- "device.chorus.offset_the_right_voices_lfo": "Offset — le LFO de la voix droite en retard sur la gauche : 0° les fait bouger ensemble, 180° en opposition. Ensemble espace ses trois voix de 120° de lui-même",
- "device.chorus.rate_the_note_value_of": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/16 avec valeurs en triolets (T)",
- "device.chorus.the_largest_detune_the_sweep": "Le plus grand désaccord atteint par le balayage, ± cents (0 … 60 sur la barre)",
- "device.chorus.the_range_each_voices_delay": "La plage balayée par le retard de chaque voix, ms (0 … 24 sur la barre)",
- "device.chorus.vibrato_no_dry_signal_the": "Vibrato : pas de signal sec, la hauteur oscille de ±",
- "device.chorus.warmth_a_bucket_brigade_flavour": "Warmth — une saveur à capacités commutées sur la ligne à retard : plus sombre (passe-bas jusqu’à 2,5 kHz) et légèrement saturé",
- "device.chorus.where_the_voices_sit_in": "Où se placent les voix dans le champ stéréo (Width) et de combien chacune est désaccordée en ce moment",
- "device.chorus.width_0_the_voices_fold": "Width 0 % : les voix se replient en mono, sans espace",
- "device.chorus.width_the_voices_stereo_spread": "Width — l’étalement stéréo des voix : 0 % mono, 100 % tel quel, 200 % relève le side de +6 dB",
- "device.comp.no_key_signal": "aucun signal de clé",
- "device.compressor.auto_gain_make_up_that": "Auto gain — un gain de compensation qui suit le seuil et le ratio",
- "device.compressor.auto_release_a_slower_second": "Auto-release — un second relâchement plus lent quand la réduction est profonde, pour que le matériel soutenu ne pompe pas",
- "device.compressor.character_the_voicing_clean_as": "Character — le voicing : Clean tel que réglé, Glue plus lent et plus doux, Punch plus rapide, Opto lent et doux selon le programme, FET très rapide",
- "device.compressor.detector_peak_reacts_to_every": "Detector — Peak réagit à chaque transitoire, RMS au corps du son, Auto suit le corps tout en captant les pointes",
- "device.compressor.drag_sideways_for_the_threshold": "Glisser latéralement pour le seuil, vers le haut / bas pour le ratio. Double-clic pour réinitialiser les deux. Le point indique le niveau de la clé en ce moment.",
- "device.compressor.external_key_key_off_the": "External key — déclenche depuis la source choisie dans l’onglet Sidechain ; désactivé, la piste se déclenche elle-même",
- "device.compressor.gain_reduction_over_the_last": "Réduction de gain sur les quatre dernières secondes ; la ligne en pointillés est la crête. Cliquer pour l’effacer.",
- "device.compressor.key_audible_output_muted": "clé audible · sortie coupée",
- "device.compressor.key_gain_drives_the_detector": "Key gain — pousse le détecteur plus ou moins fort. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.compressor.key_source_internal_keys_off": "Key source — Internal se déclenche sur cette piste ; choisir une autre piste, ou l’un de ses pads ou chaînes, pour ducker ou pomper contre elle",
- "device.compressor.listen_hear_the_filtered_key": "Listen — écouter la clé filtrée au lieu de la sortie, pour régler HP / LP à l’oreille",
- "device.compressor.make_up_gain_click_types": "Gain de compensation. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.compressor.no_reduction_to_measure": "aucune réduction à mesurer",
- "device.compressor.stereo_link_one_reduction_for": "Stereo link — une seule réduction pour les deux canaux ; désactivé, gauche et droite compressent séparément",
- "device.compressor.the_keys_spectrum_under_its": "Le spectre de la clé sous ses filtres — glisser une poignée latéralement pour déplacer HP / LP, vers le haut / bas pour Q. ⌥-clic sur une poignée pour la saisir, double-clic pour l’ouvrir.",
- "device.compressor.the_reduction_neutral_ink_hanging": "La réduction (neutre, suspendue à 0 dB) face au niveau d’entrée (turquoise) — l’attaque est la descente, le relâchement la remontée. La ligne en pointillés est le seuil.",
- "device.compressor.threshold_the_tick_is_the": "Threshold — le repère indique le niveau de la clé en ce moment. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.compressor.where_the_source_is_tapped": "Où la source est prélevée : avant ses effets et son fader, ou après — pour un pad ou une chaîne, avant ses propres effets, ou après eux et son niveau",
- "device.consort.a_cable_breaks_the_normal": "Un câble coupe la connexion normalisée sur Gate / Filt in / VCA in / Ext in · les boucles tournent avec un échantillon de retard",
- "device.consort.all_normals_intact": "toutes les connexions normalisées intactes",
- "device.consort.analog_delay_bbd": "Delay analogique · BBD",
- "device.consort.attenuators_scale_whatever_is_patched": "Les atténuateurs mettent à l’échelle ce qui est branché sur Atten 1/2 in ; Sum additionne ses entrées",
- "device.consort.cables": { "one": "{0} câble", "other": "{0} câbles" },
- "device.consort.cables_points": "{0} câbles · {1} points",
- "device.consort.clock_out_patch_bay": "Clock out (patch bay)",
- "device.consort.depth": "{0} · depth {1:+0;−0;0}",
- "device.consort.depth_drag_up_down_click": "Depth — glisser vers le haut / bas (⌥-clic pour saisir, double-clic : +50)",
- "device.consort.drag_jack_to_jack_alt": "Glisser de prise à prise · Alt-clic pour retirer · clic droit pour une liste",
- "device.consort.ext_normalled_to_the_vca": "EXT : normalisé sur la sortie du VCA (réinjection façon Moog) — brancher Ext in pour le remplacer",
- "device.consort.filt_1_cutoff_input": "Entrée de coupure Filt 1",
- "device.consort.filt_2_cutoff_input": "Entrée de coupure Filt 2",
- "device.consort.gated_glide_only_between_overlapping": "Glide conditionnel : seulement entre notes qui se chevauchent (legato)",
- "device.consort.jack_strip_points": "Bandeau de prises · {0} points · ",
- "device.consort.lfo_out_patch_bay": "LFO out (patch bay)",
- "device.consort.lfo_pitch_all_oscillators_or": "LFO pitch → tous les oscillateurs, ou seulement 2 et 4",
- "device.consort.lfo_rate_input_patch_bay": "Entrée de vitesse LFO (patch bay)",
- "device.consort.matrix_view_drag_a_cell": "Vue matrice · glisser une cellule pour la profondeur, ⌥-clic pour la saisir, double-clic pour supprimer · ",
- "device.consort.off_seq_steps_transposed_by": "Off · SEQ (pas transposés par la touche) · ARP (l’accord tenu sur 1 à 3 octaves)",
- "device.consort.open_the_full_patch_bay": "Ouvrir le patch bay complet (les 42 points) · dans l’onglet Patch : retour au dernier panneau",
- "device.consort.os_0_smp_cpu": "{0} · ×{1} OS · 0 éch. · CPU {2:0} %",
- "device.consort.osc_pitch_input_patch_bay": "Entrée de hauteur Osc {0} (patch bay)",
- "device.consort.oscillator_s_note_paraphonic_the": "Note de l’oscillateur {0} (paraphonique) · les dernières voix en vrai poly",
- "device.consort.paint_steps_alt_click_a": "Peindre {0} pas (Alt-clic sur un pas : silence)",
- "device.consort.pitch_arp_step_types_shape": "Hauteur · arp (les types de pas façonnent le rythme)",
- "device.consort.pitch_step_offsets_from_the": "Hauteur · décalages des pas par rapport à la touche",
- "device.consort.pulse_width_of_the_pulse": "Largeur d’impulsion de l’onde pulse (le carré reste à 50 %)",
- "device.consort.ratchet_repeats_per_step": "Répétitions de ratchet par pas",
- "device.consort.remove": "Retirer {0} {1:+0;−0;0}",
- "device.consort.seq_gate_out_patch_bay": "Seq gate out (patch bay)",
- "device.consort.sequence_length_drag_up_down": "Longueur de la séquence — glisser vers le haut / bas",
- "device.consort.sequencer_off_pick_seq_or": "Séquenceur désactivé · choisir SEQ ou ARP, puis tenir une touche",
- "device.consort.step_rate_synced_to_the": "Vitesse des pas (synchronisée au tempo de l’hôte)",
- "device.consort.sync_to_host_bpm_cpu": "{0} · synchro à l’hôte {1:0} BPM · CPU {2:0} %",
- "device.consort.true_poly_16": "Vrai poly (16)",
- "device.crush.anti_alias_a_4th_order": "Anti-alias — un passe-bas d’ordre 4 à la fréquence de Nyquist du taux réduit avant le maintien, pour réduire le repliement en images",
- "device.crush.auto_gain_rides_the_output": "Auto gain — ramène la sortie au volume de l’entrée (RMS 300 ms, ±24 dB), pour que Bits ou Drive ne fassent pas sauter le niveau",
- "device.crush.bits_the_bit_depth_1": "Bits — la profondeur de bits, 1 … 24 : moins de bits, moins de niveaux, plus de grain",
- "device.crush.dc_filter_a_10_hz": "DC filter — un passe-haut à 10 Hz sur le signal écrasé : retire le décalage continu que peut laisser un crush grossier, replié ou bruité",
- "device.crush.dither_up_to_lsb_of": "Dither — jusqu’à ±½ LSB de bruit triangulaire avant les niveaux : adoucit les marches en souffle",
- "device.crush.drive_12_24_db_into": "Drive — −12 … +24 dB dans le crusher : pousse le signal vers les niveaux supérieurs, dans l’écrêtage Analog ou vers davantage de repliements",
- "device.crush.input_output_through_drive_the": "Entrée → sortie à travers Drive, le mode et les niveaux ; le point marque la crête du signal. Glisser vers le haut / bas pour Drive ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.crush.jitter_the_hold_length_wanders": "Jitter — la durée du maintien varie jusqu’à ±50 % : une horloge instable, irrégulière",
- "device.crush.level_step_shown_enlarged": "pas de niveau affiché agrandi",
- "device.crush.levels_after_the_fold": " niveaux après le pli",
- "device.crush.mode_digital_hard_truncation_to": "Mode — Digital : troncature dure aux niveaux ; Analog : un écrêtage tanh doux avant eux (+4 dB, plus rond) ; Fold : un wavefolder — plus de Drive replie les crêtes plus souvent",
- "device.crush.noise_a_white_noise_floor": "Noise — un plancher de bruit blanc sous le crush, jusqu’à −50 dBFS",
- "device.crush.output_gain_12_db": "Gain de sortie, ±12 dB",
- "device.crush.peaks_in_and_out_and": "Crêtes en entrée et en sortie, et facteur de crête de la sortie (crête sur RMS) — le crush l’aplatit",
- "device.crush.post_filter_a_low_pass": "Post filter — un passe-bas après le crush, 200 Hz … 20 kHz : sous Nyquist, il lisse les marches",
- "device.crush.rate_the_reduced_sample_rate": "Rate — la fréquence d’échantillonnage réduite, 500 Hz … pleine : plus bas, chaque valeur est tenue plus longtemps et des images apparaissent au-dessus de sa fréquence de Nyquist",
- "device.crush.the_filter_cuts_the_images": "le filtre coupe les images",
- "device.crush.the_input_peak_60_0": "La crête d’entrée, −60 … 0 dBFS",
- "device.crush.the_output_peak_60_0": "La crête de sortie, −60 … 0 dBFS",
- "device.crush.the_output_spectrum_neutral_ink": "Le spectre de sortie : le neutre est le signal, le turquoise ce qu’a ajouté le crush — vif au-dessus du Nyquist réduit (les images). Glisser la ligne de Nyquist pour Rate, la ligne du filtre pour le post filter ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.crush.two_cycles_of_a_sine": "Deux cycles d’une sinusoïde au niveau d’attaque (pointillés) et ce qui en sort",
- "device.crush.wet_the_crushed_signal_against": "Wet — le signal écrasé face au signal sec",
- "device.crush.what_comes_out_the_bit": "Ce qui sort : la profondeur de bits et la fréquence, et si le post filter coupe les images au-dessus du Nyquist réduit ou les laisse passer",
- "device.delay.clear_loop": "Effacer la boucle",
- "device.delay.empty_the_delay_buffer_silences": "Vider le tampon de delay — coupe ce qui circule encore",
- "device.delay.fade_on_change_crossfade_to": "Fade on change — fondu enchaîné vers le nouveau temps de delay au lieu d’y glisser (ce qui modifie la hauteur, façon bande)",
- "device.delay.feedback_how_much_of_each": "Feedback — la part de chaque répétition qui repart pour un tour ; Freeze la bloque à 100 %. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.delay.freeze_hold_the_loop_forever": "Freeze — maintient la boucle indéfiniment ; l’entrée est coupée et les répétitions cessent de décroître",
- "device.delay.latency_comp": "Comp. de latence",
- "device.delay.link_l_r_the_right": "Link L/R — le canal droit suit le temps du gauche",
- "device.delay.loop_held_no_decay": "Boucle maintenue · sans déclin",
- "device.delay.ping_pong_each_repeat_crosses": "Ping-pong — chaque répétition passe sur l’autre canal",
- "device.delay.spread_pushes_the_right_channel": "Spread — retarde le canal droit, jusqu’à 50 ms. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.delay.tap_four_times_to_set": "Taper quatre fois pour régler le temps de delay à l’oreille (passe en ms libres)",
- "device.delay.tap_tempo": "Tap tempo",
- "device.delay.the_band_the_repeats_live": "La bande dans laquelle vivent les répétitions — glisser la poignée gauche pour le coupe-bas, la droite pour le coupe-haut. ⌥-clic sur une poignée pour la saisir, double-clic pour l’ouvrir.",
- "device.delay.the_diffuser_lengthens_the_loop": "Le diffuseur allonge la boucle d’un retard de groupe fixe ; activé, le pointeur de lecture est reculé d’autant pour que chaque répétition tombe sur le temps réglé.",
- "device.delay.the_repeat_train_l_above": "Le train de répétitions — L au-dessus de l’axe, R en dessous. La hauteur est le niveau restant après chaque passage ; la répétition qui sonne en ce moment est allumée.",
- "device.delay.wet_only_repeats_with_no": "Wet only — répétitions sans signal sec, pour une piste de retour / d’envoi",
- "device.dynamic_eq.attack_how_fast_the_band": "Attack — la vitesse à laquelle la bande rejoint sa plage",
- "device.dynamic_eq.band_on": "Bande active",
- "device.dynamic_eq.band_on_off_leaves_the": "Bande active — désactivée, elle sort du signal (double-clic sur son nœud pour le même effet)",
- "device.dynamic_eq.drag_a_node_frequency_and": "Glisser un nœud — fréquence et gain · molette sur un nœud — Q · double-clic sur un nœud — bande active / inactive · ",
- "device.dynamic_eq.duck_acts_above_the_threshold": "Duck — agit au-dessus du seuil",
- "device.dynamic_eq.dynamic_off_parks_every_band": "Dynamic — désactivé, chaque bande reste sur son gain statique : pour entendre ce que font les dynamiques",
- "device.dynamic_eq.flip_cut_boost_a_duck": "Flip — atténuation ↔ renfort (un Duck qui renforce est une expansion ascendante, un Lift qui atténue est une expansion descendante)",
- "device.dynamic_eq.frequency_or_drag_the_node": "Fréquence — ou glisser le nœud à gauche / droite",
- "device.dynamic_eq.gain_the_static_gain_or": "Gain — le gain statique ; ou glisser le nœud vers le haut / bas",
- "device.dynamic_eq.key_self_the_band_listens": "Key — Self : la bande écoute cette piste · Ext : la piste de clé (cliquer à nouveau sur Ext pour choisir la piste)",
- "device.dynamic_eq.lift_acts_as_it_falls": "Lift — agit quand le signal passe en dessous (un renfort par défaut)",
- "device.dynamic_eq.lift_acts_below_the_threshold": "Lift — agit sous le seuil",
- "device.dynamic_eq.output_drag_up_down_shift": "Output — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour 0 dB",
- "device.dynamic_eq.q_the_width_the_resonance": "Q — la largeur (la résonance sur les coupes) ; ou la molette sur le nœud",
- "device.dynamic_eq.range_how_far_the_gain": "Range — l’amplitude du gain à plein engagement (6 dB au-delà du seuil) ; cliquer la flèche pour inverser atténuation / renfort",
- "device.dynamic_eq.release_how_fast_it_returns": "Release — la vitesse de retour à son gain statique",
- "device.dynamic_eq.solo_hear_this_band_alone": "Solo — entendre cette bande seule",
- "device.dynamic_eq.static_a_plain_eq_band": "Static — une bande d’EQ simple · Duck — agit quand le niveau de la bande dépasse le seuil (une atténuation par défaut) · ",
- "device.dynamic_eq.the_selected_bands_dynamic_gain": "Le gain dynamique de la bande sélectionnée en ce moment",
- "device.dynamic_eq.threshold_where_the_band_starts": "Threshold — le point où la bande commence à agir ; le repère turquoise est le niveau actuel de la bande",
- "device.dynamic_eq.type_high_pass_low_shelf": "Type — passe-haut, low shelf, bell, notch, high shelf, passe-bas ; seuls les shelves et les bells acceptent gain et dynamique",
- "device.eq.analyzer_pre_the_input_spectrum": "Analyseur — Pre : le spectre d’entrée · Post : la sortie au-dessus d’une entrée plus discrète · Off",
- "device.eq.analyzer_range_the_graphs_bottom": "Plage de l’analyseur — le bord inférieur du graphique, en dB sous 0 dBFS",
- "device.eq.auto_gain_adds_the_opposite": "Auto gain — ajoute l’opposé du niveau moyen des shelves et des bells, pour juger les modifications à volume égal",
- "device.eq.band_on_off_leaves_the": "Bande active — désactivée, elle sort du signal (double-clic sur son nœud pour le même effet)",
- "device.eq.channel_st_both_channels_mid": "Channel — St : les deux canaux · Mid : le centre · Side : les bords · L / R : un seul canal",
- "device.eq.drag_a_node_frequency_and": "Glisser un nœud — fréquence et gain · molette sur un nœud — Q · double-clic sur un nœud — bande active / inactive · ",
- "device.eq.enter_or_esc_to_close": "Entrée ou Échap pour fermer",
- "device.eq.frequency_or_drag_the_node": "Fréquence — ou glisser le nœud à gauche / droite",
- "device.eq.gain_or_drag_the_node": "Gain — ou glisser le nœud vers le haut / bas (Scale le multiplie)",
- "device.eq.label_a_short_name_shown": "Label — un nom court affiché près du nœud de la bande (jusqu’à 24 caractères)",
- "device.eq.labels_show_the_bands_labels": "Labels — affiche les étiquettes et repères de note des bandes dans le graphique (les pastilles et le panneau de bande les conservent)",
- "device.eq.name_this_band": "Nommer cette bande",
- "device.eq.note_a_longer_note_on": "Note — une note plus longue sur le rôle de cette bande",
- "device.eq.output_plus_the_auto_gain": "Output (plus l’auto gain en vigueur) — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour 0 dB",
- "device.eq.output_the_level_after_the": "Output — le niveau après l’EQ, ±12 dB",
- "device.eq.peak_hold_a_thin_line": "Peak hold — une ligne fine au niveau le plus haut de chaque fréquence ces derniers instants",
- "device.eq.q_the_width_the_resonance": "Q — la largeur (la résonance sur les coupes) ; ou la molette sur le nœud",
- "device.eq.scale_multiplies_every_shelf_and": "Scale — multiplie le gain de chaque shelf et bell : 100 % tel que réglé, 0 % à plat, 200 % le double",
- "device.eq.slope_how_steep_the_high": "Slope — la raideur du passe-haut / passe-bas : 12, 24 ou 48 dB par octave",
- "device.eq.type_high_pass_low_shelf": "Type — passe-haut, low shelf, bell, notch, high shelf, passe-bas ; seuls les shelves et les bells acceptent un gain",
- "device.eq.what_this_band_is_for": "À quoi sert cette bande",
- "device.eq3.crossover_slope_linkwitz_riley_24": "Crossover slope — Linkwitz-Riley 24 ou 48 dB/oct : plus raide, moins d’effet sur les bandes voisines",
- "device.eq3.drag_up_down_for_the": "Glisser vers le haut / bas pour le gain de la bande (Maj pour les pas fins) ; ⌥-clic pour le saisir ; double-clic pour revenir à 0 dB et lever le kill",
- "device.eq3.each_band_in_its_colour": "Chaque bande dans sa couleur, la somme en laiton, le spectre de sortie derrière. Glisser une poignée de crossover à gauche / droite ; glisser ailleurs pour régler le gain de cette bande. Double-clic pour réinitialiser, ⌥-clic pour saisir.",
- "device.eq3.kill_the_band_removes_it": "Kill de la bande {0} — la supprime d’un coup, avec un glissement de 5 ms",
- "device.eq3.low_mid_crossover": "Crossover grave / médium",
- "device.eq3.mid_high_crossover": "Crossover médium / aigu",
- "device.eq3.output_gain_24_db_drag": "Gain de sortie, ±24 dB — glisser vers le haut / bas (Maj pour les pas fins), ⌥-clic pour saisir, double-clic pour réinitialiser",
- "device.eq8.band_on": "Bande active",
- "device.flanger.delay_the_centre_of_the": "Delay — le centre du balayage, 0,1 … 8 ms : plus court, les encoches montent",
- "device.flanger.depth_at_zero_the_comb": "Depth à zéro : le peigne reste immobile, un effet statique",
- "device.flanger.depth_how_far_the_lfo": "Depth — l’amplitude du LFO sur le retard autour de son centre",
- "device.flanger.feedback_0_a_plain_comb": "Feedback 0 : un simple peigne",
- "device.flanger.feedback_70_hollow": "Feedback −70 % : creux",
- "device.flanger.feedback_70_the_classic_jet": "Feedback +70 % : le jet classique",
- "device.flanger.feedback_the_delayed_signal_fed": "Feedback — le signal retardé réinjecté, ±95 % : positif pour le jet classique, négatif pour un timbre creux",
- "device.flanger.flanger_bypassed_the_signal_passes": "Flanger contourné : le signal passe inchangé",
- "device.flanger.how_deep_the_notches_cut": "Profondeur des encoches, dB (0 … −36 sur la barre)",
- "device.flanger.mix_50_gives_the_deepest": "Mix — 50 % donne les encoches les plus profondes ; 100 % est le signal retardé seul, un vibrato",
- "device.flanger.rate_the_note_value_of": "Rate — la valeur de note d’un cycle de LFO, 2/1 … 1/16 avec valeurs pointées (D) et en triolets (T)",
- "device.flanger.stereo_the_right_lfo_against": "Stereo — le LFO droit par rapport au gauche : 0° balaie les deux ensemble, 90° les écarte, 180° les fait évoluer en opposition",
- "device.flanger.the_comb_the_delay_carves": "Le peigne que le delay creuse dans le spectre, L neutre et R turquoise, avec la première encoche en pointillés. Glisser à gauche / droite pour déplacer l’encoche (Delay), vers le haut / bas pour Feedback ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
- "device.flanger.the_delay_of_both_channels": "Le retard τ des deux canaux sur deux cycles du LFO, et la position actuelle de chacun",
- "device.flanger.the_first_notch_now_over": "La première encoche actuelle, sur la plage où le balayage la déplace (20 Hz … 20 kHz)",
- "device.flanger.the_lfo_shape_that_sweeps": "La forme du LFO qui balaie le delay : Sine glisse, Tri balaie régulièrement, Saw monte puis retombe",
- "device.flanger.what_the_feedback_makes_positive": "Effet du feedback : positif, il affine les pics ; négatif, il creuse le timbre ; au-delà de 85 %, le peigne accroche",
- "device.flux.assign_a_source_to_turn": "→ assigner une source pour activer la réaction",
- "device.flux.choose_the_track_flux_listens": "Choisir la piste écoutée par Flux — ou l’un de ses pads, chaînes ou voix",
- "device.flux.click_to_change_the_motion": "Cliquer pour changer la valeur de synchro de Motion",
- "device.flux.cutoff_of_range": "coupure +{0} de la plage",
- "device.flux.dashed_where_the_reaction_pulls": "pointillés — où tire la réaction",
- "device.flux.drag_to_blend_the_four": "Glisser pour mélanger les quatre timbres · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "device.flux.one_knob_each": "un potentiomètre chacun",
- "device.flux.target_what_the_reaction_drives": "Target — ce que pilote la réaction",
- "device.flux.the_sidechain_bends_the_pitch": "→ le sidechain fait monter la hauteur",
- "device.flux.the_sidechain_drags_the_vector": "→ le sidechain entraîne le vecteur en rythme",
- "device.flux.the_sidechain_opens_the_filter": "→ le sidechain ouvre le filtre",
- "device.flux.the_sidechain_swells_the_space": "→ le sidechain gonfle l’espace",
- "device.flux.the_synth_listens_to_a": "le synthé écoute une piste",
- "device.flux.transients_per_bar": { "one": "{0} transitoire par mesure", "other": "{0} transitoires par mesure" },
- "device.flux_react.no_source_assigned": "aucune source assignée",
- "device.forge.amount_0_30_db_into": "Amount — 0 … +30 dB dans les étages. Glisser la courbe vers le haut / bas pour la même chose",
- "device.forge.bias_the_stages_asymmetry_100": "Bias — l’asymétrie de l’étage, −100 … +100 % : décale la courbe du centre et ajoute des harmoniques paires",
- "device.forge.digital_fold_without_oversampling_alias": "Digital / Fold sans suréchantillonnage produisent de l’aliasing : activer 2× ou plus",
- "device.forge.env_tone": "env → tone {0}",
- "device.forge.env_tone_loud_parts_push": "Env → Tone — les passages forts rendent le timbre plus brillant",
- "device.forge.harmonics_2_9_of_a": "Harmoniques 2 … 9 d’une sinusoïde à −6 dB passée dans la courbe : impaires en plein (dures, bourdonnantes), paires plus discrètes (chaudes, rondes), et la distorsion harmonique totale",
- "device.forge.input_output_through_the_device": "Entrée → sortie à travers l’appareil (en M/S et Multi, à travers l’étage sélectionné) : chaque étage seul en pâle, la courbe modulée par le LFO en turquoise pointillé, le nœud là où se situe l’entrée. Glisser vers le haut / bas pour Amount ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.forge.lfo_drive_the_lfo_sweeps": "LFO → Drive — le LFO balaie le drive de chaque étage, jusqu’à ±30 %",
- "device.forge.lfo_rate_free_0_05": "LFO rate — libre 0,05 … 20 Hz, ou avec Sync une division de 2 mesures à 1/64",
- "device.forge.of_3_stages": "{0} étages sur 3",
- "device.forge.output_24_24_db": "Sortie, −24 … +24 dB",
- "device.forge.oversampling_runs_the_stages_at": "Oversampling — fait tourner les étages à 2 / 4 / 8 × la fréquence pour que les harmoniques au-delà de Nyquist ne se replient pas (phase minimale, sans latence)",
- "device.forge.routing_serial_1_2_3": "Routing — Serial : 1 → 2 → 3. Parallel : les trois depuis la même entrée, moyennés. M/S : l’étage 1 traite le Mid, l’étage 2 le Side, l’étage 3 le stéréo recombiné. Multi : l’étage 1 les graves (< 180 Hz), le 2 les médiums, le 3 les aigus (> 2,4 kHz)",
- "device.forge.stage": "étage {0} · {1}",
- "device.forge.stage_drive_how_hard_the": "Drive de l’étage {0} — la force avec laquelle l’étage est poussé (gain 1 … ×21, niveau compensé)",
- "device.forge.stage_feedback_its_output_back": "Feedback de l’étage {0} — sa sortie réinjectée dans son entrée (0 … 85 %) : plus épais, et à la limite de l’accrochage avec Fold / Fuzz",
- "device.forge.stage_on_off": "Étage {0} activé / désactivé",
- "device.forge.stage_output_12_12_db": "Sortie de l’étage {0}, −12 … +12 dB — glisser vers le haut / bas, ⌥-clic pour saisir, double-clic pour réinitialiser",
- "device.forge.sync_the_lfo_rate_as": "Sync — la vitesse du LFO en valeur de note calée sur le morceau, ou libre en Hz",
- "device.forge.the_selected_stages_type_tube": "Le type de l’étage sélectionné — Tube : doux, asymétrique, chaud ; Tape : doux et régulier ; Diode : dur d’un côté ; Fuzz : carré, dense ; Fold : replie les crêtes, brillant et métallique ; Digital : un écrêtage dur",
- "device.forge.tone_a_tilt_after_the": "Tone — une inclinaison après l’étage, −12 … +12 dB autour de 800 Hz : distorsion plus sombre ou plus brillante",
- "device.forge.wet_the_forged_signal_against": "Wet — le signal forgé face au signal sec",
- "device.forge.what_the_device_is_doing": "Ce que fait l’appareil ; les décalages généraux Tone / Bias / Width des anciens projets s’affichent ici lorsqu’ils sont réglés",
- "device.forge.width_the_stages_stereo_image": "Width — l’image stéréo de l’étage, 0 … 200 % (en M/S, la largeur de l’étage 2 met à l’échelle le side)",
- "device.generic.open_gui": "Ouvrir l’interface ↗",
- "device.grain.blend_the_sample_itself_dry": "Mélange l’échantillon lui-même (sec) avec le nuage de grains (traité)",
- "device.grain.drag_to_move_the_read": "Glisser pour déplacer la position de lecture · ⌥-clic pour la saisir · double-clic pour la réinitialiser",
- "device.grain.position_pitch_pan": "{0} · position · hauteur · panoramique",
- "device.grain.root_a_semitone_down": "Fondamentale un demi-ton plus bas",
- "device.grain.root_a_semitone_up": "Fondamentale un demi-ton plus haut",
- "device.grain.root_plays_the_sample_as": "La fondamentale {0} joue l’échantillon tel qu’enregistré · coarse 0 · fine 0",
- "device.grain.scan_moves_through_the_file": "Scan parcourt le fichier · Freeze maintient Position · Key la déplace avec la note",
- "device.grain.the_root_the_key_that": "La fondamentale — la touche qui joue l’échantillon tel qu’enregistré. Défiler pour la changer · double-clic la prend dans le nom du fichier (C4 à défaut)",
- "device.grain.voices_grains_caps": "{0} {1}{2} · {3} voix · {4} grains",
- "device.keys.2_lines_bbd": "2 lignes · BBD",
- "device.keys.held_by_the_pedal": "{0} tenues par la pédale",
- "device.keys.ringing_out": "{0} en fin de résonance",
- "device.keys.string_2_pickups": "Corde · 2 micros",
- "device.keys.sustain_pedal_click_to_hold": "Pédale de sustain — cliquer pour la maintenir enfoncée ; le CC64 d’un clavier fonctionne aussi",
- "device.keys.voices": "{0} / {1} voix",
- "device.keys.voices_n": "{0} · {1} voix",
- "device.length.1_bar_at_bpm_notes": "1 mesure à {0:0} BPM · {1} notes",
- "device.length.clip_length_limit": "Limite de durée du clip",
- "device.length.count_the_length_from_the": "Compter la durée depuis le note-on ou le note-off — cliquer pour basculer",
- "device.length.count_the_length_from_the_2": "Compter la durée depuis le note-on, ou depuis le note-off (la note part au relâchement de la touche)",
- "device.length.drag_up_down_double_click": "{0} — glisser vers le haut / bas, double-clic pour réinitialiser",
- "device.length.each_note_lasts_until_the": "Chaque note dure jusqu’au début de la suivante (au plus jusqu’à la barre de mesure)",
- "device.length.from_avg_out": "{0} {1} · depuis {2} · sortie moy. {3}",
- "device.length.legato_retrigger_held": "Legato · redéclenchement des notes tenues",
- "device.length.length_drag_up_down_double": "Length — glisser vers le haut / bas, double-clic pour réinitialiser",
- "device.length.length_mode_sync_ms_gate": "Mode de durée : Sync / ms / Gate % — cliquer pour le suivant, Maj-clic pour le précédent",
- "device.length.loud_notes_longer_at": "notes fortes plus longues à +",
- "device.length.low_notes_longer_at": "notes graves plus longues à +",
- "device.length.no_note_crosses_the_bar": "Aucune note ne franchit la barre de mesure où elle a commencé",
- "device.length.outline_in_fill_out_band": "Contour — entrée · aplat — sortie · bande — plage de Random",
- "device.length.outline_the_note_played_in": "Contour — la note jouée en entrée · aplat — la note en sortie · bande — la plage sur laquelle Random la répartit. La partie ombrée dépasse la barre de mesure.",
- "device.length.spread_per_note": "dispersion par note",
- "device.length.sync_a_tempo_division_ms": "Sync : une division du tempo · ms : un temps fixe · Gate % : une part de la durée de tenue de chaque note",
- "device.lens.arm_the_next_single_capture": "Armer la prochaine capture Single",
- "device.lens.crest_db_lufs": "crête {0:0.0} dB · LUFS {1:0.0}",
- "device.lens.db_bin": "{0:0.0} dB · bin {1:0}",
- "device.lens.export_the_lens_capture_to": "Exporter la capture de Lens en WAV",
- "device.lens.export_wav": "Exporter en WAV",
- "device.lens.freeze_stop_capturing_and_hold": "Freeze — arrête la capture et conserve ce qui est à l’écran",
- "device.lens.key_draw_another_tracks_audio": "Key — superposer en turquoise l’audio d’une autre piste à celui-ci",
- "device.lens.key_gain_scales_only_the": "Key gain — ne met à l’échelle que la trace de la clé, pour l’œil (le son n’est pas modifié)",
- "device.lens.level_holdoff_ms": "niveau {0:0.00} · holdoff {1:0} ms",
- "device.lens.mid_side": "Mid / Side",
- "device.lens.move_over_the_graph": "survoler le graphique",
- "device.lens.n_a_in_a_rack": "indisponible dans un rack",
- "device.lens.open_lens_in_its_own": "Ouvrir Lens dans sa propre fenêtre",
- "device.lens.peak_db": "crête {0} · {1:0.0} dB",
- "device.lens.period_ms_hz": "période {0:0.000} ms · {1:0.0} Hz",
- "device.lens.row_ms_bins": "ligne {0:0} ms · {1} bins",
- "device.lens.show_the_keys_trace": "Afficher la trace de la clé",
- "device.lens.snap_to_peaks": "Caler sur les crêtes",
- "device.lens.span_how_much_of_the": "Span — la portion du morceau affichée par l’oscilloscope, d’un quart de temps à quatre mesures",
- "device.lens.sync_line_the_scope_up": "Sync — aligne l’oscilloscope sur les temps et les mesures du morceau",
- "device.lens.vpp_rms": "Vpp {0:0.000} · RMS {1:0.000}",
- "device.lens.waterfall_bins_overlap_window_s": "Waterfall · {0} bins · {1} · overlap {2:0.#} % · fenêtre {3:0} s · plancher {4:0} dB",
- "device.lens.window_ms_slope_db_oct": "fenêtre {0:0} ms · pente {1:0.0} dB/oct",
- "device.lens.write_the_captured_scope_window": "Écrire la fenêtre d’oscilloscope capturée dans un fichier WAV",
- "device.midi.card_size_s_mini_l": "Taille de la carte : S (mini) / L (complète)",
- "device.midi.map_a_hardware_control_arm": "Assigner une commande matérielle : armer, toucher une commande sur la carte, bouger un potentiomètre ou une touche",
- "device.monolith.controllers_osc_bank": "Controllers · Osc Bank",
- "device.mosaic.a_folder_of_samples": "un dossier d’échantillons",
- "device.mosaic.a_new_empty_layer_move": "Une nouvelle couche vide — y déplacer des zones depuis le rail",
- "device.mosaic.blends_the_loops_end_into": "Fond la fin de la boucle dans son début (boucles avant)",
- "device.mosaic.busy_on_pedal_release": "{0} occupées · {1} sur pédale · {2} en relâchement",
- "device.mosaic.click_a_key_to_make": "Cliquer une touche pour en faire la fondamentale de la zone sélectionnée",
- "device.mosaic.detect_from_file_name": "Détecter d’après le nom du fichier",
- "device.mosaic.drag_left_right_for_the": "Glisser : gauche / droite pour la coupure, haut / bas pour la résonance · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "device.mosaic.drag_the_nodes_attack_decay": "Glisser les nœuds : attaque, déclin et maintien (haut / bas), relâchement · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "device.mosaic.drop_samples_or_a_folder": "Déposer des échantillons ou un dossier ici · ou choisir un préréglage",
- "device.mosaic.edit_this_zones_start_end": "Modifier le début, la fin et la boucle de cette zone",
- "device.mosaic.empty": "Vide",
- "device.mosaic.empty_drop_samples_or_a": "Vide · déposer des échantillons ou un dossier, ou choisir un préréglage",
- "device.mosaic.exclusive_group_off_by": "Exclusive · groupe / coupé par",
- "device.mosaic.exclusive_is_for_hi_hats": "Exclusive sert aux charleys et aux valves : une nouvelle note coupe le groupe off_by.",
- "device.mosaic.files": "{0} / {1} · {2} / {3} fichiers",
- "device.mosaic.files_n": { "one": "{0} fichier", "other": "{0} fichiers" },
- "device.mosaic.filter_off_the_samples_pass": "Filtre désactivé — les échantillons passent intacts",
- "device.mosaic.fine_tune_of_the_whole": "Accord fin de tout l’instrument, ±50 cents",
- "device.mosaic.found_by_name": "{0} · {1} trouvés par le nom : {2}",
- "device.mosaic.group": "Groupe · {0}",
- "device.mosaic.groups": "{0} groupes · {1} · {2}",
- "device.mosaic.how_far_the_key_moves": "L’influence de la touche sur la hauteur — 100 % chromatique, 0 % toutes les touches jouent la fondamentale",
- "device.mosaic.how_fast_a_stolen_or": "La vitesse d’extinction d’une voix volée ou remplacée",
- "device.mosaic.how_many_strikes_of_one": "Le nombre de frappes d’une même touche qui peuvent sonner ensemble",
- "device.mosaic.how_much_quieter_a_release": "De combien l’échantillon de relâchement baisse quand la touche est tenue longtemps — glisser vers le haut / bas, ⌥-clic pour saisir",
- "device.mosaic.how_much_velocity_sets_the": "Dans quelle mesure la vélocité règle le niveau",
- "device.mosaic.install_pack": "Installer le pack",
- "device.mosaic.instruments": { "one": "{0} instrument", "other": "{0} instruments" },
- "device.mosaic.layers": { "one": "{0} couche", "other": "{0} couches" },
- "device.mosaic.let_the_amp_envelope_open": "Laisser l’enveloppe d’ampli ouvrir (ou fermer) le filtre",
- "device.mosaic.loading": "Chargement {0}",
- "device.mosaic.loading_n": "Chargement {0} %",
- "device.mosaic.loading_notes_muted": "Chargement · {0} / {1} · notes coupées",
- "device.mosaic.locate_folder": "Localiser le dossier…",
- "device.mosaic.locate_the_samples": "Localiser les échantillons",
- "device.mosaic.make_the_note_in_the": "Prendre la note du nom de fichier de la zone comme fondamentale",
- "device.mosaic.missing": " · {0} manquant(s)",
- "device.mosaic.move_start_and_end_to": "Placer Start et End là où le son commence et s’éteint (−48 dB)",
- "device.mosaic.move_start_end_and_the": "Placer Start, End et la boucle au passage par zéro le plus proche",
- "device.mosaic.mpe_pressure_aftertouch_level": "Pression MPE (aftertouch) → niveau",
- "device.mosaic.mpe_slide_cc74_cutoff": "Glissement MPE (CC74) → coupure",
- "device.mosaic.none_of_its_samples_were": "Aucun de ses {0} échantillons n’a été trouvé. Les réglages de zones sont conservés — indiquer à Mosaic le dossier qui les contient.",
- "device.mosaic.notes_are_silent_until_loading": "Les notes restent muettes jusqu’à la fin du chargement",
- "device.mosaic.off_plays_once_fwd_loops": "Off joue une fois · Fwd boucle · Ping fait des allers-retours — cette zone uniquement",
- "device.mosaic.old_voice_fade": "Old voice fade",
- "device.mosaic.open_in_sample": "Ouvrir dans Sample",
- "device.mosaic.opens_the_mapping_preview_a": "Ouvre l’aperçu de l’assignation. Un fichier seul remplace l’échantillon, comme avant.",
- "device.mosaic.pack_is_not_installed": "Le pack « {0} » n’est pas installé",
- "device.mosaic.pick_the_folder_that_holds": "Choisir le dossier qui contient les échantillons — Mosaic y retrouve chaque fichier par son chemin ou son nom",
- "device.mosaic.poly_chords_click_again_for": "Poly : accords (cliquer à nouveau pour les réglages de voix) · Mono : une à la fois, legato avec Glide · Choke : une nouvelle note coupe celles qui sonnent",
- "device.mosaic.release_to_build_a_multisample": "Relâcher pour créer un multi-échantillon",
- "device.mosaic.release_to_load_the_sample": "Relâcher pour charger l’échantillon",
- "device.mosaic.round_robin_steps_the_groups": "Étapes de round-robin : les zones du groupe jouent à tour de rôle de 1 à N (l’étape de chaque zone est définie par son fichier)",
- "device.mosaic.sample_not_loaded": "Échantillon non chargé",
- "device.mosaic.samples_are_not_copied_into": "Les échantillons ne sont pas copiés dans le projet ; le programme retient où ils se trouvent.",
- "device.mosaic.samples_unavailable_notes_muted": "Échantillons indisponibles · notes coupées",
- "device.mosaic.select_a_zone": "Sélectionner une zone",
- "device.mosaic.settings_downloads_sample_packs": "Réglages → Téléchargements → Packs d’échantillons",
- "device.mosaic.shift_every_note_24_semitones": "Décaler toutes les notes, ±24 demi-tons",
- "device.mosaic.slide_from_the_last_note": "Glisser depuis la dernière note — en Mono, legato",
- "device.mosaic.snap_to_zero": "Caler sur le zéro",
- "device.mosaic.stop_loading_the_instrument_empties": "Arrêter le chargement — l’instrument se vide (annuler le rétablit)",
- "device.mosaic.the_articulation_the_sfzs_controller": "L’articulation — la valeur de contrôleur du SFZ selon laquelle ses zones ont été choisies",
- "device.mosaic.the_cutoff_follows_the_key": "La coupure suit la touche",
- "device.mosaic.the_level_after_everything": "Le niveau après tout le reste",
- "device.mosaic.the_pitch_wheels_range_mpe": "La plage de la molette de hauteur (les bends MPE sont par note)",
- "device.mosaic.the_release_samples_level": "Le niveau des échantillons de relâchement",
- "device.mosaic.the_samples_arent_where_the": "Les échantillons ne sont pas là où le programme l’indique",
- "device.mosaic.the_sustain_pedal_a_keyboards": "La pédale de sustain : le CC64 d’un clavier maintient les touches relâchées — cliquer pour ne plus l’écouter",
- "device.mosaic.the_zones_fine_tune_100": "L’accord fin de la zone, ±100 cents",
- "device.mosaic.the_zones_fine_tune_drag": "L’accord fin de la zone — glisser, molette, double-clic pour réinitialiser",
- "device.mosaic.the_zones_level": "Le niveau de la zone",
- "device.mosaic.the_zones_pan": "Le panoramique de la zone",
- "device.mosaic.the_zones_root_drag_or": "La fondamentale de la zone — glisser ou défiler",
- "device.mosaic.this_groups_exclusive_number": "Le numéro exclusif de ce groupe",
- "device.mosaic.this_preset_uses_samples_from": "Ce préréglage utilise {0} échantillons du pack. Les réglages de zones sont conservés, mais aucun son tant que le pack n’est pas installé.",
- "device.mosaic.this_zones_level": "Le niveau de cette zone",
- "device.mosaic.total_in_ram": "Total en RAM",
- "device.mosaic.trim_silence": "Rogner le silence",
- "device.mosaic.velocity_level_curve": "Courbe vélocité → niveau",
- "device.mosaic.velocity_level_drag_up_for": "Vélocité → niveau : glisser vers le haut pour doux (notes faibles plus fortes), vers le bas pour dur ; ⌥-clic pour saisir",
- "device.mosaic.voice_stealing_order": "Vol de voix · ordre",
- "device.mosaic.voices_of_this_group_stop": "Les voix de ce groupe s’arrêtent quand une note de ce groupe exclusif démarre",
- "device.mosaic.zones": { "one": "{0} zone", "other": "{0} zones" },
- "device.mosaic.zones_can_already_be_selected": "Les zones peuvent déjà être sélectionnées et modifiées",
- "device.mosaic.zones_n": "{0} · {1} zones",
- "device.operator.11_topologies_feedback_on_a": "11 topologies · feedback sur A",
- "device.operator.vel_fm_off": "Vél. → FM off",
- "device.operator_algo.drag_an_operator_onto_another": "glisser un opérateur sur un autre pour le reconnecter",
- "device.pendulum.bar_quantize": "mesure · quantification {0}",
- "device.pendulum.detune_of_the_chorus_partner": "Désaccord du partenaire de chorus dans chaque voix",
- "device.pendulum.fan_the_notes_across_the": "Répartir les notes dans le champ stéréo selon la position de la balle",
- "device.pendulum.free_seconds_per_swing_at": "Free : secondes par oscillation à +100 %",
- "device.pendulum.hold_a_chord": "tenir un accord",
- "device.pendulum.how_far_the_balls_rates": "L’écart croissant entre les vitesses des balles — chaque balle un peu plus rapide que la précédente",
- "device.pendulum.how_long_one_swing_low": "La durée d’une oscillation (bas → haut → bas) à +100 %",
- "device.pendulum.humanize_on_off_the_amount": "Humanize activé / désactivé — la quantité est réglée par le curseur HUMAN",
- "device.pendulum.last_note": "dernière note {0} · {1}",
- "device.pendulum.latch_the_chord_it_keeps": "Latch de l’accord — il continue d’osciller après le relâchement ; l’accord suivant le remplace",
- "device.pendulum.level_and_pitch_jitter_per": "Variation aléatoire du niveau et de la hauteur par note",
- "device.pendulum.one_ball_fewer_2_at": "Une balle de moins (2 au minimum)",
- "device.pendulum.one_ball_more_6_at": "Une balle de plus (6 au maximum)",
- "device.pendulum.one_lane_per_ball_x": "Une voie par balle : x est la hauteur, du grave à l’aigu. Franchir un degré d’accord joue cette note ; le turquoise montre le mur devant",
- "device.pendulum.quantize_a_crossing_waits_for": "Quantize : un franchissement attend la prochaine double-croche ou croche avant de jouer",
- "device.pendulum.reset_spread_humanize_and_scale": "Réinitialiser spread, humanize et scale à leurs valeurs par défaut",
- "device.pendulum.restart_every_ball_from_its": "Relancer chaque balle depuis son départ quand un nouvel accord commence",
- "device.pendulum.restart_every_balls_swing_now": "Relancer maintenant l’oscillation de chaque balle",
- "device.pendulum.snap_the_generated_notes_to": "Caler les notes générées sur une gamme",
- "device.pendulum.swing_speed_centre_stops_the": "Vitesse d’oscillation — le centre arrête les balles, à gauche du centre elles repartent en sens inverse",
- "device.pendulum.sync_a_swing_takes_a": "Sync : une oscillation dure une valeur de note du tempo · Free : elle dure un temps en secondes",
- "device.pendulum.the_bar_generated_notes_land": "La mesure : les notes générées tombent sur la grille de doubles-croches — cette mesure en neutre avec la note qui vient de jouer en accent, la mesure précédente plus pâle devant la tête de lecture",
- "device.pendulum.the_swing_curve_pendulum_slows": "La courbe d’oscillation — Pendulum ralentit aux murs, Linear garde une vitesse constante, Bounce se stabilise avec une ondulation",
- "device.pendulum.the_voice_soft_keys_bright": "La voix : Keys doux, Glass brillant, Saw, Square creux ou Bell inharmonique",
- "device.pendulum.up_the_low_wall_plays": "Haut : le mur bas joue la note la plus basse de l’accord · Bas : la plus haute",
- "device.pendulum.voices": { "one": "{0} voix", "other": "{0} voix" },
- "device.pentad.khz_os_cpu": "{0:0.#} kHz · ×{1} OS · CPU {2:0} %",
- "device.pentad.per_voice_active_routes": { "one": "par voix · {0} route active", "other": "par voix · {0} routes actives" },
- "device.pentad.poly_mod_source_destination_caps": "Poly mod — source → destination",
- "device.pentad.re_roll_the_vintage_seed": "Retirer la graine vintage (nouvelle dispersion par voix)",
- "device.pentad.restore_lows_at_high_q": "Restaurer les graves à Q élevé",
- "device.pentad.shape_pulse_width_caps": "Shape · pulse width",
- "device.pentad.voice_setup_polyphony_allocation_glide": "Configuration des voix : polyphonie, allocation, mode de glide, suréchantillonnage, graine vintage",
- "device.pentad.wheel_mod_destinations_caps": "Wheel mod — destinations",
- "device.phaser.all_pass_stages_every_two": "Étages passe-tout : tous les deux creusent une encoche — 2 donne un léger tourbillon, 12 un balayage profond et dense",
- "device.phaser.center_the_middle_of_the": "Center — le milieu du balayage, 50 Hz … 5 kHz : plus haut, les encoches montent",
- "device.phaser.depth_at_zero_the_notches": "Depth à zéro : les encoches restent immobiles",
- "device.phaser.depth_how_far_the_lfo": "Depth — l’amplitude du LFO sur les étages autour de Center, jusqu’à ±3 octaves",
- "device.phaser.feedback_the_chains_output_fed": "Feedback — la sortie de la chaîne réinjectée, ±95 % : positif, il affine les pics ; négatif, il déplace et élargit les encoches",
- "device.phaser.how_deep_the_notches_cut": "Profondeur des encoches, dB (0 … −36 sur la barre)",
- "device.phaser.mix_50_gives_the_deepest": "Mix — 50 % donne les encoches les plus profondes ; 100 % est le signal déphasé seul",
- "device.phaser.phaser_bypassed_the_signal_passes": "Phaser contourné : le signal passe inchangé",
- "device.phaser.rate_the_note_value_of": "Rate — la valeur de note d’un cycle de LFO, 4/1 … 1/16 avec valeurs pointées (D) et en triolets (T)",
- "device.phaser.stereo_the_right_lfo_against": "Stereo — le LFO droit par rapport au gauche : 0° balaie les deux ensemble, 90° les écarte, 180° les fait évoluer en opposition",
- "device.phaser.the_corner_frequency_of_both": "La fréquence de coin des deux canaux sur deux cycles du LFO (20 Hz … 20 kHz), et la position actuelle de chacune",
- "device.phaser.the_lfo_shape_that_sweeps": "La forme du LFO qui balaie les étages : Sine glisse, Tri balaie régulièrement, Saw monte puis retombe",
- "device.phaser.the_notches_the_stages_cut": "Les encoches que les étages creusent dans le spectre, L neutre et R turquoise, avec le coin en pointillés et chaque encoche repérée en haut. Glisser à gauche / droite pour déplacer Center, vers le haut / bas pour Feedback ; ⌥-clic pour saisir, double-clic pour réinitialiser les deux.",
- "device.phaser.the_range_the_corner_sweeps": "La plage balayée par le coin (20 Hz … 20 kHz sur la barre), et la première encoche actuelle",
- "device.phaser.what_the_feedback_makes_positive": "Effet du feedback : positif, il affine les pics ; négatif, il déplace et élargit les encoches ; au-delà de 85 %, le phaser siffle",
- "device.physical.1_2_resonator_1_rings": "1→2 : le résonateur 1 excite le résonateur 2 · 1+2 : les deux sont frappés, mélangés",
- "device.physical.env_freq_off": "env → freq off",
- "device.physical.how_hard_a_released_key": "La force avec laquelle une touche relâchée étouffe le corps — à 0 il continue de sonner, au maximum il s’arrête aussitôt",
- "device.physical.partials_as_the_engine_tunes": "Partiels tels que le moteur les accorde — glisser ↔ pour étaler la série (Ratio), ↕ pour incliner les aigus (Bright)",
- "device.physical.poly_8_voices_ring_over": "Poly : 8 voix qui se chevauchent · Mono : une nouvelle frappe coupe la note qui sonne",
- "device.physical.res_1_against_res_2": "Res 1 face à Res 2 — les deux à plein niveau au milieu ; en 1→2, le son propre de res 1 face au corps qu’il fait résonner",
- "device.physical.resonator_2_on_off_resonator": "Résonateur 2 activé / désactivé — le résonateur 1 sonne toujours",
- "device.physical.stiffness_sets_the_contact_time": "Stiffness règle le temps de contact : doux = long et sombre, dur = court et brillant",
- "device.physical.which_resonator_the_controls_below": "Le résonateur que modifient les commandes ci-dessous",
- "device.plugin.close_editor": "Fermer l’éditeur",
- "device.plugin.close_the_plug_ins_own": "Fermer la fenêtre propre au plug-in",
- "device.plugin.couldnt_open_the_window": "Impossible d’ouvrir la fenêtre {0}.",
- "device.plugin.couldnt_open_the_window_n": "Impossible d’ouvrir la fenêtre {0} : {1}",
- "device.plugin.no_parameter_matches": "Aucun paramètre correspondant",
- "device.plugin.open_editor": "Ouvrir l’éditeur",
- "device.plugin.open_the_plug_ins_own": "Ouvrir la fenêtre propre au plug-in",
- "device.plugin.save_the_plug_ins_state": "Enregistrer l’état du plug-in comme préréglage",
- "device.plugin.this_plug_in_exposes_no": "Ce plug-in n’expose aucun paramètre",
- "device.prism.above_compress_caps": "Au-dessus — compresser",
- "device.prism.above_compression_caps": "Au-dessus — compression",
- "device.prism.amount_scales_every_bands_compression": "Amount — met à l’échelle la compression et l’expansion de chaque bande (0 % = aucune). Double-clic : 100 %",
- "device.prism.auto_makeup_each_band_gets": "Auto makeup — chaque bande récupère environ la moitié de sa compression à 0 dBFS",
- "device.prism.auto_release_short_peaks_recover": "Auto release — les pics brefs se relâchent vite, une compression soutenue se relâche lentement",
- "device.prism.band_gain_24_db_drag": "Gain de bande ±24 dB — glisser vers le haut / bas, double-clic pour réinitialiser",
- "device.prism.bands_3_low_mid_high": "Bandes — 3 : Low / Mid / High · 2 : Low + Mid (Mid va jusqu’à 20 kHz) · 1 : Mid, pleine bande",
- "device.prism.below_expand_caps": "Au-dessous — expanser",
- "device.prism.below_expansion": "Au-dessous — expansion",
- "device.prism.below_expansion_caps": "Au-dessous — expansion",
- "device.prism.below_upward_compression": "Au-dessous — compression ascendante",
- "device.prism.compression_threshold_ratio_set_the": "Seuil de compression · ratio (régler le ratio dans Band detail)",
- "device.prism.crossovers": "crossovers {0} / {1}",
- "device.prism.detector_peak_follows_every_transient": "Detector — Peak suit chaque transitoire ; RMS (10 ms) suit le volume, plus lisse",
- "device.prism.drag_a_dot_threshold_ratio": "Glisser un point : ← → seuil, ↑ ↓ ratio (vers le bas = plus). Le point brillant est la compression au-dessus, le gris l’expansion en dessous. Double-clic sur un point pour le réinitialiser. · ⌥-clic pour saisir",
- "device.prism.expansion_upward_compression_threshold_ratio": "Seuil d’expansion / compression ascendante · ratio — cliquer sur l’affichage pour l’activer ou le désactiver",
- "device.prism.input_spectrum_fill_and_output": "Spectre d’entrée (aplat) et de sortie (ligne). Glisser une ligne de crossover pour la déplacer ; ⌥-clic pour saisir, double-clic pour réinitialiser. Cliquer une bande pour la sélectionner.",
- "device.prism.khz_cpu": "{0:0.#} kHz · {1}{2} · CPU {3:0} %",
- "device.prism.listen_hear_the_detectors_key": "Listen — écouter le signal de clé du détecteur (le sidechain, ou l’entrée), par bande en solo",
- "device.prism.listening_to_the_detector_key": "À l’écoute de la clé du détecteur",
- "device.prism.low_mid_crossover": "Crossover grave / médium",
- "device.prism.mid_high_crossover": "Crossover médium / aigu",
- "device.prism.n_a_in_a_rack": "indisponible dans un rack",
- "device.prism.none_own_input": "Aucun — entrée propre",
- "device.prism.output_gain_24_db_double": "Gain de sortie ±24 dB — double-clic : 0 dB",
- "device.prism.ratio_above_1_1_expands": "Un ratio au-dessus de 1 : 1 expanse (les passages faibles deviennent plus faibles) ; en dessous de 1 : 1 (↑) il comprime vers le haut (les passages faibles sont relevés). Floor limite les deux à ± ce nombre de dB.",
- "device.prism.sidechain_key_every_bands_detector": "Sidechain — pilote le détecteur de chaque bande depuis une autre piste (découpée dans les mêmes bandes)",
- "device.prism.soft_clip_a_smooth_ceiling": "Soft clip — un plafond doux à −0,3 dBFS après le gain de sortie",
- "device.prism.solo_a_band_hear_only": "Solo d’une bande — n’entendre que cette bande (cliquer à nouveau pour annuler)",
- "device.prism.the_selected_bands_input_peaks": "Les crêtes d’entrée de la bande sélectionnée (gris) et ce qu’en fait le détecteur de son compresseur (les ~1,5 dernières secondes), face au seuil.",
- "device.rack.a_midi_effect_rack_holds": "Un MIDI Effect Rack contient jusqu’à {0} chaînes",
- "device.rack.a_midi_effect_rack_takes": "Un MIDI Effect Rack n’accepte que des effets MIDI.",
- "device.rack.a_rack_cant_go_inside": "Un rack ne peut pas aller dans un rack.",
- "device.rack.add_device_click_for_the": "Ajouter un appareil — cliquer pour la liste, ou déposer un effet ici",
- "device.rack.all_chains_get_the_input": "Toutes les chaînes reçoivent l’entrée. Les sorties sont additionnées.",
- "device.rack.an_audio_effect_rack_takes": "Un Audio Effect Rack n’accepte que des effets audio.",
- "device.rack.audio_effect_rack_chain": "Audio Effect Rack · chaîne {0}",
- "device.rack.chain": "Chaîne {0}",
- "device.rack.chain_1_feeds_chain_2": "La chaîne 1 alimente la chaîne 2, de haut en bas.",
- "device.rack.chain_n": "chaîne {0}",
- "device.rack.chains": { "one": "{0} chaîne", "other": "{0} chaînes" },
- "device.rack.chains.a_midi_effect_rack_holds": "Un MIDI Effect Rack contient jusqu’à {0} chaînes.",
- "device.rack.chains.add_a_chain_or_drop": "Ajouter une chaîne — ou déposer un appareil du Navigateur sur la liste",
- "device.rack.chains.add_a_chain_to_start": "Ajouter une chaîne pour commencer.",
- "device.rack.chains.add_a_midi_effect_or": "Ajouter un effet MIDI — ou en déposer un depuis le Navigateur",
- "device.rack.chains.add_an_effect_or_drop": "Ajouter un effet — ou en déposer un depuis le Navigateur",
- "device.rack.chains.an_instrument_rack_cant_go": "Un Instrument Rack ne peut pas aller dans un rack — ajouter ses instruments comme chaînes.",
- "device.rack.chains.cant_go_in_a_rack": "{0} ne peut pas aller dans une chaîne de rack.",
- "device.rack.chains.chain": "Chaîne · {0}",
- "device.rack.chains.click_to_add_or_remove": "Cliquer pour ajouter ou retirer",
- "device.rack.chains.controlled_by_click_to_open": "Contrôlé par {0} · cliquer pour ouvrir la macro",
- "device.rack.chains.delete_chain": "Supprimer la chaîne",
- "device.rack.chains.devices": { "one": "{0} appareil", "other": "{0} appareils" },
- "device.rack.chains.drop_a_device_here": "Déposer un appareil ici.",
- "device.rack.chains.left_right": "{0} · {1} de gauche à droite",
- "device.rack.chains.map_to": "Assigner à {0}",
- "device.rack.chains.midi_effect": "{0} · effet MIDI {1}",
- "device.rack.chains.open_the_full_editor": "Ouvrir l’éditeur complet",
- "device.rack.chains.pick_an_instrument_or_drop": "Choisir un instrument — ou en déposer un depuis le Navigateur",
- "device.rack.chains.plug_in_presets_cant_go": "Les préréglages de plug-in ne peuvent pas encore aller dans une chaîne de rack.",
- "device.rack.chains.replace_instrument": "Remplacer l’instrument",
- "device.rack.chains.sel": "sél. {0}–{1}",
- "device.rack.chains.this_preset_cant_go_in": "Ce préréglage ne peut pas aller dans un rack.",
- "device.rack.chains.this_rack_cant_host_plug": "Ce rack ne peut pas accueillir de plug-ins.",
- "device.rack.chains.turn_off": "Désactiver",
- "device.rack.chains.turn_on": "Activer",
- "device.rack.chains.unmap_from": "Désassigner de {0}",
- "device.rack.clear_mappings": { "one": "Effacer {0} assignation", "other": "Effacer {0} assignations" },
- "device.rack.clipboard.copied": "{0} copié",
- "device.rack.clipboard.couldnt_paste_a_device_failed": "Impossible de coller : un appareil n’a pas pu se charger.",
- "device.rack.clipboard.midi_effects_run_in_the": "Les effets MIDI s’exécutent dans les 16 premières chaînes.",
- "device.rack.clipboard.move_left": "Déplacer vers la gauche",
- "device.rack.clipboard.move_right": "Déplacer vers la droite",
- "device.rack.clipboard.nothing_to_paste": "Rien à coller",
- "device.rack.clipboard.nothing_to_paste_here": "Rien à coller ici.",
- "device.rack.clipboard.pasted": "{0} collé",
- "device.rack.clipboard.pasted_devices": "{0} appareils collés",
- "device.rack.clipboard.pasted_devices_skipped_this_chain": "{0} appareils collés, {1} ignorés car cette chaîne ne peut pas les accepter",
- "device.rack.clipboard.sidechain_dropped": " · sidechain supprimé",
- "device.rack.clipboard.the_device_cant_go_there": "L’appareil ne peut pas aller là.",
- "device.rack.clipboard.this_chain_cant_take_the": "Cette chaîne ne peut pas accepter les appareils copiés.",
- "device.rack.clipboard.this_device_cant_be_duplicated": "Cet appareil ne peut pas être dupliqué",
- "device.rack.clipboard.this_racks_chains_take_no": "Les chaînes de ce rack n’acceptent pas d’effets MIDI.",
- "device.rack.clipboard.this_racks_chains_take_no_2": "Les chaînes de ce rack n’acceptent pas d’effets audio.",
- "device.rack.double_click_to_rename": "Double-clic pour renommer",
- "device.rack.drag_to_set_right_click": "Glisser pour régler · clic droit pour assigner",
- "device.rack.drop_an_effect_to_add": "Déposer un effet pour ajouter une chaîne.",
- "device.rack.drop_an_instrument_to_add": "Déposer un instrument pour ajouter une couche.",
- "device.rack.drop_midi_effects_here_output": "Déposer des effets MIDI ici. La sortie va à l’instrument de la piste.",
- "device.rack.drum.16_loaded": "{0} · {1}/16 chargés",
- "device.rack.drum.a_rack_cant_go_on": "Un rack ne peut pas aller sur un pad de Drum Rack.",
- "device.rack.drum.a_synth_voice_no_sample": "Une voix de synthé, sans échantillon",
- "device.rack.drum.all_pads": { "one": "Tous les {0} pad", "other": "Tous les {0} pads" },
- "device.rack.drum.back_to_pads": "Retour aux pads",
- "device.rack.drum.bank": "Banque {0}",
- "device.rack.drum.choke_group": "Groupe d’exclusion",
- "device.rack.drum.choke_group_click_for_the": "Groupe d’exclusion : cliquer pour le suivant",
- "device.rack.drum.choke_group_n": "groupe d’exclusion {0} : {1}",
- "device.rack.drum.choke_groups": { "one": "{0} groupe d’exclusion", "other": "{0} groupes d’exclusion" },
- "device.rack.drum.click_to_add_an_instrument": "{0} — cliquer pour ajouter un instrument, ou déposer un échantillon ici",
- "device.rack.drum.click_to_play_right_click": "{0} · {1} — cliquer pour jouer, clic droit pour plus d’options",
- "device.rack.drum.drop_a_sample_on_a": "Déposer un échantillon sur un pad, ou choisir un kit ci-dessus.",
- "device.rack.drum.effects": { "one": "{0} effet", "other": "{0} effets" },
- "device.rack.drum.empty": "{0} · vide",
- "device.rack.drum.every": "Chaque {0} ({1})",
- "device.rack.drum.group": "Groupe {0}",
- "device.rack.drum.hide_the_empty_pads": "Masquer les pads vides",
- "device.rack.drum.instrument_then_its_effects_signal": "instrument, puis ses effets · signal de gauche → droite",
- "device.rack.drum.mute_the_pad": "Couper le pad",
- "device.rack.drum.no_choke_groups": " · aucun groupe d’exclusion",
- "device.rack.drum.no_pad_selected": "{0} · aucun pad sélectionné{1}",
- "device.rack.drum.no_pads_in_bank": "Aucun pad dans la banque {0}.",
- "device.rack.drum.no_pads_in_bank_drop": "Aucun pad dans la banque {0} — déposer des échantillons dans la vue Pads.",
- "device.rack.drum.no_pads_to_map": "Aucun pad à assigner",
- "device.rack.drum.no_sample_drop_one_on": "Aucun échantillon — en déposer un sur le pad",
- "device.rack.drum.none_choke_group": "Aucun",
- "device.rack.drum.nudge_every_hits_timing_at": "Décaler au hasard le timing de chaque frappe",
- "device.rack.drum.off": "désactivé",
- "device.rack.drum.open_chain": "Ouvrir la chaîne",
- "device.rack.drum.open_the_pads_instrument": "Ouvrir l’instrument du pad",
- "device.rack.drum.pad": "Pad",
- "device.rack.drum.pad_bank_sixteen_notes_from": "Banque de pads : seize notes à partir de C1, C2, C3 ou C4",
- "device.rack.drum.pad_pan_drag_up_or": "Panoramique du pad · glisser vers le haut ou le bas, ⌥-clic pour saisir, double-clic pour centrer",
- "device.rack.drum.pad_volume_drag_up_or": "Volume du pad · glisser vers le haut ou le bas, ⌥-clic pour saisir, double-clic pour 0 dB",
- "device.rack.drum.pad_volume_pan": "{0} {1} · {2} → {3} → volume, panoramique du pad",
- "device.rack.drum.pads": { "one": "{0} pad", "other": "{0} pads" },
- "device.rack.drum.pads_in_the_same_group": "Les pads d’un même groupe se coupent mutuellement",
- "device.rack.drum.push_the_off_beat_sixteenths": "Retarder les doubles-croches en contretemps",
- "device.rack.drum.remove_pad": "Retirer le pad",
- "device.rack.drum.sampler": "sampler {0}",
- "device.rack.drum.select_a_pad_to_see": "Sélectionner un pad pour voir sa chaîne d’appareils.",
- "device.rack.drum.select_the_pad": "Sélectionner le pad",
- "device.rack.drum.selected_choke": "{0} {1} sélectionné · {2} · exclusion {3}",
- "device.rack.drum.shorten_the_pads_tail_hold": "Raccourcir la queue du pad ; hold la laisse sonner",
- "device.rack.drum.show_every_pad_of_the": "Afficher tous les pads de la banque",
- "device.rack.drum.show_the_pads": "Afficher les pads",
- "device.rack.drum.show_the_pads_instrument_and": "Afficher l’instrument et les effets du pad",
- "device.rack.drum.slots_assigned": "{0} emplacements · {1} assignés",
- "device.rack.drum.solo_the_pad": "Mettre le pad en solo",
- "device.rack.drum.swing_humanize": " · swing {0} · humanize {1}",
- "device.rack.drum.transpose_the_note_the_pad": "Transposer la note jouée par le pad, en demi-tons",
- "device.rack.drum_rack_pad": "Drum Rack · pad {0}{1}",
- "device.rack.each_note_goes_to_every": "Chaque note va à toutes les chaînes dont elle touche la zone. Les sorties fusionnent avant l’instrument.",
- "device.rack.effect_of": "{0} · effet {1} sur {2}",
- "device.rack.instrument_rack_chain": "Instrument Rack · chaîne {0}{1}",
- "device.rack.keys_c_1_g9_vel": "Touches C−1–G9 · vél. 0–127",
- "device.rack.macro_tab.drag_the_ends_min_above": "Glisser les extrémités · min au-dessus de max inverse",
- "device.rack.macro_tab.map_this_macro_click_parameters": "Assigner cette macro : cliquer des paramètres dans l’onglet Chains",
- "device.rack.macro_tab.no_targets_yet_press_map": "Aucune cible pour l’instant. Appuyer sur Map, puis cliquer des paramètres dans l’onglet Chains.",
- "device.rack.macros": { "one": "{0} macro", "other": "{0} macros" },
- "device.rack.macros.add_a_receiver_a_pad": "Ajouter un récepteur : une commande de pad, l’instrument du pad ou l’un de ses effets",
- "device.rack.macros.all": "tous",
- "device.rack.macros.all_n": "tous les {0}",
- "device.rack.macros.drag_to_turn_click_to": "{0} — {1}\nGlisser pour tourner · cliquer pour voir ses récepteurs · clic droit pour assigner, renommer ou effacer",
- "device.rack.macros.drag_to_turn_double_click": "{0} → {1} · glisser pour tourner · double-clic pour réinitialiser",
- "device.rack.macros.every_macro_assigned": "toutes les macros assignées",
- "device.rack.macros.free": "{0} libre(s)",
- "device.rack.macros.macro_is_free_right_click": "La macro {0} est libre — clic droit (ou Map) pour lui donner une cible",
- "device.rack.macros.map": "Assigner",
- "device.rack.macros.map_the_chosen_macro_click": "Assigner la macro choisie : cliquer des paramètres dans la chaîne",
- "device.rack.macros.map_to": "Assigner à",
- "device.rack.macros.not_assigned": "non assigné",
- "device.rack.macros.not_mapped_pick_it_and": "Non assigné · le choisir puis appuyer sur Map",
- "device.rack.macros.nothing_mapped_yet_map_gives": "Rien d’assigné pour l’instant. Map donne à ce potentiomètre une commande de pad, un paramètre d’instrument ou l’un des effets du kit.",
- "device.rack.macros.params": { "one": "{0} param.", "other": "{0} param." },
- "device.rack.macros.receivers_and_ranges": "Récepteurs et plages…",
- "device.rack.macros.remove_every_receiver_of_this": "Retirer tous les récepteurs de cette macro",
- "device.rack.macros.remove_this_receiver": "Retirer ce récepteur",
- "device.rack.macros.rename": "Renommer",
- "device.rack.macros.stop_mapping_esc": "Arrêter l’assignation (Échap)",
- "device.rack.macros.targets": { "one": "{0} cible", "other": "{0} cibles" },
- "device.rack.macros.the_range_the_macro_sweeps": "La plage balayée par la macro : glisser l’une ou l’autre extrémité · le repère indique la position actuelle",
- "device.rack.map_to_a_macro": "Assigner à une macro",
- "device.rack.map_to_parameter": "Assigner à un paramètre",
- "device.rack.map_to_the_selector": "Assigner au sélecteur",
- "device.rack.mapped_to_macro_click_to": "Assigné à la macro {0} — cliquer pour changer",
- "device.rack.nota_rhythm_voice": "Nota Rhythm · voix {0}",
- "device.rack.of_8_mapped": "{0} sur 8 assignées",
- "device.rack.only_chains_whose_range_holds": "Seules les chaînes dont la plage contient le sélecteur reçoivent des notes.",
- "device.rack.only_chains_whose_range_holds_2": "Seules les chaînes dont la plage contient le sélecteur jouent.",
- "device.rack.pads": "{0} · {1} pads",
- "device.rack.parameters": { "one": "{0} paramètre", "other": "{0} paramètres" },
- "device.rack.params": { "one": "→ {0} param.", "other": "→ {0} param." },
- "device.rack.remove_device": "Retirer l’appareil",
- "device.rack.right_panel.a_rack_keeps_at_least": "Un rack garde au moins une chaîne",
- "device.rack.right_panel.all_chains_share_one_voice": "Toutes les chaînes partagent une voix, la dernière touche l’emporte",
- "device.rack.right_panel.copy_this_chain_after_itself": "Copier cette chaîne après elle-même",
- "device.rack.right_panel.delete_this_chain": "Supprimer cette chaîne",
- "device.rack.right_panel.dry_wet": "{0} · {1} · dry/wet {2} · {3}",
- "device.rack.right_panel.edit_on_the_tab": "Modifier dans l’onglet {0}",
- "device.rack.right_panel.follow_input_level": "Suivre le niveau d’entrée",
- "device.rack.right_panel.follows_input": " · suit l’entrée",
- "device.rack.right_panel.glides_between_notes_in_mono": "Glisse entre les notes en mode mono",
- "device.rack.right_panel.in_select_mode_the_selector": "En mode Select, le sélecteur suit le niveau d’entrée au lieu de sa poignée",
- "device.rack.right_panel.line_up_chains_with_different": "Aligner des chaînes de latences différentes",
- "device.rack.right_panel.macros_mapped": { "one": "{0} macro assignée", "other": "{0} macros assignées" },
- "device.rack.right_panel.merge_duplicate_notes": "Fusionner les notes en double",
- "device.rack.right_panel.merged_midi": "{0} · {1} → MIDI fusionné · {2}",
- "device.rack.right_panel.mono_last_note": "Mono (dernière note)",
- "device.rack.right_panel.no_chain_yet": "Aucune chaîne pour l’instant.",
- "device.rack.right_panel.notes_no_chain_takes_reach": "Les notes qu’aucune chaîne ne prend atteignent l’instrument inchangées",
- "device.rack.right_panel.pass_through_outside_zones": "Laisser passer hors des zones",
- "device.rack.right_panel.select": "Sélecteur {0}",
- "device.rack.right_panel.two_chains_sending_the_same": "Deux chaînes qui envoient la même hauteur ne jouent qu’une note",
- "device.rack.this_drum_rack_is_no": "Ce Drum Rack n’est plus dans le rack.",
- "device.rack.unmap": "Désassigner",
- "device.rack.voices": "{0} · voix {1}",
- "device.rack.zones.drag_the_edges_to_set": "Glisser les bords pour définir la zone de touches · survoler pour tester une note",
- "device.rack.zones.drag_the_edges_to_set_2": "Glisser les bords pour définir la plage de sélection",
- "device.rack.zones.drag_the_edges_to_set_3": "Glisser les bords pour définir la zone de vélocité",
- "device.rack.zones.drag_the_selector_or_map": "Glisser le sélecteur ou l’assigner à une macro",
- "device.rack.zones.drag_to_choose_which_chains": "Glisser pour choisir les chaînes jouées · clic droit pour l’assigner à une macro",
- "device.rack.zones.drag_zone_edges_hover_to": "Glisser les bords de la zone · survoler pour tester une note",
- "device.rack.zones.hover_the_zones": "Survoler les zones",
- "device.rack.zones.inactive": " · inactif",
- "device.rack.zones.nothing": "rien",
- "device.rack.zones.ranges_apply_when_chains_run": "Les plages s’appliquent quand Chains run est réglé sur Select",
- "device.rack.zones.select_range_in_select_mode": "Plage de sélection : en mode Select, cette chaîne joue tant que le sélecteur est dedans",
- "device.rack.zones.selector": "sélecteur {0} → {1}{2}",
- "device.rack.zones.silence": "silence",
- "device.rack.zones.the_selector_follows_the_input": "Le sélecteur suit le niveau d’entrée · désactiver Follow input dans l’onglet Rack out pour le régler à la main",
- "device.rack.zones.vel": "{0} · vél. {1} → {2}",
- "device.random.bar_changed_skipped": "mesure {0} · {1} modifiées · {2} ignorées",
- "device.random.chance_how_many_notes_get": "Chance — combien de notes sont variées",
- "device.random.chance_that_a_varied_note": "Probabilité qu’une note variée soit supprimée",
- "device.random.changed_skip": "{0} modifiées · {1} ignorées",
- "device.random.dashed_in_filled_out_brightness": "Pointillés — entrée · plein — sortie (luminosité = vélocité) · × — ignoré",
- "device.random.distribution_gauss_even_walk_click": "Distribution : Gauss / Even / Walk — cliquer pour la suivante, Maj-clic pour la précédente",
- "device.random.distribution_gauss_mostly_small_moves": "Distribution : Gauss — surtout de petits écarts · Even — toute amplitude de façon égale · Walk — dérive de note en note",
- "device.random.drag_up_down_double_click": "{0} — glisser vers le haut / bas, double-clic pour réinitialiser",
- "device.random.hold_the_roll_showing_now": "Maintenir le roulement affiché — il se répète à chaque mesure",
- "device.random.jump_up_or_down_by": "Saute vers le haut ou le bas jusqu’à deux octaves",
- "device.random.lock_hold_the_roll_showing": "Lock — maintenir le roulement affiché",
- "device.random.next_seed_a_new_roll": "Graine suivante — un nouveau tirage",
- "device.random.one_bar_of_eight_notes": "Une mesure de huit notes : pointillés — la note en entrée, plein — la note en sortie (luminosité = vélocité, décalée à droite si retardée), × — ignorée",
- "device.random.per_note_every_note_rolls": "Per note — chaque note tire ses propres valeurs · Per bar — un seul jeu de valeurs pour toute la mesure",
- "device.random.play_late_by_up_to": "Jouer en retard jusqu’à cette durée (un effet en direct ne peut pas jouer en avance)",
- "device.random.push_the_velocity_up_or": "Pousser la vélocité vers le haut ou le bas jusqu’à cette valeur",
- "device.random.reroll_the_next_seed": "Reroll — la graine suivante",
- "device.random.snap_every_varied_note_into": "Ramener chaque note variée dans Do majeur",
- "device.random.stay_in_scale_c_maj": "Rester dans la gamme · Do maj",
- "device.random.the_shape_of_the_roll": "La forme du roulement — 1500 tirages du même générateur",
- "device.random.transpose_up_or_down_by": "Transposer vers le haut ou le bas jusqu’à ce nombre de demi-tons",
- "device.reverb.algorithm_hall_large_spaced_reflections": "Algorithme — Hall (grandes réflexions espacées) · Room (petite pièce, murs proches) · Plate (dense, sans pièce) · Chamber (entre les deux)",
- "device.reverb.bass_mono_below_this_frequency": "Bass mono — sous cette fréquence la queue est mono, pour qu’une réverbération large n’empâte pas les graves (désactivé tout à gauche)",
- "device.reverb.decay_rt60_the_time_the": "Decay — RT60, le temps que met la queue à baisser de 60 dB (0,2 … 12 s) ; Freeze la maintient indéfiniment. Double-clic pour réinitialiser.",
- "device.reverb.early_reflections_the_first_discrete": "Early reflections — les premiers échos discrets sur les murs, espacés selon l’algorithme et la taille",
- "device.reverb.freeze_hold_the_tail_forever": "Freeze — maintient la queue indéfiniment ; l’entrée est coupée et rien ne décroît",
- "device.reverb.hf_damp_how_much_faster": "HF Damp — de combien les aigus s’éteignent plus vite que les graves. Double-clic pour réinitialiser.",
- "device.reverb.input_muted_tail_held": "entrée coupée · queue maintenue",
- "device.reverb.kill_tail_empty_the_reverb": "Kill tail — vide la réverbération d’un coup ; tout ce qui sonne encore (ou est gelé) s’arrête",
- "device.reverb.latency_comp": "Comp. de latence",
- "device.reverb.mod_on_tail_the_modulation": "Mod on tail — la modulation fait osciller la queue elle-même (un déclin chorusé et évolutif) ; désactivé, elle ne bouge que le début et la queue reste immobile",
- "device.reverb.tail_held_no_decay": "Queue maintenue · sans déclin",
- "device.reverb.the_decay_tail_the_impulse": "La queue de déclin — l’impulsion au pre-delay (turquoise), les premières réflexions (dessinées agrandies), puis la courbe RT60 sur 4 s. Glisser le repère turquoise pour le pre-delay, la queue pour le déclin ; ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.reverb.the_input_diffuser_delays_the": "Le diffuseur d’entrée retarde la queue d’un retard de groupe fixe ; activé, le pre-delay est raccourci d’autant pour que la queue démarre au pre-delay réglé (il ne peut pas descendre sous zéro).",
- "device.reverb.vintage_an_early_digital_colour": "Vintage — une couleur des débuts du numérique : entrée limitée en bande, traitement en 12 bits et oscillation plus profonde",
- "device.reverb.wet_only_the_tail_with": "Wet only — la queue sans signal sec, pour une piste de retour / d’envoi",
- "device.rhythm.add_a_receiver_to_a": "Ajouter un récepteur à {0} : un paramètre de voix, un réglage du kit ou l’effet d’une voix",
- "device.rhythm.all_voices": { "one": "Toutes les {0} voix", "other": "Toutes les {0} voix" },
- "device.rhythm.amp_decay_shortens_the_hit": "Amp decay — raccourcit le coup",
- "device.rhythm.attack_click_snap": "Clic / claquement d’attaque",
- "device.rhythm.bank": "Banque {0}",
- "device.rhythm.bank_play_and_edit_this": "Banque {0} — jouer et modifier ce motif · clic droit pour le copier ou l’effacer",
- "device.rhythm.clear": "Effacer {0}",
- "device.rhythm.clear_bank": "Effacer la banque {0}",
- "device.rhythm.clear_its_steps_in_bank": "Effacer ses pas dans la banque {0}",
- "device.rhythm.click_step_on_off_shift": "Clic : pas actif / inactif · Maj-clic : accent · Alt-clic : pas faible\nGlisser pour peindre · glisser vers le haut / bas ou défiler pour régler la vélocité · clic droit pour plus d’options",
- "device.rhythm.click_to_load_another_file": "{0} — cliquer pour charger un autre fichier",
- "device.rhythm.copy_to": "Copier {0} vers",
- "device.rhythm.drag_the_start_and_end": "Glisser les lignes Start et End pour les régler · ⌥-clic sur l’une pour la saisir · double-clic pour charger un autre fichier",
- "device.rhythm.every": "Chaque {0} ({1})",
- "device.rhythm.fill_every_16th": "Remplir toutes les doubles-croches",
- "device.rhythm.fill_every_8th": "Remplir toutes les croches",
- "device.rhythm.fill_every_beat": "Remplir tous les temps",
- "device.rhythm.glue_a_bus_compressor_on": "Glue : un compresseur de bus sur tout le kit — soude les frappes entre elles (0 = désactivé)",
- "device.rhythm.how_much_louder_an_accented": "De combien un pas accentué joue plus fort",
- "device.rhythm.how_much_of_the_file": "La part du fichier jouée, à partir de Start",
- "device.rhythm.humanize_a_random_nudge_to": "Humanize : un léger décalage aléatoire de la vélocité de chaque frappe",
- "device.rhythm.load_a_one_shot_into": "Charger un one-shot dans cette voix (ou déposer un fichier sur la voix)",
- "device.rhythm.load_a_sample_into": "Charger un échantillon dans {0}",
- "device.rhythm.load_sample": "Charger un échantillon…",
- "device.rhythm.midi_click_select_and_play": "{0} · MIDI {1}\nClic : sélectionner et jouer · déposer un fichier pour le charger · clic droit pour plus d’options",
- "device.rhythm.of_1_16_bank": "{0} sur {1} · 1/16 · banque {2}",
- "device.rhythm.off_beats": "Contretemps",
- "device.rhythm.pitch_kick_snare_tom_hats": "Hauteur (Kick, Snare, Tom, Hats, Perc) ou couleur du bruit (Clap, Rim)",
- "device.rhythm.play_the_loaded_sample": "Jouer l’échantillon chargé",
- "device.rhythm.play_the_region_back_to": "Jouer la région à l’envers",
- "device.rhythm.play_the_synth_engine": "Jouer le moteur de synthèse",
- "device.rhythm.shift_left": "Décaler à gauche",
- "device.rhythm.shift_right": "Décaler à droite",
- "device.rhythm.shift_step_accent": "Maj+pas = accent",
- "device.rhythm.slots_assigned": "{0} emplacements · {1} assignés",
- "device.rhythm.snare_body_noise_hats_metal": "Snare corps ↔ bruit · Hats métal ↔ bruit · Perc rapport d’anneau",
- "device.rhythm.sound_the_voices_source_and": "Sound : la source et la forme de la voix · FX : ses propres effets, avant le bus du kit",
- "device.rhythm.step_accent": "Pas {0} accentué",
- "device.rhythm.step_quiet": "Pas {0} faible",
- "device.rhythm.swing_delays_every_second_16th": "Swing : retarde une double-croche sur deux — à 100 %, d’un demi-pas",
- "device.rhythm.synth_the_voices_own_engine": "Synth : le moteur propre de la voix · Sample : un one-shot chargé (en charge un si la voix n’en a pas)",
- "device.rhythm.the_hit_amp_contour_over": "La frappe : contour d’amplitude sur la chute de hauteur · glisser latéralement pour Decay, vers le haut / bas pour Tune (Maj = fin) · ⌥-clic pour les saisir",
- "device.rhythm.the_kits_eight_macros_knobs": "Les huit macros du kit — des potentiomètres sur chaque voix et ses effets",
- "device.rhythm.the_kits_output_level": "Le niveau de sortie du kit",
- "device.rhythm.the_selected_voices_sound_and": "Le son et les effets de la voix sélectionnée",
- "device.rhythm.the_voices_level_in_the": "Le niveau de la voix dans le kit",
- "device.rhythm.transpose_12_semitones": "Transposition, ±12 demi-tons",
- "device.rhythm.voices": { "one": "{0} voix", "other": "{0} voix" },
- "device.rhythm.where_in_the_file_the": "L’endroit du fichier où commence la frappe",
- "device.sampler.a_long_tail_after_release": "une longue queue après le relâchement",
- "device.sampler.a_slow_swell": "une montée lente",
- "device.sampler.almost_a_gate_the_sample": "presque un gate — l’échantillon s’entend en entier",
- "device.sampler.blends_the_loops_end_into": "Fond la fin de la boucle dans son début (boucles avant)",
- "device.sampler.click_a_key_to_make": "Cliquer une touche pour en faire la fondamentale — celle qui joue l’échantillon tel qu’enregistré",
- "device.sampler.detect_from_file_name": "Détecter d’après le nom du fichier",
- "device.sampler.drag_a_sample_from_the": "Glisser un échantillon depuis l’onglet Fichiers ou le navigateur",
- "device.sampler.drag_left_right_for_the": "Glisser : gauche / droite pour la coupure, haut / bas pour la résonance · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "device.sampler.drag_start_end_and_the": "Glisser Start / End (et les repères de boucle en mode boucle) · ⌥-clic sur un repère pour le saisir · double-clic pour le réinitialiser",
- "device.sampler.drag_the_nodes_attack_decay": "Glisser les nœuds : attaque, déclin et maintien (haut / bas), relâchement · Maj pour les pas fins · ⌥-clic pour saisir · double-clic pour réinitialiser",
- "device.sampler.drop_a_sample_here": "Déposer un échantillon ici",
- "device.sampler.env": "Env {0} — {1}",
- "device.sampler.every_key_plays_the_same": "toutes les touches jouent la même hauteur",
- "device.sampler.filter_off_the_sample_passes": "Filtre désactivé — l’échantillon passe intact",
- "device.sampler.fine_tune_50_cents": "Accord fin, ±50 cents",
- "device.sampler.held_at_the_sustain_level": "maintenu au niveau de sustain",
- "device.sampler.how_far_the_envelope_moves": "L’amplitude du déplacement de la coupure par l’enveloppe, ±6 octaves",
- "device.sampler.how_far_the_key_moves": "L’influence de la touche sur la hauteur — 100 % chromatique, 0 % toutes les touches jouent la fondamentale",
- "device.sampler.how_much_velocity_sets_the": "Dans quelle mesure la vélocité règle le niveau",
- "device.sampler.let_the_amp_envelope_open": "Laisser l’enveloppe d’ampli ouvrir (ou fermer) le filtre — la profondeur est ENV",
- "device.sampler.move_start_and_end_to": "Placer Start et End là où le son commence et s’éteint (−48 dB)",
- "device.sampler.move_start_end_and_the": "Placer Start, End et la boucle au passage par zéro le plus proche — sans clics",
- "device.sampler.names_make_it_the_root": "« {0} » désigne {1} — en faire la fondamentale",
- "device.sampler.no_crossfade": "{0} · sans fondu enchaîné",
- "device.sampler.no_sample_drop_one_from": "Aucun échantillon · en déposer un depuis l’onglet Fichiers ou le navigateur",
- "device.sampler.off_low_pass_high_pass": "Off · passe-bas · passe-haut · passe-bande (12 dB/oct)",
- "device.sampler.off_plays_once_fwd_loops": "Off joue une fois · Fwd boucle · Ping fait des allers-retours · Rev boucle à l’envers",
- "device.sampler.plays_the_sample_at_its": "{0} joue l’échantillon à sa propre hauteur",
- "device.sampler.poly_16_voices_mono_one": "Poly : 16 voix · Mono : une à la fois (legato avec Glide) · Choke : une nouvelle note coupe celles qui sonnent",
- "device.sampler.range_root_keytrack": "plage {0} — {1} · fondamentale {2} · keytrack {3}",
- "device.sampler.root_a_semitone_down": "Fondamentale un demi-ton plus bas",
- "device.sampler.root_a_semitone_up": "Fondamentale un demi-ton plus haut",
- "device.sampler.shift_every_note_24_semitones": "Décaler toutes les notes, ±24 demi-tons",
- "device.sampler.slide_from_the_last_note": "Glisser depuis la dernière note — en Mono, legato : sans redéclenchement",
- "device.sampler.snap_to_zero": "Caler sur le zéro",
- "device.sampler.the_cutoff_follows_the_key": "La coupure suit la touche, 0 … 100 %",
- "device.sampler.the_key_sets_the_playback": "la touche règle la vitesse de lecture",
- "device.sampler.the_level_after_everything": "Le niveau après tout le reste",
- "device.sampler.the_root_note_scroll_to": "La note fondamentale — défiler pour la changer",
- "device.sampler.the_sample_plays_at_its": "l’échantillon joue à sa propre hauteur sur la fondamentale",
- "device.sampler.the_samples_file_name_isnt": "Le nom de fichier de l’échantillon est inconnu",
- "device.sampler.the_samples_level_before_the": "Le niveau de l’échantillon avant l’enveloppe",
- "device.sampler.the_voices_level": "Le niveau des voix",
- "device.sampler.trim_silence": "Rogner le silence",
- "device.sampler.velocity_sets_the_level_the": "La vélocité règle le niveau — la quantité est le VEL → VOL du rail",
- "device.scale.an_octave_drag_or_scroll": "{0} — ± une octave, glisser ou défiler la note pour les demi-tons, ⌥-clic sur la note pour la saisir, double-clic pour réinitialiser. Les notes hors de la plage passent telles quelles.",
- "device.scale.clear_the_scale_down_to": "Réduire la gamme à la fondamentale (Custom)",
- "device.scale.click_a_note_to_add": "Cliquer une note pour l’ajouter à la gamme ou l’en retirer (la gamme passe en Custom)",
- "device.scale.custom_your_own_notes_click": "Custom : vos propres notes — cliquer la carte des notes pour modifier",
- "device.scale.empty_notes_pass": "vide · les notes passent",
- "device.scale.fold_where_an_out_of": "Fold — où va une note hors gamme : la note de gamme la plus proche (à égalité, vers le haut), celle du dessous ou celle du dessus",
- "device.scale.follow_key_from_input": "Follow key · depuis l’entrée",
- "device.scale.follow_key_the_root_moves": "Follow key — la fondamentale se déplace vers la tonalité qui correspond le mieux à ce qui est joué (en gardant le type de gamme)",
- "device.scale.last_in_out_caps": "Dernière entrée → sortie",
- "device.scale.learn_play_the_notes_of": "Learn — jouer les notes de la gamme ; elles passent intactes et deviennent la gamme Custom. Cliquer à nouveau pour terminer.",
- "device.scale.notes": "{0} {1} · {2} notes",
- "device.scale.notes_fold": "{0} {1} · {2} notes · fold {3} · ",
- "device.scale.notes_n": "{0} — {1} notes",
- "device.scale.of_12_remapped": "{0} sur 12 réassignées",
- "device.scale.root_click_the_arrows_or": "Root — cliquer les flèches ou défiler",
- "device.scale.the_key_in_effect_root": "La tonalité en vigueur : fondamentale et gamme",
- "device.scale.the_last_note_played_and": "La dernière note jouée et ce qu’elle est devenue",
- "device.shutter.clear_every_step": "Effacer tous les pas",
- "device.shutter.click_to_type": " · ⌥-clic pour saisir",
- "device.shutter.clock_sync_locks_the_pattern": "Clock — Sync cale le motif sur les mesures du morceau, Free le fait tourner en Hz",
- "device.shutter.closes_to_silence": "se ferme jusqu’au silence",
- "device.shutter.complexity_how_busy_and_varied": "Complexity — le degré de densité et de variété que Rnd donne au motif",
- "device.shutter.copy_the_steps": "Copier les pas",
- "device.shutter.depth_how_far_an_empty": "Depth — de combien un pas vide baisse le signal",
- "device.shutter.detector_filter_the_key_goes": "Detector filter — la clé passe par le passe-bande (onglet Sidechain) avant le détecteur",
- "device.shutter.detector_filter_the_key_goes_2": "Detector filter — la clé passe par le passe-bande avant le détecteur",
- "device.shutter.detector_full_band": "Détecteur · pleine bande",
- "device.shutter.ducks_to_silence": "descend jusqu’au silence",
- "device.shutter.external_sidechain_the_detector_listens": "Sidechain externe — le détecteur écoute la source de clé au lieu de cette piste",
- "device.shutter.floor_the_level_when_closed": "Floor — le niveau une fois fermé (−∞ = silence) ; en Duck, de combien le signal descend",
- "device.shutter.gain_reduction_how_far_the": "Gain reduction — de combien le gate baisse le signal en ce moment",
- "device.shutter.gate_envelope_trigger": "Gate envelope · trigger",
- "device.shutter.gated_the_pattern_plays_only": "Gated — le motif ne joue que tant que le gate de seuil est ouvert (gate × motif)",
- "device.shutter.internal_this_track": "Interne — cette piste",
- "device.shutter.key_source_internal_keys_off": "Key source — Internal se déclenche sur cette piste ; choisir une autre piste, ou l’un de ses pads ou chaînes, pour gater ou ducker contre elle",
- "device.shutter.levels_4_8_or_16": "Levels — 4, 8 ou 16 hauteurs sur lesquelles un pas se cale",
- "device.shutter.listen_hear_the_key_as": "Listen — écouter la clé comme l’entend le détecteur (après son filtre), pour régler la bande",
- "device.shutter.live_the_graph_follows_the": "Live — le graphique suit l’audio ; cliquer pour figer l’image",
- "device.shutter.lookahead_0_1_or_5": "Lookahead — 0, 1 ou 5 ms",
- "device.shutter.lookahead_the_gate_opens_this": "Lookahead — le gate s’ouvre aussi tôt avant l’arrivée du transitoire (la piste est retardée d’autant)",
- "device.shutter.map_pattern_out": " → Map (Pattern Out)",
- "device.shutter.map_pattern_out_2": "Map → Pattern Out",
- "device.shutter.mode_gate_lets_the_signal": "Mode — Gate laisse passer le signal au-dessus du seuil ; Duck le baisse tant que la clé est au-dessus",
- "device.shutter.mouse_tool_for_the_grid": "Outil souris pour la grille",
- "device.shutter.one_opening_attack_hold_release": "Une ouverture : attaque, maintien, relâchement dans la forme choisie, jusqu’au plancher (inversé pour Duck). Glisser un nœud latéralement pour son temps, le plancher turquoise vers le haut ou le bas ; double-clic pour réinitialiser, ⌥-clic pour saisir.",
- "device.shutter.only_while_gate_open": "Uniquement gate ouvert",
- "device.shutter.paste_copied_steps_fitted_to": "Coller les pas copiés (ajustés à la grille)",
- "device.shutter.pattern_shapes_the_arrows_step": "Formes de motifs — les flèches les parcourent (ajustées à la grille)",
- "device.shutter.peak_hold_the_detector_holds": "Peak hold — le détecteur maintient chaque crête plus longtemps, pour que les notes graves et les ondes lentes ne fassent pas trembler le gate",
- "device.shutter.range_how_far_the_gate": "Range — de combien le gate se ferme ou le duck descend (−∞ = jusqu’au bout)",
- "device.shutter.rate_how_long_the_whole": "Rate — la durée du motif entier : 1/4 … 4 mesures en Sync, 4 … 0,25 Hz en Free",
- "device.shutter.reset_clear_the_peak_reduction": "Reset — efface la réduction maximale, le compte d’ouvertures et l’historique",
- "device.shutter.retrig_every_midi_note_on": "Retrig — chaque note MIDI de cette piste (ou de la piste de clé) relance le motif",
- "device.shutter.retrig_on_midi_note": "Redéclencher sur note MIDI",
- "device.shutter.retrigger_trigger_mode_each_hit": "Retrigger — mode déclenché : chaque frappe lance une attaque → maintien → relâchement, quelle que soit la durée pendant laquelle le signal reste au-dessus du seuil",
- "device.shutter.return_how_far_under_the": "Return — de combien la clé doit passer sous le seuil avant que le gate ne se ferme (évite les battements)",
- "device.shutter.roll_a_new_pattern_complexity": "Tirer un nouveau motif — Complexity règle sa densité et sa variété",
- "device.shutter.sc_eq_the_detector_hears": "SC EQ — le détecteur entend la clé à travers son passe-bande ; off = pleine bande",
- "device.shutter.shape_linear_straight_ramps_over": "Shape — Linear : rampes droites sur les durées ; Log : la courbe classique à un pôle ; Snap : reste ouvert, puis se ferme net",
- "device.shutter.signal_and_duck": "Signal et duck",
- "device.shutter.signal_and_gate": "Signal et gate",
- "device.shutter.signal_tab_click_to_change": "Onglet Signal : cliquer pour changer la fenêtre — ",
- "device.shutter.smooth_ramps_into_each_step": "Smooth — monte en rampe vers chaque pas au lieu de sauter (jusqu’à un demi-pas)",
- "device.shutter.steps_8_16_or_32": "Steps — 8, 16 ou 32 (le motif est étiré pour s’y adapter)",
- "device.shutter.swing_every_second_step_comes": "Swing — un pas sur deux arrive en retard",
- "device.shutter.target_off_volume_the_pattern": "Target — Off ; Volume : le motif gate l’audio ; Map : l’audio n’est pas touché et le motif pilote Pattern Out, une source CV de la vue Modulaire",
- "device.shutter.the_detectors_band_pass_teal": "Le passe-bande du détecteur (turquoise) — seule cette partie de la clé ouvre le gate — au-dessus de la réduction dans la fenêtre (neutre). Glisser les nœuds latéralement ; double-clic pour réinitialiser, ⌥-clic pour saisir.",
- "device.shutter.the_input_teal_and_what": "L’entrée (turquoise) et ce qui passe (neutre) sur la fenêtre, avec le seuil (pointillés) et le point où le gate se referme (pointillés). Glisser une ligne vers le haut ou le bas ; double-clic pour la réinitialiser, ⌥-clic pour la saisir.",
- "device.shutter.the_level_the_detector_compares": "Le niveau que compare le détecteur — l’entrée de cette piste, ou la clé quand un sidechain externe le pilote ; le repère en pointillés est le seuil",
- "device.shutter.the_step_pattern_each_column": "Le motif de pas — chaque colonne est le niveau d’un pas, la ligne est le gain qui en résulte (smooth et swing l’infléchissent). Draw règle les pas, Line trace une rampe, Erase efface, Flip bascule actif / inactif.",
- "device.shutter.volume_gated": " → Volume · gaté",
- "device.shutter.what_the_gate_is_doing": "Ce que fait le gate en ce moment — fermé, attaque, ouvert, maintien ou relâchement — et son gain",
- "device.sidechain.frozen_its_parts_dont_play": "Gelée — ses parties ne jouent pas tant que la piste n’est pas dégelée",
- "device.sidechain.missing": "{0} · manquant",
- "device.sidechain.no_free_routes_every_sidechain": "Aucune route libre — toutes les routes de sidechain sont utilisées",
- "device.sidechain.part": "Partie {0}",
- "device.sidechain.the_keyed_part_was_deleted": "La partie pilotée a été supprimée — annuler la rétablit",
- "device.size_s_260_260_l": "Taille : S (260 × 260) / L (700 × 260)",
- "device.strata.at_bar_end": "en fin de mesure",
- "device.strata.of_bars": { "one": "sur {0} mesure", "other": "sur {0} mesures" },
- "device.strata.of_one_cycle_shown": "{0} sur {1} · un cycle affiché",
- "device.strata.onto_layer": "sur la couche {0}",
- "device.strata.press_record_to_lay_down": "Appuyer sur Enregistrer pour poser la première boucle",
- "device.strata.set_tempo_from_loop": "Régler le tempo d’après la boucle",
- "device.synth.cycles_unison": "{0} · {1} cycles · unisson {2}",
- "device.synth.filter_off_the_oscillator_goes": "Filtre désactivé — l’oscillateur va directement à l’amplificateur",
- "device.synth.vel_vol_off": "Vél. → Vol off",
- "device.utility.bass_mono_off": "bass mono désactivé",
- "device.utility.both_phases_inverted": "les deux phases inversées",
- "device.utility.channel_stereo_left_or_right": "Channel — Stereo ; Left ou Right des deux côtés ; Swap échange les côtés",
- "device.utility.gain_match_moves_gain_once": "Gain match — règle Gain une fois pour que la sortie atteigne la référence (le niveau d’entrée, ou Target) sur les 3 dernières secondes, dans l’unité du vumètre",
- "device.utility.input_and_output": "Entrée et sortie",
- "device.utility.input_peak_60_0_dbfs": "Crête d’entrée, −60 … 0 dBFS",
- "device.utility.input_teal_and_output_neutral": "Entrée (turquoise) et sortie (neutre) sur les 8 dernières secondes dans l’unité du vumètre ; en pointillés : la cible. Glisser vers le haut ou le bas pour la cible.",
- "device.utility.invert_the_left_channels_phase": "Inverser la phase du canal gauche",
- "device.utility.invert_the_right_channels_phase": "Inverser la phase du canal droit",
- "device.utility.lows_at_the_bottom_highs": "graves en bas · aigus en haut",
- "device.utility.match_to_input": "aligner sur l’entrée",
- "device.utility.meter_lufs_s_short_term": "Meter — LUFS-S : volume à court terme (3 s, pondération K) ; Peak : crête d’échantillon ; RMS : 300 ms",
- "device.utility.mono_below_freq": "Mono below freq",
- "device.utility.mono_below_removes_the_side": "Mono below — retire le signal latéral sous la coupure, pour que les graves soient mono",
- "device.utility.mute_the_output": "Couper la sortie",
- "device.utility.out_of_phase_mono_risk": "en opposition de phase — risque en mono",
- "device.utility.output_correlation_1_mono_0": "Corrélation de sortie — +1 mono, 0 sans rapport, sous 0 en opposition de phase (s’annule en mono)",
- "device.utility.output_peak_60_0_dbfs": "Crête de sortie, −60 … 0 dBFS",
- "device.utility.pan_by_frequency_1_s": "panoramique par fréquence · fenêtre de 1 s",
- "device.utility.reset_gain_back_to_0": "Reset — Gain revient à 0 dB, et les vumètres, maintiens et l’historique des niveaux repartent de zéro",
- "device.utility.slope_of_the_mono_cutoff": "Pente de la coupure mono — 6, 12 ou 24 dB/oct ; cliquer pour changer",
- "device.utility.the_inputs_level_in_the": "Le niveau de l’entrée dans l’unité du vumètre (LUFS-S, crête 1 s ou RMS 300 ms)",
- "device.utility.the_outputs_level_in_the": "Le niveau de la sortie dans l’unité du vumètre",
- "device.utility.the_outputs_stereo_field_by": "Le champ stéréo de la sortie par fréquence sur la dernière seconde — graves en bas, aigus en haut. Plein : la position de chaque bande entre L et R ; turquoise : son étalement ; pointillés : l’étalement que le réglage de largeur donne à une bande non corrélée. Glisser latéralement pour la balance, vers le haut ou le bas pour la largeur.",
- "device.utility.the_usual_cutoffs_60_120": "Les coupures usuelles — 60, 120 ou 240 Hz (active Mono below)",
- "device.utility.the_width_over_frequency_solid": "La largeur selon la fréquence — plein : ce que font les réglages (0 % = mono, 100 % = inchangé), la zone mono ombrée ; turquoise en pointillés : la largeur mesurée de la sortie (side contre mid). Glisser latéralement pour la coupure mono, vers le haut ou le bas pour la largeur.",
- "device.utility.what_gain_match_and_level": "Ce que visent Gain match et Level match — le niveau de l’entrée, ou Target",
- "device.utility.width_by_frequency": "Largeur par fréquence",
- "device.utility.width_law_l_r_the": "Width law — L/R : le side est mis à l’échelle, donc plus large est plus fort ; M/S : mid et side sont échangés, donc le niveau reste constant (200 % = side seul)",
- "device.valve.bright_a_treble_lift_before": "Bright — une montée des aigus avant le préampli, plus forte à faible gain (le condensateur bright d’un potentiomètre de volume)",
- "device.valve.cab_by_model": "baffle selon le modèle · ",
- "device.valve.cabinet_match_follows_the_model": "Cabinet — Match suit le modèle ; 1×12 ouvert, 2×12 combo, 4×12 fermé, 1×15 basse",
- "device.valve.cabinet_match_follows_the_model_2": "Cabinet — Match suit le modèle ; les autres apportent leur propre résonance grave et leur pic de présence. Défiler pour changer.",
- "device.valve.deep_a_low_resonance_boost": "Deep — un renfort de résonance grave après le correcteur de tonalité, pour des graves plus pleins et plus serrés",
- "device.valve.even_harmonics_only": "Harmoniques paires uniquement",
- "device.valve.even_only_the_preamp_adds": "Even only — le préampli n’ajoute que des harmoniques paires : de la chaleur sans le grésillement des impaires",
- "device.valve.gain_how_hard_the_signal": "Gain — la force avec laquelle le signal attaque le préampli. Double-clic pour réinitialiser.",
- "device.valve.mic_dynamic_the_classic_close": "Mic — Dynamic : le micro proche classique ; Condenser : plus brillant, moins d’effet de proximité ; Ribbon : sombre, le plus d’effet de proximité",
- "device.valve.mic_position_at_the_cones": "Mic position — au centre du cône (brillant) ou sur son bord (plus sombre)",
- "device.valve.model_the_amps_voicing_how": "Model — le voicing de l’ampli : la force d’attaque du préampli, le nombre d’étages qui écrêtent, la fermeté des graves et le baffle associé. Défiler pour changer.",
- "device.valve.output_the_master_level_after": "Output — le niveau général après le baffle, ±12 dB. Double-clic pour réinitialiser.",
- "device.valve.the_cabinet_as_the_mic": "Le baffle tel que l’entend le micro, avec les coupures grave / aigu — en pointillés le même baffle et micro dans l’axe, au centre du cône, à 5 cm. Glisser latéralement pour désaxer le micro, vers le haut pour le rapprocher.",
- "device.valve.the_harmonics_the_preamp_adds": "Les harmoniques ajoutées par le préampli au niveau de l’entrée (la fondamentale en haut). Glisser vers le haut ou le bas pour le gain.",
- "device.valve.the_tone_stack_before_the": "Le correcteur de tonalité avant le baffle — la fermeté avant distorsion du modèle, Bright, Bass / Middle / Treble / Presence et Deep ; en pointillés, le correcteur à plat. Glisser latéralement pour la fréquence du médium, vers le haut ou le bas pour le médium.",
- "device.velocity.compand_the_same_around_the": "Compand — la même chose autour du milieu : au-dessus de 1, étire vers les bords ; en dessous de 1, resserre vers le milieu",
- "device.velocity.curve_bend_the_response_drive": "Curve — infléchit la réponse : Drive au-dessus de 1 remonte les notes douces, en dessous de 1 les abaisse",
- "device.velocity.drag_up_down_shift_for": "Glisser vers le haut / bas, Maj pour les pas fins, double-clic pour réinitialiser",
- "device.velocity.every_note_at_this_velocity": "toutes les notes à cette vélocité",
- "device.velocity.fixed_every_note_comes_out": "Fixed — toutes les notes sortent à une seule vélocité",
- "device.velocity.input_across_output_up_dashed": "Entrée en abscisse, sortie en ordonnée · pointillés — la plage Out · bande — Random · points — les dernières notes",
- "device.velocity.input_velocity_across_output_up": "Vélocité d’entrée en abscisse, de sortie en ordonnée. Pointillés — la plage Out ; la bande — où Random peut placer une note ; points — les dernières notes jouées",
- "device.velocity.last": "dernière {0} → {1}",
- "device.velocity.out_range_drag_a_handle": "Out range — glisser une poignée, ⌥-clic pour la saisir, double-clic pour revenir à 1–127",
- "device.velocity.random_amount_0_64_velocity": "Quantité aléatoire, ±0–64 de vélocité — glisser vers le haut / bas, double-clic pour réinitialiser",
- "device.velocity.random_both_ways_only_up": "Aléatoire dans les deux sens, seulement vers le haut, ou seulement vers le bas",
- "device.velocity.random_both_ways_up_down": "Random : deux sens → haut → bas → désactivé — cliquer pour avancer, Maj-clic pour reculer",
- "device.velocity.random_spread_each_notes_velocity": "Random — disperse la vélocité de chaque note (la quantité est conservée tant qu’il est désactivé)",
- "device.velocity.soft_notes_louder": "notes douces plus fortes",
- "device.velocity.soft_notes_quieter": "notes douces plus faibles",
- "device.velocity.squeezed_to_the_middle": "resserré vers le milieu",
- "device.velocity.stretched_to_the_edges": "étiré vers les bords",
- "device.velocity.the_last_12_notes_outline": "Les 12 dernières notes : contour — vélocité en entrée, aplat — vélocité en sortie",
- "device.velocity.velocity_mode_curve_compand_fixed": "Mode de vélocité : Curve / Compand / Fixed — cliquer pour le suivant, Maj-clic pour le précédent",
- "device.vintage.analog_stage_a_console_style": "Étage analogique — un écrêtage doux façon console après la saturation (cliquer à nouveau pour aucun)",
- "device.vintage.auto_comp_the_output_level": "Auto-comp — le niveau de sortie suit celui de l’entrée, quelle que soit la saturation",
- "device.vintage.character_the_era_the_signal": "Character — l’époque que traverse le signal : sa saturation, sa tonalité, sa bande passante et la quantité de souffle, de craquements, de wow et de flutter. Défiler pour changer.",
- "device.vintage.drive_how_hard_the_signal": "Drive — la force avec laquelle le signal attaque la saturation. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.vintage.even_harmonics_only": "Harmoniques paires uniquement",
- "device.vintage.sync_the_wow_follows_the": "Sync — le wow suit le tempo : une oscillation toutes les 4 mesures … 1/8 (RATE la choisit)",
- "device.vintage.the_harmonics_the_saturation_adds": "Les harmoniques ajoutées par la saturation au niveau de l’entrée (la fondamentale en haut), face au plancher de souffle en turquoise. Glisser vers le haut ou le bas pour le drive, ⌥-clic pour le saisir.",
- "device.vintage.the_pitch_drift_over_the": "La dérive de hauteur sur les quatre dernières secondes — wow en neutre, flutter en turquoise. Glisser vers le haut ou le bas pour la profondeur de ce qui est choisi au-dessus, latéralement pour sa vitesse ; ⌥-clic pour les saisir.",
- "device.vintage.the_transfer_curve_the_saturation": "La courbe de transfert de la saturation — niveau d’entrée en abscisse, sortie en ordonnée ; en pointillés la ligne sèche, en turquoise ce qu’on entend avec Mix et Output, le point où se situe la crête d’entrée. Glisser vers le haut ou le bas pour le drive, ⌥-clic pour le saisir.",
- "device.vintage.tone_model_warm_the_eras": "Tone model — Warm : l’inclinaison propre à l’époque et la bosse de tête ; Flat : le potentiomètre TONE seul ; Dark : une inclinaison plus basse et plus sombre",
- "device.vintage.tube_stage_a_warm_asymmetric": "Étage à lampe — un étage à lampe chaud et asymétrique après la saturation (cliquer à nouveau pour aucun)",
- "device.vintage.wear_follows_input": "Wear suit l’entrée",
- "device.vintage.wear_the_age_of_the": "Wear — l’âge du support : une bande plus étroite, plus de souffle et de craquements, un flutter erratique. ⌥-clic pour saisir, double-clic pour réinitialiser.",
- "device.vintage.what_the_window_shows_and": "Ce que montre la fenêtre et ce qu’un glissement y modifie",
- "device.vocoder.attack_how_fast_a_band": "Attack — la vitesse d’ouverture d’une bande, 0,5 … 100 ms",
- "device.vocoder.bands_how_many_bands_8": "Bands — le nombre de bandes, 8 … 32 : moins, c’est plus robotique ; plus, c’est plus clair",
- "device.vocoder.carrier_track_the_track_the": "Piste porteuse — la piste que la voix module quand Carrier est Track ; cette piste et ses groupes ne sont pas proposés",
- "device.vocoder.carrier_what_the_voice_shapes": "Carrier — ce que la voix module : une dent de scie interne (à Pitch), du bruit, ou une autre piste choisie ci-dessous",
- "device.vocoder.formant_moves_the_carriers_bands": "Formant — décale les bandes de la porteuse par rapport à celles du modulateur, ±12 st : vers le haut, le son paraît plus petit ; vers le bas, plus grand",
- "device.vocoder.gain_the_output_level_12": "Gain — le niveau de sortie, ±12 dB",
- "device.vocoder.high_the_highest_bands_edge": "High — le bord de la bande la plus haute, 2 … 20 kHz",
- "device.vocoder.hold_freezes_every_band_where": "Hold — fige chaque bande là où elle est ; la porteuse continue de sonner à travers",
- "device.vocoder.low_the_lowest_bands_edge": "Low — le bord de la bande la plus basse, 20 Hz … 1 kHz",
- "device.vocoder.mix_the_carrier_as_it": "Mix — la porteuse telle qu’elle arrive face au son vocodé",
- "device.vocoder.mod_gain_trims_the_voice": "Mod gain — ajuste la voix avant que les bandes ne l’entendent, ±24 dB",
- "device.vocoder.pick_a_carrier_track_until": "Choisir une piste porteuse · d’ici là le son passe tel quel",
- "device.vocoder.pitch_the_internal_saws_note": "Pitch — la note de la dent de scie interne, C0 … C7",
- "device.vocoder.q_how_narrow_each_band": "Q — l’étroitesse de chaque bande, 1 … 10",
- "device.vocoder.release_how_fast_a_band": "Release — la vitesse de fermeture d’une bande, 5 … 1000 ms",
- "device.vocoder.the_modulator_is_the_sound": "Le modulateur est le son de la piste sur laquelle se trouve le vocoder — la voix",
- "device.vocoder.the_modulators_level_in_each": "Le niveau du modulateur dans chaque bande (barres) et celui de la porteuse (turquoise). Glisser un bord pour déplacer Low ou High ; ⌥-clic sur un bord pour le saisir, double-clic pour le réinitialiser.",
- "device.vocoder.the_vocoders_output_level": "Le niveau de sortie du vocoder",
- "device.vocoder.the_voices_level_after_mod": "Le niveau de la voix après Mod gain",
- "device.vocoder.tilt_brightens_or_darkens_the": "Tilt — éclaircit (ou assombrit) la dent de scie ou la piste porteuse autour de 1 kHz avant les bandes, ±12 dB",
- "device.vocoder.unvoiced_adds_noise_where_the": "Unvoiced — ajoute du bruit là où le modulateur siffle, pour que les consonnes restent claires",
- "device.vocoder.where_the_carrier_track_is": "Où la piste porteuse est prélevée : avant ses effets et son fader, ou après. Pre continue d’alimenter même piste coupée",
- "device.volt.8_slots_assigned": "8 emplacements · {0} assignés",
- "device.volt.click_for_the_next_target": "Cliquer pour la cible suivante, clic droit pour la précédente",
- "device.volt.drag_a_cell_up_adds": "glisser une cellule — vers le haut ajoute, vers le bas retranche · ⌥-clic pour saisir · double-clic pour effacer",
- "device.volt.vibrato_always_rides_the_pitch": "le vibrato suit toujours la hauteur",
- "device.volt.zero_every_route_in_the": "Remettre à zéro toutes les routes de la matrice",
- "device_chain.active_click_to_bypass": "Actif — cliquer pour contourner",
- "device_chain.add_an_audio_effect_search": "Ajouter un effet audio : chercher dans le navigateur, ou déposer un appareil ici",
- "device_chain.bypassed_click_to_enable": "Contourné — cliquer pour activer",
- "device_chain.clipboard.a_drum_rack_cant_be": "Un Drum Rack ne peut pas être dégroupé",
- "device_chain.clipboard.a_plug_in_cant_go": "Un plug-in ne peut pas aller dans un MIDI Effect Rack",
- "device_chain.clipboard.a_rack_cant_go_inside": "Un rack ne peut pas aller dans un autre rack",
- "device_chain.clipboard.an_instrument_rack_cant_go": "Un Instrument Rack ne peut pas aller dans un autre Instrument Rack",
- "device_chain.clipboard.audio_effect": "Effet audio · {0}",
- "device_chain.clipboard.couldnt_paste_a_device_failed": "Impossible de coller : un appareil n’a pas pu se charger.",
- "device_chain.clipboard.couldnt_paste_the_instrument": "Impossible de coller l’instrument.",
- "device_chain.clipboard.delete_track": "Supprimer la piste",
- "device_chain.clipboard.deleted_devices": "{0} appareils supprimés",
- "device_chain.clipboard.device": "Appareil",
- "device_chain.clipboard.devices": { "one": "{0} appareil", "other": "{0} appareils" },
- "device_chain.clipboard.group_into_rack": "Grouper dans un rack",
- "device_chain.clipboard.its_macros_and_chain_settings": " — ses macros et réglages de chaîne ont été abandonnés",
- "device_chain.clipboard.midi_effect": "Effet MIDI · {0}",
- "device_chain.clipboard.nothing_to_paste": "Rien à coller.",
- "device_chain.clipboard.only_a_rack_with_one": "Seul un rack à une seule chaîne peut être dégroupé",
- "device_chain.clipboard.only_an_instrument_track_takes": "Seule une piste d’instrument accepte des effets MIDI et un instrument",
- "device_chain.clipboard.only_an_instrument_track_takes_2": "Seule une piste d’instrument accepte un instrument.",
- "device_chain.clipboard.paste_an_instrument_on_an": "Coller un instrument sur une carte d’instrument.",
- "device_chain.clipboard.pasted": "{0} collé",
- "device_chain.clipboard.pasted_devices": "{0} appareils collés",
- "device_chain.clipboard.pasted_devices_skipped_this_track": "{0} appareils collés, {1} ignorés car cette piste ne peut pas les accepter",
- "device_chain.clipboard.put_devices_in": "Placer {0} appareils dans {1}",
- "device_chain.clipboard.put_in": "Placer {0} dans {1}",
- "device_chain.clipboard.select_a_rack_to_take": "Sélectionner un rack pour en sortir les appareils",
- "device_chain.clipboard.select_devices_next_to_each": "Sélectionner des appareils côte à côte pour les grouper",
- "device_chain.clipboard.select_devices_to_put_them": "Sélectionner des appareils pour les placer dans un rack",
- "device_chain.clipboard.selected": "Sélection",
- "device_chain.clipboard.some_devices_cant_be_duplicated": "Certains appareils ne peuvent pas être dupliqués",
- "device_chain.clipboard.the_racks_chain_has_no": "La chaîne du rack n’a aucun instrument à remettre",
- "device_chain.clipboard.these_devices_cant_be_copied": "Ces appareils ne peuvent pas être copiés, ils n’ont donc pas été coupés.",
- "device_chain.clipboard.these_devices_cant_be_grouped": "Ces appareils ne peuvent pas être groupés",
- "device_chain.clipboard.this_device_cant_be_copied": "Cet appareil ne peut pas être copié, il n’a donc pas été coupé.",
- "device_chain.clipboard.this_rack_cant_be_ungrouped": "Ce rack ne peut pas être dégroupé",
- "device_chain.clipboard.this_track_cant_take_the": "Cette piste ne peut pas accepter les appareils copiés.",
- "device_chain.clipboard.took_devices_out_of_the": "{0} appareils sortis du rack",
- "device_chain.clipboard.took_the_device_out_of": "Appareil sorti du rack",
- "device_chain.clipboard.ungroup_rack": "Dégrouper le rack",
- "device_chain.clipboard.with_the_instrument": "Avec l’instrument",
- "device_chain.fold.double_click_to_unfold": "{0} — double-clic pour déplier",
- "device_chain.fold.unfold": "Déplier",
- "device_chain.instruments.drums_pads": { "one": "Drums · {0} pad", "other": "Drums · {0} pads" },
- "device_chain.instruments.presets_are_unavailable": "Les préréglages ne sont pas disponibles.",
- "device_chain.move.move_to_track": "Déplacer vers la piste",
- "device_chain.move.plug_ins": "Plug-ins",
- "device_chain.move.replace": "Remplacer…",
- "device_chain.no_return_tracks": "Aucune piste de retour",
- "device_chain.rack_chains": { "one": "Rack · {0} chaîne", "other": "Rack · {0} chaînes" },
- "device_chain.remove_device": "Retirer l’appareil",
- "device_chain.remove_track": "Retirer la piste",
- "device_chain.select_a_track": "Sélectionner une piste",
- "device_chain.shell.click_to_select_double_click": "Cliquer pour sélectionner · double-clic pour replier · clic droit pour remplacer, copier ou déplacer",
- "device_chain.shell.compare": "Comparer : {0}",
- "device_chain.shell.copy_a_to_b": "Copier A vers B",
- "device_chain.shell.copy_b_to_a": "Copier B vers A",
- "device_chain.shell.double_click_to_fold_right": "Double-clic pour replier · clic droit pour plus d’options",
- "device_chain.shell.drag_to_reorder_double_click": "Glisser pour réordonner · double-clic pour replier · clic droit pour A/B, déplacer et supprimer",
- "device_chain.shell.fold": "Replier",
- "device_chain.shell.init": "Init",
- "device_chain.shell.mono": "Mono",
- "device_chain.shell.move_left": "Déplacer vers la gauche",
- "device_chain.shell.move_right": "Déplacer vers la droite",
- "device_chain.shell.next_preset": "Préréglage suivant",
- "device_chain.shell.off_click_to_turn_the": "Désactivé — cliquer pour activer l’instrument",
- "device_chain.shell.on_click_to_turn_the": "Activé — cliquer pour désactiver l’instrument",
- "device_chain.shell.preset": "Préréglage : {0}",
- "device_chain.shell.previous_preset": "Préréglage précédent",
- "device_insert.a_drum_rack_takes_kits": "Un Drum Rack accepte des kits et des instruments ; charger un préréglage d’instrument sur un pad depuis sa carte.",
- "device_insert.added_chain": "Chaîne {0} ajoutée",
- "device_insert.added_on_a_new_audio": "{0} ajouté sur une nouvelle piste audio (piste {1})",
- "device_insert.added_pad": "Pad {0} ajouté",
- "device_insert.added_to_track": "{0} ajouté à la piste {1}",
- "device_insert.added_track": "{0} ajouté (piste {1})",
- "device_insert.all_16_pads_are_used": "Les 16 pads sont utilisés.",
- "device_insert.applied_preset": "Préréglage {0} appliqué",
- "device_insert.cant_go_on_a_track": "{0} ne peut pas aller sur une piste.",
- "device_insert.changed_instrument_to": "Instrument remplacé par {0}",
- "device_insert.changed_instrument_to_track": "Instrument remplacé par {0} (piste {1})",
- "device_insert.couldnt_add_a_track_for": "Impossible d’ajouter une piste pour {0}.",
- "device_insert.drop_failed": "Échec du dépôt : {0}",
- "device_insert.drop_midi_files_onto_the": "Déposer des fichiers MIDI sur l’arrangement ou un emplacement de session.",
- "device_insert.drop_onto_a_track": "Déposer sur une piste.",
- "device_insert.drop_samples_onto_the_arrangement": "Déposer des échantillons sur l’arrangement.",
- "device_insert.failed_to_load_effect": "Échec du chargement de l’effet.",
- "device_insert.kits_are_unavailable": "Les kits ne sont pas disponibles.",
- "device_insert.loaded": "{0} chargé",
- "device_insert.loaded_kit": "Kit {0} chargé",
- "device_insert.loaded_root": "{0} chargé · fondamentale {1}",
- "device_insert.midi_effects_need_an_instrument": "Les effets MIDI nécessitent une piste d’instrument.",
- "device_insert.midi_effects_need_an_instrument_2": "Les effets MIDI nécessitent une piste d’instrument : ajouter d’abord un instrument.",
- "device_insert.presets_are_unavailable": "Les préréglages ne sont pas disponibles.",
- "device_insert.replaced_with": "Remplacé par {0}",
- "device_selection.midi_and_audio_effects_go": "Les effets MIDI et audio ne vont dans un même rack qu’avec l’instrument entre eux",
- "device_selection.select_devices_next_to_each": "Sélectionner des appareils côte à côte pour les grouper",
- "download_jobs.cancelling": "Annulation…",
- "download_jobs.installing_failed": "Échec de l’installation de {0} : {1}",
- "download_jobs.installing_was_cancelled": "L’installation de {0} a été annulée.",
- "dropout_counter.dropouts": { "one": "{0} décrochage", "other": "{0} décrochages" },
- "drum_pattern.bars": "Barres",
- "drum_pattern.click_to_place_shift_click": "clic pour placer · ⇧-clic pour les accents · glisser pour peindre",
- "drum_pattern.drop_samples_on_the_drum": "Déposer des échantillons sur les pads du Drum Rack dans Appareils, puis les programmer ici pas à pas.",
- "drum_pattern.no_pads_loaded": "Aucun pad chargé",
- "drum_pattern.pads": { "one": "{0} pad", "other": "{0} pads" },
- "drum_pattern.play_and_show_its_velocity": "Jouer {0} · {1} et afficher son couloir de vélocité",
- "drum_pattern.steps": { "one": "{0} pas", "other": "{0} pas" },
- "editing.snap_grid.2_bars": "2 mesures",
- "editing.snap_grid.4_bars": "4 mesures",
- "editing.snap_grid.auto": "Auto · {0}",
- "export.16_bit_only": "16 bits uniquement",
- "export.1_file_mb_offline_render": "≈ 1 fichier · {0:0.0} Mo · rendu hors ligne",
- "export.add_1_bar_release_tail": "Ajouter une queue de relâchement d’1 mesure",
- "export.bar_beat_sixteenth_counted_from": "Mesure.temps.double-croche, comptés à partir de 1 — p. ex. 5.1 ou 5.3.2",
- "export.bit_depth": "Profondeur de bits",
- "export.custom": "Personnalisé",
- "export.dither": "Dithering",
- "export.end": "Fin",
- "export.export": "Exporter {0}",
- "export.export_audio": "Exporter l’audio",
- "export.export_stems": "Exporter les stems",
- "export.export_wav": "Exporter en WAV",
- "export.format": "Format",
- "export.full_song": "Morceau entier",
- "export.normalize_1_dbtp": "Normaliser à −1 dBTP",
- "export.not_a_position_type_bar": "Position invalide : saisir mesure.temps, comme 5.1",
- "export.one_file_per_track_mb": "un fichier par piste · {0:0.0} Mo chacun · rendu hors ligne",
- "export.one_file_per_track_post": "· un fichier par piste, post-fader",
- "export.positions_are_bar_beat_sixteenth": "Les positions s’écrivent mesure.temps.double-croche, comptées à partir de 1 comme dans le transport : 5 ou 5.1 est le début de la mesure 5, 5.3 son troisième temps. L’export s’arrête à la position de fin, donc 1 à 5 fait quatre mesures.",
- "export.quality": "Qualité",
- "export.sample_rate": "Fréquence d’échantillonnage",
- "export.the_end_must_be_after": "La fin doit être après le début",
- "history.add_note": "Ajouter une note…",
- "history.clean_up_the_history": "Nettoyer l’historique",
- "history.couldnt_change_the_version": "Impossible de changer de version : {0}",
- "history.current": "Actuelle",
- "history.current_version": "Version actuelle",
- "history.delete_audio_that_only_this": "Supprimer {0} ? L’audio utilisé uniquement par cette version est aussi supprimé du dossier du projet. Cette action est irréversible.",
- "history.delete_the_selected_versions_and": "Supprimer les versions sélectionnées et l’audio que seules elles utilisent",
- "history.delete_unnamed_versions": "Supprimer les versions sans nom",
- "history.delete_unnamed_versions_2": "Supprimer les versions sans nom…",
- "history.delete_unnamed_versions_n": { "one": "Supprimer {0} version sans nom…", "other": "Supprimer {0} versions sans nom…" },
- "history.delete_version": "Supprimer la version",
- "history.delete_version_2": "Supprimer la version…",
- "history.delete_versions": "Supprimer les versions",
- "history.delete_versions_and_the_audio": { "one": "Supprimer {0} version et l’audio qu’elle seule utilise ? La version actuelle, la dernière version de chaque branche et toute version nommée, étoilée ou annotée restent. Cette action est irréversible.", "other": "Supprimer {0} versions et l’audio que seules elles utilisent ? La version actuelle, la dernière version de chaque branche et toute version nommée, étoilée ou annotée restent. Cette action est irréversible." },
- "history.delete_versions_audio_that_only": { "one": "Supprimer {0} version ? L’audio qu’elle seule utilise est aussi supprimé du dossier du projet. Cette action est irréversible.", "other": "Supprimer {0} versions ? L’audio que seules elles utilisent est aussi supprimé du dossier du projet. Cette action est irréversible." },
- "history.delete_versions_n": { "one": "Supprimer {0} version…", "other": "Supprimer {0} versions…" },
- "history.deleted_versions": { "one": "{0} version supprimée", "other": "{0} versions supprimées" },
- "history.each_save_adds_a_version": "Chaque enregistrement ajoute une version ici.",
- "history.edit_note": "Modifier la note…",
- "history.freed": "{0} · {1} libérés",
- "history.its_versions_cant_be_listed": "Ses versions ne peuvent pas être listées tant que le fichier .history/versions.json n’est pas réparé.",
- "history.name": "Nommer…",
- "history.name_version": "Nommer la version",
- "history.no_starred_versions_yet_right": "Aucune version étoilée pour l’instant. Clic droit sur une version puis « Étoiler ».",
- "history.nota": "Nota {0}",
- "history.older_versions_take_on_disk": "{0} · les anciennes versions occupent {1} sur le disque",
- "history.open_as_copy": "Ouvrir comme copie…",
- "history.open_copy": "Ouvrir une copie",
- "history.open_this_version_as_a": "Ouvrir cette version comme nouveau projet, en laissant celui-ci tel quel",
- "history.remove_name": "Retirer le nom",
- "history.remove_note": "Retirer la note",
- "history.remove_star": "Retirer l’étoile",
- "history.save_the_project_to_start": "Enregistrer le projet pour commencer son historique.",
- "history.saved_by_a_newer_nota": "Enregistré par une version plus récente de Nota — mettre à jour pour l’ouvrir.",
- "history.show_all_versions": "Afficher toutes les versions",
- "history.show_starred_versions_only": "Afficher seulement les versions étoilées",
- "history.star": "Étoiler",
- "history.switch": "Basculer",
- "history.switch_the_project_to_this": "Basculer le projet vers cette version",
- "history.switch_to_another_version_to": "Basculer vers une autre version pour supprimer celle-ci",
- "history.switch_to_this_version": "Basculer vers cette version",
- "history.the_current_version_stays": "La version actuelle reste",
- "history.the_current_version_stays_2": "La version actuelle reste.",
- "history.the_project_is_at_this": "Le projet est à cette version",
- "history.version": "Version",
- "history.version_history_is_turned_off": "L’historique des versions est désactivé dans les Réglages.",
- "history.version_name": "Nom de la version",
- "history.version_note": "Note de version",
- "history.versions": "Versions",
- "history.versions_n": { "one": "{0} version", "other": "{0} versions" },
- "history.what_changed_in_this_version": "Qu’est-ce qui a changé dans cette version ?",
- "kits.drum_kit.couldnt_create_a_drum_rack": "Impossible de créer une piste Drum Rack.",
- "kits.drum_kit.couldnt_create_a_nota_rhythm": "Impossible de créer une piste Nota Rhythm.",
- "kits.drum_kit.unknown_drum_kit": "Kit de batterie inconnu.",
- "lens.nota_lens": "Nota Lens · {0}",
- "linux_file_dialogs.the_system_file_dialog_answered": "la boîte de dialogue système a répondu sans s’afficher",
- "linux_file_dialogs.the_system_file_dialog_didnt": "la boîte de dialogue système ne s’est pas ouverte en {0:0} s",
- "linux_file_dialogs.the_system_file_dialog_failed": "échec de la boîte de dialogue système : {0}",
- "linux_file_dialogs.using_notas_built_in_file": "Utilisation de la boîte de dialogue de fichiers intégrée de Nota : {0}. Vérifier xdg-desktop-portal et son moteur FileChooser.",
- "main.adaptive_grid": "Grille adaptative",
- "main.added_to_slot": "{0} ajouté à l’emplacement",
- "main.all_return_buses_are_in": "Tous les bus de retour sont utilisés.",
- "main.arrangement": "Arrangement",
- "main.asio_driver_couldnt_start_using": "Le pilote ASIO ‘{0}’ n’a pas pu démarrer — WASAPI utilisé. {1}",
- "main.audio_asio_hz_frames": "Audio : ASIO · {0} · {1:0} Hz · {2} échantillons",
- "main.audio_device_error": "Erreur du périphérique audio : {0}",
- "main.audio_driver_settings_changed_frames": "Audio : réglages du pilote modifiés · {0} échantillons",
- "main.audio_dropout": "⚠ Décrochage audio ({0})",
- "main.audio_dropouts_since_the_device": "Décrochages audio depuis le démarrage du périphérique : des tampons que Nota n’a pas pu remplir à temps, audibles sous forme de claquements ou de trous. S’ils persistent, augmenter la taille du tampon ou geler les pistes lourdes. Cliquer pour réinitialiser",
- "main.audio_format.audio_settings": "Réglages audio…",
- "main.audio_format.buffer_size": "Taille de la mémoire tampon",
- "main.audio_format.device_default": "Par défaut du périphérique",
- "main.audio_format.driver_settings": "Réglages du pilote…",
- "main.audio_format.exclusive_mode_uses_the_devices": "Le mode exclusif utilise le tampon de l’appareil",
- "main.audio_format.set_in_the_asio_drivers": "À régler dans les réglages du pilote ASIO",
- "main.audio_format.stop_recording_to_change_it": "Arrêter l’enregistrement pour le modifier",
- "main.audio_hz": "Audio : {0:0} Hz",
- "main.audio_hz_frames": "Audio : {0:0} Hz · {1} échantillons",
- "main.audio_import.failed_to_load": "Échec du chargement de {0}",
- "main.audio_import.failed_to_load_n": "Échec du chargement de {0} : {1}",
- "main.audio_import.import_of_cancelled": "Import de {0} annulé",
- "main.audio_import.importing": "Import de {0}…",
- "main.audio_import.loop_warped_bpm": "boucle warpée {0} → {1} BPM",
- "main.audio_import.one_shot_not_warped": "one-shot, non warpé",
- "main.audio_import.processing": "{0} · Traitement…",
- "main.audio_import.processing_n": "{0} · Traitement… {1:0} %",
- "main.audio_import.transposed_st_to": "transposé de {0} st vers {1}",
- "main.audio_import.warped_to_tempo_bpm": "warpé au tempo ({0:0.0} BPM)",
- "main.audio_import.warping": "Warp de {0}… {1:0} %",
- "main.audio_track_arm_it_and": "Piste audio {0} — l’armer puis appuyer sur Rec pour enregistrer l’entrée",
- "main.auto_arm_selected_track": "Armement automatique de la piste sélectionnée",
- "main.bass": "Basse",
- "main.bounce_to_a_linked_audio": "Rendre vers une piste audio liée en dessous et mettre la source en veille",
- "main.browser.couldnt_delete": "Impossible de supprimer {0}",
- "main.browser.delete_preset": "Supprimer le préréglage",
- "main.browser.delete_project": "Supprimer le projet",
- "main.browser.load_failed": "Échec du chargement : {0}",
- "main.browser.move_to_the_trash": "Mettre « {0} » à la corbeille ?",
- "main.browser.moved_to_trash": "{0} mis à la corbeille",
- "main.browser.nothing_to_save_built_in": "Rien à enregistrer (le synthé intégré n’a pas d’état).",
- "main.browser.only_plug_in_chain_instruments": "Seuls les instruments à chaîne de plug-ins peuvent être enregistrés comme préréglages.",
- "main.browser.preset_name": "Nom du préréglage",
- "main.browser.reveal_failed": "Échec de l’affichage : {0}",
- "main.browser.save_preset_failed": "Échec de l’enregistrement du préréglage : {0}",
- "main.browser.saved_preset": "Préréglage {0} enregistré",
- "main.cancel_the_download": "Annuler le téléchargement",
- "main.clip_editor_fills_the_window": "L’éditeur de clips remplit la fenêtre",
- "main.clip_names": "Noms des clips",
- "main.close_the_drivers_settings_window": "Fermer la fenêtre de réglages du pilote pour appliquer le changement",
- "main.command_palette": "Palette de commandes…",
- "main.commands.arrangement_grid": "Grille de l’arrangement : {0}",
- "main.commands.clip_editor_grid": "Grille de l’éditeur de clips : {0}",
- "main.commands.envelopes_follow_clips": "Les enveloppes suivent les clips",
- "main.commands.envelopes_locked_clip_moves_keep": "Enveloppes verrouillées : les déplacements de clips laissent l’automation en place",
- "main.commands.grouped_tracks": "Pistes groupées",
- "main.commands.no_notes_outside_the_scale": "Aucune note hors de la gamme",
- "main.commands.nothing_to_undo": "Rien à annuler",
- "main.commands.open_a_midi_clip_first": "Ouvrir d’abord un clip MIDI",
- "main.commands.open_the_session_view_first": "Ouvrir d’abord la vue Session",
- "main.commands.quantized_notes": "Notes quantifiées",
- "main.commands.scenes_live_in_the_session": "Les scènes se trouvent dans la vue Session",
- "main.commands.select_a_clip_first": "Sélectionner d’abord un clip",
- "main.commands.select_a_clip_or_a": "Sélectionner d’abord un clip ou une plage",
- "main.commands.select_a_time_range_first": "Sélectionner d’abord une plage de temps",
- "main.commands.select_a_track_first": "Sélectionner d’abord une piste",
- "main.commands.select_clips_or_a_range": "Sélectionner d’abord des clips ou une plage",
- "main.commands.select_tracks_first": "Sélectionner d’abord des pistes",
- "main.commands.select_two_or_more_midi": "Sélectionner au moins deux clips MIDI",
- "main.commands.selecting_a_track_leaves_the": "Sélectionner une piste ne modifie pas l’armement",
- "main.commands.selecting_an_instrument_track_arms": "Sélectionner une piste d’instrument l’arme",
- "main.commands.snap_off": "Magnétisme désactivé",
- "main.commands.this_track_cant_be_frozen": "Cette piste ne peut pas être gelée",
- "main.commands.track_headers_on_the_left": "En-têtes de piste à gauche",
- "main.commands.ungrouped": "Dégroupé",
- "main.connect_phone": "Connecter un téléphone…",
- "main.convert.analysing": "Analyse…",
- "main.convert.building_pads": "Création des pads…",
- "main.convert.convert_failed": "Échec de la conversion : {0}",
- "main.convert.converted_harmony_notes_new_track": "Harmonie convertie : {0} notes → nouvelle piste {1}",
- "main.convert.converted_hits": "{0} frappes converties",
- "main.convert.converted_melody_notes_new_track": "Mélodie convertie : {0} notes → nouvelle piste {1}",
- "main.convert.converted_notes_new_track": "{0} converti : {1} notes → nouvelle piste {2}",
- "main.convert.detecting_harmony": "Détection de l’harmonie…",
- "main.convert.detecting_hits": "Détection des frappes…",
- "main.convert.detecting_pitch": "Détection de la hauteur…",
- "main.convert.detecting_transients": "Détection des transitoires…",
- "main.convert.listening_for_notes": "À l’écoute des notes…",
- "main.convert.new_drum_rack_track": "{0} → nouvelle piste Drum Rack {1}",
- "main.convert.no_drum_hits_found": "Aucune frappe de batterie trouvée.",
- "main.convert.no_found": "Aucun {0} trouvé.",
- "main.convert.no_harmony_found": "Aucune harmonie trouvée.",
- "main.convert.no_melody_found": "Aucune mélodie trouvée.",
- "main.convert.nothing_to_slice": "Rien à découper.",
- "main.convert.sliced_into_pads": "Découpé en {0} pads",
- "main.convert.slicing_pads": "Découpe des pads… {0}",
- "main.convert.that_converter_isnt_available_yet": "Ce convertisseur n’est pas encore disponible.",
- "main.convert.this_clip_has_no_audio": "Ce clip n’a pas d’audio à convertir.",
- "main.convert_melody_and_convert_harmony": "« Convertir la mélodie » et « Convertir l’harmonie » utilisent désormais le modèle d’IA.",
- "main.convert_to_midi": "Convertir en MIDI",
- "main.copied_range": "Plage copiée",
- "main.copied_track_s": "Piste(s) copiée(s)",
- "main.copy_clips_to_session_arrangement": "Copier les clips vers Session / Arrangement",
- "main.couldnt_freeze_this_track": "Impossible de geler cette piste.",
- "main.cut_range": "Plage coupée",
- "main.cut_track_s": "Piste(s) coupée(s)",
- "main.deleted_clip_s": "Clip(s) supprimé(s)",
- "main.deleted_track_s": "Piste(s) supprimée(s)",
- "main.detail.audio": "Audio ",
- "main.detail.back_to_the_split_f": "Retour à la vue partagée (⌘⇧F)",
- "main.detail.clip_editor_every_clip_on": "Éditeur de clips : tous les clips de la piste",
- "main.detail.clip_editor_one_clip": "Éditeur de clips : un seul clip",
- "main.detail.group": "Groupe {0}",
- "main.detail.in": "Entrée ",
- "main.detail.inst": "Inst ",
- "main.detail.midi_from": "MIDI depuis ",
- "main.detail.monitor_in": "Écoute entrée",
- "main.detail.pdc_ms": "PDC {0:0.0} ms",
- "main.detail.select_a_clip_to_edit": "Sélectionner un clip pour le modifier.",
- "main.detail.select_a_midi_clip_on": "Sélectionner un clip MIDI sur une piste Drum Rack pour le programmer pas à pas.",
- "main.detail.the_clip_editor_is_in": "L’éditeur de clips est dans sa propre fenêtre",
- "main.detail.track_clip": "Clip de la piste {0}",
- "main.detail.track_scene": "Piste {0} · Scène {1}",
- "main.detail_window.select_a_clip_in_the": "Sélectionner un clip dans l’arrangement pour le modifier ici",
- "main.device_moves.cant_take": "« {0} » ne peut pas accepter {1}.",
- "main.device_moves.copied_to": "{0} copié vers {1}",
- "main.device_moves.couldnt_copy": "Impossible de copier {0}.",
- "main.device_moves.couldnt_move": "Impossible de déplacer {0}.",
- "main.device_moves.cut_deleted": "{0} coupé — {1} supprimé",
- "main.device_moves.delete_track": "Supprimer la piste",
- "main.device_moves.delete_track_the_track_and": "Supprimer la piste « {0} » ? La piste et ses {1} appareils sélectionnés seront supprimés.",
- "main.device_moves.deleted": " · {0} supprimé",
- "main.device_moves.deleted_n": "{0} supprimé",
- "main.device_moves.has_clips_delete_the_track": "« {0} » contient des clips. Supprimer la piste avec ses clips ?",
- "main.device_moves.modulation_links_left_on": " · liaisons de modulation restantes sur {0}",
- "main.device_moves.move": "Déplacer",
- "main.device_moves.move_devices_to_and_delete": "Déplacer {0} appareils vers « {1} » et supprimer « {2} » ?",
- "main.device_moves.move_to_and_delete_with": "Déplacer {0} vers « {1} » et supprimer « {2} » avec ses clips ?",
- "main.device_moves.moved_devices_to": "{0} appareils déplacés vers {1}",
- "main.device_moves.moved_devices_to_couldnt_move": "{0} appareils déplacés vers {1} · {2} n’ont pas pu être déplacés",
- "main.device_moves.moved_to": "{0} déplacé vers {1}",
- "main.device_moves.sidechain_cleared": " · sidechain supprimé",
- "main.devices": "Appareils",
- "main.dnd.couldnt_add_to_the_rack": "Impossible d’ajouter {0} au rack.",
- "main.dnd.drop_effects_onto_a_column": "Déposer des effets sur une colonne.",
- "main.dnd.drop_failed": "Échec du dépôt : {0}",
- "main.dnd.drop_samples_and_midi_files": "Déposer des échantillons et des fichiers MIDI sur un emplacement.",
- "main.dnd.drop_samples_onto_audio_slots": "Déposer des échantillons sur les emplacements audio.",
- "main.done": "Terminé",
- "main.downloads.dismiss": "Ignorer",
- "main.downloads.open_settings_downloads": "Ouvrir Réglages → Téléchargements",
- "main.drums": "Batterie",
- "main.dsp_caps": "DSP {0}%",
- "main.dsp_load_of_the_audio": "Charge DSP : {0} du temps de tampon audio — les décrochages commencent près de 100 %",
- "main.duplicate_clip": "Dupliquer le clip",
- "main.duplicated_track_s": "Piste(s) dupliquée(s)",
- "main.exit": "Quitter",
- "main.export_audio": "Exporter de l’audio…",
- "main.files.audio": "Audio {0}",
- "main.files.export": "Exporter",
- "main.files.export_failed": "Échec de l’export : {0}",
- "main.files.export_master_to": "Exporter le master en {0}",
- "main.files.export_stems_to_folder": "Exporter les stems dans un dossier",
- "main.files.exported": "{0} exporté",
- "main.files.exported_stems": { "one": "{0} stem exporté", "other": "{0} stems exportés" },
- "main.files.exporting": "Export…",
- "main.files.exporting_n": "Export de {0}… {1:0} %",
- "main.files.exporting_stems": "Export des stems…",
- "main.files.import_audio": "Importer de l’audio",
- "main.files.new_project": "Nouveau projet.",
- "main.files.nota": "Nota — {0}",
- "main.files.nota_project": "Projet Nota",
- "main.files.nothing_to_export_the_arrangement": "Rien à exporter — l’arrangement est vide.",
- "main.files.open_failed": "Échec de l’ouverture : {0}",
- "main.files.open_nota_project_nota_folder": "Ouvrir un projet Nota (dossier .nota)",
- "main.files.open_project": "Ouvrir un projet",
- "main.files.opened": "{0} ouvert",
- "main.files.opened_item_s_downgraded": "{0} ouvert — {1} élément(s) dégradé(s) : {2}",
- "main.files.preparing_warped_clips": "Préparation des clips warpés…",
- "main.files.preparing_warped_clips_n": "Préparation des clips warpés… {0:0} %",
- "main.files.save_failed": "Échec de l’enregistrement : {0}",
- "main.files.save_nota_project": "Enregistrer le projet Nota",
- "main.files.save_your_changes_before_opening": "Enregistrer les modifications avant d’ouvrir un autre projet ?",
- "main.files.save_your_changes_before_starting": "Enregistrer les modifications avant de commencer un nouveau projet ?",
- "main.files.saved": "{0} enregistré",
- "main.files.saved_unsupported_item_s_skipped": "{0} enregistré — {1} élément(s) non pris en charge ignoré(s) : {2}",
- "main.files.unsupported_file_location": "Emplacement de fichier non pris en charge.",
- "main.files.unsupported_project_location": "Emplacement de projet non pris en charge.",
- "main.files.untitled": "Sans titre",
- "main.fill_the_window_with_the": "Remplir la fenêtre avec l’éditeur de clips (⌘⇧F)",
- "main.flatten": "Aplatir",
- "main.flatten_remove_source": "Aplatir (supprimer la source)",
- "main.flatten_track": "Aplatir la piste",
- "main.follow_is_paused_while_you": "Le suivi est en pause pendant la consultation d’un autre endroit · P ou un clic ici le reprend",
- "main.follow_paused_press_p_to": "Suivi en pause · appuyer sur P pour revenir à la tête de lecture",
- "main.follow_playhead": "Suivre la tête de lecture",
- "main.follow_playhead_off": "Suivi de la tête de lecture désactivé",
- "main.following_the_playhead": "Suivi de la tête de lecture",
- "main.freeze.discard_edits": "Abandonner les modifications",
- "main.freeze.done_re_freeze": "Terminé — geler à nouveau",
- "main.freeze.edit_source": "Modifier la source",
- "main.freeze.flatten_failed": "Échec de l’aplatissement : {0}",
- "main.freeze.flatten_replaces_this_tracks_instrument": "Aplatir remplace l’instrument, le MIDI et les appareils de cette piste par un seul clip audio du son gelé. ",
- "main.freeze.flatten_to_audio_track": "Aplatir en piste audio",
- "main.freeze.freeze_failed": "Échec du gel : {0}",
- "main.freeze.freeze_the_track_first_then": "Geler d’abord la piste, puis l’aplatir.",
- "main.freeze.freeze_track": "Geler la piste",
- "main.freeze.freeze_tracks": "Geler {0} pistes",
- "main.freeze.freezing_track": "Gel de la piste…",
- "main.freeze.freezing_track_n": "Gel de la piste… {0:0} %",
- "main.freeze.freezing_track_of": "Gel de la piste {0} sur {1}… {2:0} %",
- "main.freeze.freezing_tracks": "Gel des pistes…",
- "main.freeze.froze_of_tracks": "{0} pistes sur {1} gelées.",
- "main.freeze.frozen": "Gelée",
- "main.freeze.this_cant_be_undone_continue": "Cette action est irréversible. Continuer ?",
- "main.freeze.track_flattened_to_audio": "Piste aplatie en audio.",
- "main.freeze.track_frozen_its_devices_are": "Piste gelée — ses appareils sont inactifs jusqu’au dégel.",
- "main.freeze.track_unfrozen": "Piste dégelée.",
- "main.freeze.tracks_frozen_their_devices_are": "{0} pistes gelées — leurs appareils sont inactifs jusqu’au dégel.",
- "main.freeze.tracks_unfrozen": "{0} pistes dégelées.",
- "main.freeze.unfreeze_track": "Dégeler la piste",
- "main.freeze.unfreeze_tracks": "Dégeler {0} pistes",
- "main.freeze_the_track_to_audio": "Geler la piste en audio pour libérer du CPU (clic droit pour aplatir)",
- "main.gamepad.gamepad_octave_c": "Octave manette : C{0}",
- "main.gamepad.octave": "Octave +",
- "main.gamepad.octave_2": "Octave −",
- "main.gamepad.velocity": "Vélocité +",
- "main.gamepad.velocity_2": "Vélocité −",
- "main.hand_overridden_controls_back_to": "Rendre les commandes modifiées à leur automation",
- "main.help": "Aide",
- "main.hide_the_mixer": "Masquer le mixeur",
- "main.history.choose_a_new_name_for": "Choisir un nouveau nom pour la copie — elle ne peut pas remplacer un projet existant.",
- "main.history.couldnt_open_the_version": "Impossible d’ouvrir la version : {0}",
- "main.history.couldnt_switch_version": "Impossible de changer de version : {0}",
- "main.history.open_version_as_a_new": "Ouvrir la version comme nouveau projet",
- "main.history.open_version_as_copy": "Ouvrir la version comme copie",
- "main.history.opened_as": "{0} ouvert comme {1}",
- "main.history.save_version": "Enregistrer la version",
- "main.history.save_your_changes_as_a": "Enregistrer les modifications comme nouvelle version avant de changer ?",
- "main.history.save_your_changes_before_opening": "Enregistrer les modifications avant d’ouvrir la copie ?",
- "main.history.switch_version": "Changer de version",
- "main.history.switched_to": "Passage à {0}",
- "main.history.the_version": "la version “{0}” ({1})",
- "main.history.the_version_of": "la version du {0}",
- "main.history.version_history_is_turned_off": "L’historique des versions est désactivé dans les Réglages.",
- "main.history.version_history_turned_off_freed": "Historique des versions désactivé · {0} libérés",
- "main.history.version_not_recorded": " · version non enregistrée : {0}",
- "main.history.what_changed_in_this_version": "Qu’est-ce qui a changé dans cette version ?",
- "main.import_audio": "Importer de l’audio…",
- "main.imported": "{0} importé",
- "main.input.copied_automation": "Automation copiée",
- "main.input.copied_clip_s": "Clip(s) copié(s)",
- "main.input.cut_automation": "Couper l’automation",
- "main.input.cut_clip_s": "Clip(s) coupé(s)",
- "main.input.deleted_automation": "Automation supprimée",
- "main.input.deleted_range": "Plage supprimée",
- "main.input.keyboard_octave_c": "Octave clavier : C{0}",
- "main.input.keyboard_velocity": "Vélocité clavier : {0}",
- "main.input.pasted_automation": "Automation collée",
- "main.input.pasted_clip_s": "Clip(s) collé(s)",
- "main.insert_scene": "Insérer une scène",
- "main.instrument_track_synth": "Piste d’instrument {0} (synthé)",
- "main.key": "Tonalité",
- "main.leave_edit_mode_without_re": "Quitter le mode édition sans regeler",
- "main.live_freeze": "Gel en direct",
- "main.live_freeze.editing_the_frozen_source_press": "Modification de la source gelée — appuyer sur Terminé pour geler à nouveau, ou sur Abandonner.",
- "main.live_freeze.failed": "Échec de {0} : {1}",
- "main.live_freeze.flatten_keeps_the_frozen_audio": "Aplatir conserve la piste audio gelée et supprime définitivement sa source (instrument, MIDI et appareils). Continuer ?",
- "main.live_freeze.flattened_the_frozen_audio_is": "Aplati — l’audio gelé est maintenant une piste ordinaire.",
- "main.live_freeze.left_edit_mode_the_frozen": "Mode d’édition quitté (l’audio gelé n’a pas été modifié).",
- "main.live_freeze.live_freeze_failed": "Échec du gel en direct : {0}",
- "main.live_freeze.live_freeze_link_removed_its": "Lien de gel en direct supprimé — sa piste a été supprimée.",
- "main.live_freeze.re_freeze_failed": "Échec du nouveau gel : {0}",
- "main.live_freeze.re_freeze_failed_the_source": "Échec du nouveau gel — la source est toujours active.",
- "main.live_freeze.track_live_frozen_press_edit": "Piste gelée en direct — appuyer sur Modifier pour la changer, puis sur Terminé.",
- "main.live_freeze.unfrozen_the_source_is_live": "Dégelée — la source est de nouveau active.",
- "main.lock_envelopes": "Verrouiller les enveloppes",
- "main.loop_record_overdub_replace": "Enregistrement en boucle : superposition / remplacement",
- "main.loop_recording_overdub_adds_every": "Enregistrement en boucle : Superposer ajoute chaque passage · Remplacer garde le dernier passage (⌘⇧R)",
- "main.loop_the_range_set_on": "Mettre en boucle la plage définie sur la règle",
- "main.map_a_controller_click_a": "Assigner un contrôleur : cliquer sur une commande, puis bouger un bouton du contrôleur",
- "main.master_volume": "Volume master",
- "main.measuring": "mesure…",
- "main.menu.clip_names_every_clip": "Noms des clips : tous les clips",
- "main.menu.clip_names_first_of_a": "Noms des clips : premier d’une série",
- "main.menu.clip_names_none": "Noms des clips : aucun",
- "main.menu.consolidated": "Consolidé",
- "main.menu.copied_clip": "Clip copié",
- "main.menu.copied_notes": "Notes copiées",
- "main.menu.cut_clip": "Clip coupé",
- "main.menu.cut_notes": "Notes coupées",
- "main.menu.deleted_notes": "Notes supprimées",
- "main.menu.duplicated_automation": "Automation dupliquée",
- "main.menu.duplicated_clip_s": "Clip(s) dupliqué(s)",
- "main.menu.duplicated_notes": "Notes dupliquées",
- "main.menu.duplicated_range": "Plage dupliquée",
- "main.menu.duplicated_time": "Temps dupliqué",
- "main.menu.inserted_silence": "Silence inséré",
- "main.menu.loop_set_to_selection": "Boucle réglée sur la sélection",
- "main.menu.not_implemented_yet": "Pas encore disponible.",
- "main.menu.nothing_after_the_selection_to": "Rien à déplacer après la sélection.",
- "main.menu.nothing_to_duplicate_in_the": "Rien à dupliquer dans la plage sélectionnée.",
- "main.menu.nothing_to_redo": "Rien à rétablir.",
- "main.menu.nothing_to_undo": "Rien à annuler.",
- "main.menu.overview_strip_hidden": "Bandeau d’aperçu masqué",
- "main.menu.overview_strip_shown": "Bandeau d’aperçu affiché",
- "main.menu.pasted_clip": "Clip collé",
- "main.menu.pasted_notes": "Notes collées",
- "main.menu.scenes_live_in_the_session": "Les scènes se trouvent dans la vue Session.",
- "main.menu.sections_lane_hidden": "Couloir des sections masqué",
- "main.menu.sections_lane_shown": "Couloir des sections affiché",
- "main.menu.select_a_clip_first": "Sélectionner d’abord un clip.",
- "main.menu.select_a_clip_or_a": "Sélectionner un clip ou une scène à copier dans l’arrangement.",
- "main.menu.select_a_range_or_a": "Sélectionner une plage, ou un clip que la tête de lecture traverse.",
- "main.menu.select_a_range_or_clips": "Sélectionner une plage ou des clips à consolider.",
- "main.menu.select_a_time_range_first": "Sélectionner d’abord une plage de temps.",
- "main.menu.select_clips_to_copy_to": "Sélectionner des clips à copier dans la session.",
- "main.menu.split_at_selection": "Découpé à la sélection",
- "main.menu.split_clip_s_at_playhead": "Clip(s) découpé(s) à la tête de lecture",
- "main.menu_keys.show_parameter_automation_lanes_a": "Afficher les couloirs d’automation des paramètres (⌘⇧A)",
- "main.midi_error": "Erreur MIDI : {0}",
- "main.midi_import.couldnt_read": "Impossible de lire {0} : {1}",
- "main.midi_import.drop_midi_files_onto_instrument": "Déposer des fichiers MIDI sur les emplacements d’instruments.",
- "main.midi_import.has_no_notes": "{0} ne contient aucune note.",
- "main.midi_import.imported_parts": "{0} importé ({1} parties)",
- "main.midi_inputs_updated": "Entrées MIDI mises à jour.",
- "main.missing_plugins.install": "Installer",
- "main.missing_plugins.installed_reopen_the_project_to": "{0} installé — rouvrir le projet pour l’utiliser.",
- "main.missing_plugins.installed_reopen_the_project_to_n": "{0} installés — rouvrir le projet pour les utiliser.",
- "main.missing_plugins.installing_plugins": "Installation des plug-ins…",
- "main.missing_plugins.missing_plugins": "Plug-ins manquants",
- "main.missing_plugins.scanning_plugins": "Analyse des plug-ins…",
- "main.missing_plugins.this_project_uses_which_arent": "Ce projet utilise {0}, qui ne sont pas installés. Ils sont open source et disponibles dans le registre de plug-ins de Nota. Les installer et rouvrir le projet ?",
- "main.missing_plugins.this_project_uses_which_isnt": "Ce projet utilise {0}, qui n’est pas installé. Il est open source et disponible dans le registre de plug-ins de Nota. L’installer et rouvrir le projet ?",
- "main.mixer_in_its_own_window": "Mixeur dans sa propre fenêtre",
- "main.mosaic.created_presets_loaded": "{0} préréglages créés · {1} chargé",
- "main.mosaic.created_the_preset": "Préréglage {0} créé",
- "main.narrow_grid": "Réduire la grille",
- "main.new": "Nouveau",
- "main.no_audio_output_could_be": "Aucune sortie audio n’a pu être ouverte — Nota fonctionne sans son. Choisir un périphérique dans Réglages → Audio",
- "main.no_audio_output_device_opened": "Aucun périphérique de sortie audio ouvert — Nota fonctionne en silence. Choisir un périphérique dans Réglages → Audio",
- "main.no_key": "Aucune tonalité",
- "main.no_project_key": "Aucune tonalité de projet",
- "main.not_now": "Pas maintenant",
- "main.nota_process_cpu_audio_interface": "CPU du processus Nota : {0} (audio, interface, plug-ins)",
- "main.note_audition_off": "Écoute des notes désactivée",
- "main.note_audition_on": "Écoute des notes activée",
- "main.nothing_to_freeze_the_arrangement": "Rien à geler — l’arrangement est vide.",
- "main.off_remote": "Off",
- "main.open": "Ouvrir…",
- "main.open_a_clip_in_the": "Ouvrir d’abord un clip dans l’éditeur de clips",
- "main.open_devices_and_clip_in": "Ouvrir les appareils et le clip dans une fenêtre séparée",
- "main.open_the_mixer_in_a": "Ouvrir le mixeur dans une fenêtre",
- "main.overdub": "Superposer",
- "main.pad": "Pad",
- "main.palette.added_to_the_canvas_connect": "{0} ajouté au canevas {1} — le relier à un paramètre",
- "main.palette.couldnt_add": "Impossible d’ajouter {0}.",
- "main.palette.not_available": "Indisponible",
- "main.palette.opened_in_devices": "{0} ouvert dans Appareils",
- "main.palette.selected": "{0} sélectionné",
- "main.paste_bounced.click_an_audio_track_to": "Cliquer une piste audio pour y coller l’audio rendu.",
- "main.paste_bounced.couldnt_paste_the_bounced_audio": "Impossible de coller l’audio rendu.",
- "main.paste_bounced.couldnt_render_this_track": "Impossible de rendre cette piste.",
- "main.paste_bounced.paste_bounced_audio_failed": "Échec du collage de l’audio rendu : {0}",
- "main.paste_bounced.paste_bounced_audio_takes_a": "Coller l’audio rendu demande une plage sur une seule piste.",
- "main.paste_bounced.pasted_bounced_audio": "Audio rendu collé",
- "main.paste_bounced.select_a_time_range_first": "Sélectionner d’abord une plage de temps (Maj+glisser), puis la coller rendue sur une piste audio.",
- "main.paste_bounced.the_selected_range_has_no": "La plage sélectionnée ne contient aucune piste audio ou d’instrument à rendre.",
- "main.pasted_track_s": "Piste(s) collée(s)",
- "main.play_and_control_nota_from": "Jouer et piloter Nota depuis un téléphone",
- "main.play_pause": "Lecture / pause",
- "main.play_space": "Lire (Space)",
- "main.project_key": "Tonalité du projet : {0}",
- "main.re_enable": "Réactiver",
- "main.re_freeze_the_source_and": "Regeler la source et la remettre en veille",
- "main.recent.added_track": "{0} ajouté (piste {1})",
- "main.recent.is_no_longer_installed": "{0} n’est plus installé.",
- "main.recent_menu.no_recent_projects": "Aucun projet récent",
- "main.recent_menu.open_recent": "Ouvrir un projet récent",
- "main.record_r": "Lancer l’enregistrement (⌘R)",
- "main.recovery.discard": "Ignorer",
- "main.recovery.do_you_really_want_to": "Quitter sans enregistrer les modifications ?",
- "main.recovery.just_now": "à l’instant",
- "main.recovery.nota_didnt_shut_down_cleanly": "Nota ne s’est pas fermé correctement. Récupérer le travail non enregistré de {0} ?",
- "main.recovery.recover": "Récupérer",
- "main.recovery.recover_project": "Récupérer le projet",
- "main.recovery.recovered_unsaved_work": "Travail non enregistré récupéré.",
- "main.recovery.unsaved_changes": "Modifications non enregistrées",
- "main.recovery.unsaved_changes_n": "modifications non enregistrées · {0}",
- "main.redo": "Rétablir",
- "main.remote": "Télécommande",
- "main.remote.phones_connected": { "one": "{0} téléphone connecté", "other": "{0} téléphones connectés" },
- "main.remote.remote_is_on_scan_the": "Télécommande activée · scanner le code avec un téléphone",
- "main.remote.undo_from_a_phone": "Annuler (depuis un téléphone)",
- "main.rendering": "Rendu…",
- "main.rendering_n": "Rendu… {0:0} %",
- "main.replace": "Remplacer",
- "main.return_added_add_an_effect": "Retour {0} ajouté — ajouter un effet, puis augmenter les envois des pistes",
- "main.sample_rate_and_buffer_size": "Fréquence d’échantillonnage et taille du tampon. Cliquer pour changer la taille du tampon",
- "main.save": "Enregistrer",
- "main.save_as": "Enregistrer sous…",
- "main.save_version_with_note": "Enregistrer une version avec note…",
- "main.scroll_the_arrangement_to_keep": "Faire défiler l’arrangement pour garder la tête de lecture visible",
- "main.select_a_clip_to_edit": "Sélectionner un clip pour l’éditer",
- "main.session": "Session",
- "main.set_the_project_key_samples": "Régler la tonalité du projet : les échantillons peuvent y être transposés",
- "main.set_the_tempo_drag_or": "Régler le tempo : glisser, ou double-clic pour le saisir",
- "main.set_the_time_signature_drag": "Régler la signature rythmique : glisser chaque champ",
- "main.settings": "Réglages…",
- "main.show_playhead": "Afficher la tête de lecture",
- "main.snap_clips_to_the_grid": "Caler les clips sur la grille (maintenir Alt pour déplacer librement)",
- "main.snap_off_clips_position_freely": "Magnétisme désactivé — les clips se placent librement",
- "main.snap_on": "Magnétisme activé",
- "main.snap_to_grid": "Magnétisme sur la grille",
- "main.split_at_playhead": "Découper à la tête de lecture",
- "main.stems.download_cancelled": "Téléchargement annulé.",
- "main.stems.downloading": "Téléchargement…",
- "main.stems.is_waiting_for_its_model": "{0} attend son modèle — il se télécharge (voir la barre d’état).",
- "main.stems.isnt_available_on_this_computer": "{0} n’est pas disponible sur cet ordinateur.",
- "main.stems.preparing_audio": "Préparation de l’audio…",
- "main.stems.separate_stems": "Séparer les stems",
- "main.stems.separate_stems_cancelled": "Séparation des stems annulée.",
- "main.stems.separate_stems_failed": "Échec de la séparation des stems : {0}",
- "main.stems.separated_into_drums_bass_other": "« {0} » séparé en batterie, basse, autres et voix.",
- "main.stems.the_model": "le modèle {0}",
- "main.stems.the_model_and_the_ai": "le modèle {0} et le moteur d’IA sur lequel il tourne",
- "main.stems.uses_an_ai_model_that": "{0} utilise un modèle d’IA qui s’exécute sur cet ordinateur. Télécharger {1} ({2}) une fois ? ",
- "main.stems.you_can_remove_it_later": "Il pourra être supprimé plus tard dans Réglages → Téléchargements → Modèles d’IA.",
- "main.step_the_selected_midi_clip": "Programmer pas à pas le clip MIDI sélectionné d’une piste Drum Rack",
- "main.stop_return": "Arrêter (Return)",
- "main.strips": "Tranches",
- "main.switch_between_bars_and_time": "Basculer entre mesures et temps",
- "main.tap": "Tap",
- "main.tap_the_beat_to_set": "Taper le rythme pour régler le tempo",
- "main.tempo_bpm_tapped": "Tempo : {0} BPM (tapé)",
- "main.toggle_browser": "Afficher/masquer le navigateur",
- "main.toggle_detail_panel": "Afficher/masquer le panneau de détail",
- "main.toggle_full_screen": "Activer/quitter le plein écran",
- "main.toggle_overview": "Afficher/masquer l’aperçu",
- "main.toggle_sections": "Afficher/masquer les sections",
- "main.toggled_clip_s": "État des clips inversé",
- "main.track_headers_on_the_right": "En-têtes de piste à droite",
- "main.triplet_grid": "Grille en triolets",
- "main.turn_the_metronome_on_or": "Activer ou désactiver le métronome (⌘M) · clic droit pour le décompte",
- "main.updates.check_for_updates": "Rechercher des mises à jour",
- "main.updates.checking_for_updates": "Recherche de mises à jour…",
- "main.updates.couldnt_reach_github_to_check": "Impossible de joindre GitHub pour rechercher une version plus récente de Nota. Vérifier la connexion Internet, puis réessayer.",
- "main.updates.download_it_from_the_release": " Le télécharger depuis la page de la version.",
- "main.updates.download_nota": "Télécharger Nota {0}…",
- "main.updates.hide_it_still_installs_when": "Masquer — l’installation se fera quand même à la fermeture",
- "main.updates.later": "Plus tard",
- "main.updates.nota_downloads_it_here_and": " Nota le télécharge ici et l’installe au redémarrage ou à la fermeture.",
- "main.updates.nota_is_available": "Nota {0} est disponible",
- "main.updates.nota_is_downloaded_click_to": "Nota {0} est téléchargé. Cliquer pour redémarrer maintenant — ou il s’installera à la prochaine fermeture.",
- "main.updates.nota_is_out_you_have": "Nota {0} est disponible — la version installée est la {1}.",
- "main.updates.nota_is_ready_to_install": "Nota {0} est prêt à être installé. Redémarrer Nota pour terminer la mise à jour — ou il s’installera à la prochaine fermeture.",
- "main.updates.release_notes": "Notes de version",
- "main.updates.restart_now": "Redémarrer maintenant",
- "main.updates.restart_to_update_to_nota": "Redémarrer pour passer à Nota {0}",
- "main.updates.the_update_didnt_download": "La mise à jour n’a pas pu être téléchargée",
- "main.updates.update_available": "Mise à jour disponible",
- "main.updates.update_to_nota": "Mettre à jour vers Nota {0}",
- "main.updates.you_have_click_to_update": "La version installée est {0}. Cliquer pour mettre à jour ou lire les notes de version.",
- "main.updates.youre_up_to_date_nota": "Nota est à jour : la version {0} est la plus récente.",
- "main.view": "Affichage",
- "main.view_release_notes": "Voir les notes de version",
- "main.wake_the_frozen_source_to": "Réveiller la source gelée pour l’éditer (clic droit pour dégeler ou aplatir)",
- "main.wasapi_exclusive_unavailable_using_shared": "WASAPI exclusif indisponible — mode partagé utilisé",
- "main.widen_grid": "Élargir la grille",
- "menu.mac.hide": "Masquer {0}",
- "menu.mac.hide_others": "Masquer les autres",
- "menu.mac.quit": "Quitter {0}",
- "menu.mac.show_all": "Tout afficher",
- "menu.reveal_in_finder": "Afficher dans le Finder",
- "menu.show_in_explorer": "Afficher dans l’Explorateur",
- "menu.show_in_file_manager": "Afficher dans le gestionnaire de fichiers",
- "midi.accent": "Accent",
- "midi.cycles": "Cycles",
- "midi.down": "Bas",
- "midi.generators.a_step_sequencer_in_scale": "Un séquenceur pas à pas en degrés de gamme — choisir un contour et une étendue, obtenir une ligne.",
- "midi.generators.accent_vel": "Vélocité d’accent",
- "midi.generators.accents": "Accents",
- "midi.generators.arch": "Arche",
- "midi.generators.cluster": "Cluster",
- "midi.generators.contour": "Contour",
- "midi.generators.density": "Densité",
- "midi.generators.drop_2": "Drop 2",
- "midi.generators.euclidean": "Euclidien",
- "midi.generators.exponential": "Exponentielle",
- "midi.generators.grows_every_note_into_a": "Transforme chaque note en accord, voicé comme on le jouerait.",
- "midi.generators.lays_down_a_pattern_that": "Pose un motif qui s’appuie sur les temps forts, aussi dense qu’on le demande.",
- "midi.generators.learns_the_clips_intervals_and": "Apprend les intervalles et le rythme du clip, puis écrit une nouvelle prise dans le même style.",
- "midi.generators.logarithmic": "Logarithmique",
- "midi.generators.melodic_steps": "Pas mélodiques",
- "midi.generators.pitch_var": "Variation de hauteur",
- "midi.generators.power": "Alimentation",
- "midi.generators.pulses": "Impulsions",
- "midi.generators.random_walk": "Marche aléatoire",
- "midi.generators.rhythm": "Rythme",
- "midi.generators.rhythm_var": "Variation de rythme",
- "midi.generators.root": "Fondamentale",
- "midi.generators.seed": "Graine",
- "midi.generators.spread": "Spread",
- "midi.generators.spreads_a_number_of_hits": "Répartit un nombre de frappes aussi régulièrement que le permet un nombre de pas.",
- "midi.generators.square": "Carré",
- "midi.generators.stacks": "Piles",
- "midi.generators.traces_a_curve_across_the": "Trace une courbe sur le clip et dépose une note chaque fois qu’elle croise un pas.",
- "midi.generators.valley": "Vallée",
- "midi.generators.variation": "Variation",
- "midi.generators.vel_falloff": "Atténuation de vél.",
- "midi.generators.vel_follows": "Vél. suit",
- "midi.generators.vel_var": "Var. de vél.",
- "midi.generators.voices": "Voix",
- "midi.generators.voicing": "Voicing",
- "midi.generators.zigzag": "Zigzag",
- "midi.in_scale": "Dans la gamme",
- "midi.interval": "Intervalle",
- "midi.octaves": "Octaves",
- "midi.phase": "Phase",
- "midi.ramp_down": "Rampe descendante",
- "midi.ramp_up": "Rampe ascendante",
- "midi.random": "Aléatoire",
- "midi.rate": "Rate",
- "midi.rotate": "Rotation",
- "midi.s_curve": "Courbe en S",
- "midi.shape": "Forme",
- "midi.sine": "Sine",
- "midi.steps": "Pas",
- "midi.tool.on": "On",
- "midi.transforms.alternate": "Alterner",
- "midi.transforms.amount": "Quantité",
- "midi.transforms.arpeggiate": "Arpéger",
- "midi.transforms.bends_the_time_axis_so": "Déforme l’axe du temps pour qu’une phrase accélère, traîne ou respire.",
- "midi.transforms.blend": "Blend",
- "midi.transforms.breaks_chords_into_a_running": "Découpe les accords en une séquence continue.",
- "midi.transforms.centre": "Centre",
- "midi.transforms.centre_out": "Du centre vers l’extérieur",
- "midi.transforms.chance": "Probabilité",
- "midi.transforms.chord": "Accord",
- "midi.transforms.chromatic": "Chromatique",
- "midi.transforms.chunk": "Segment",
- "midi.transforms.connect": "Relier",
- "midi.transforms.converge": "Converger",
- "midi.transforms.curve": "Courbe",
- "midi.transforms.decorates_notes_with_grace_notes": "Orne les notes de notes d’agrément, de trilles et de roulements.",
- "midi.transforms.depth": "Depth",
- "midi.transforms.direction": "Sens",
- "midi.transforms.distance": "Distance",
- "midi.transforms.diverge": "Diverger",
- "midi.transforms.down_up": "Bas-haut",
- "midi.transforms.draws_a_curve_through_the": "Trace une courbe à travers les vélocités au lieu de les modifier une par une.",
- "midi.transforms.fill": "Remplissage",
- "midi.transforms.fills_the_gaps_between_notes": "Comble les vides entre les notes par des traits qui montent ou descendent vers la hauteur suivante.",
- "midi.transforms.fixed": "Fixe",
- "midi.transforms.flam": "Flam",
- "midi.transforms.flatten": "Aplatir",
- "midi.transforms.grace": "Appogiature",
- "midi.transforms.humanize": "Humaniser",
- "midi.transforms.in_scale": "Dans la gamme",
- "midi.transforms.keep_ends": "Garder les extrémités",
- "midi.transforms.max_steps": "Pas max.",
- "midi.transforms.mirror_pitch": "Hauteur en miroir",
- "midi.transforms.mode": "Mode",
- "midi.transforms.mordent": "Mordant",
- "midi.transforms.ornament": "Ornement",
- "midi.transforms.per_pitch": "Par hauteur",
- "midi.transforms.period": "Période",
- "midi.transforms.pulls_notes_onto_the_grid": "Cale les notes sur la grille, avec du swing et une force qui reste souple.",
- "midi.transforms.pulls_pitch_and_rhythm_apart": "Sépare hauteur et rythme puis les recompose autrement.",
- "midi.transforms.quantize_ends": "Quantifier les fins",
- "midi.transforms.recombine": "Recombiner",
- "midi.transforms.reverse_pitch": "Hauteur inversée",
- "midi.transforms.reverse_time": "Temps inversé",
- "midi.transforms.rewrites_note_lengths_from_staccato": "Réécrit les durées de notes — du staccato au legato jusqu’au chevauchement.",
- "midi.transforms.roll": "Roulement",
- "midi.transforms.rolls_the_notes_of_a": "Étale dans le temps les notes d’un accord au lieu de les frapper ensemble.",
- "midi.transforms.rotate_pitch": "Rotation de hauteur",
- "midi.transforms.scale_length": "Longueur de la gamme",
- "midi.transforms.shuffle_both": "Mélanger les deux",
- "midi.transforms.shuffle_pitch": "Mélanger la hauteur",
- "midi.transforms.shuffle_rhythm": "Mélanger le rythme",
- "midi.transforms.snap_to_grid": "Magnétisme sur la grille",
- "midi.transforms.span": "Étendue",
- "midi.transforms.strum": "Strum",
- "midi.transforms.style": "Style",
- "midi.transforms.swing": "Swing",
- "midi.transforms.tension": "Tension",
- "midi.transforms.time_warp": "Déformation temporelle",
- "midi.transforms.to_next_note": "Jusqu’à la note suivante",
- "midi.transforms.trill": "Trille",
- "midi.transforms.turn": "Gruppetto",
- "midi.transforms.type": "Type",
- "midi.transforms.up_down": "Haut-bas",
- "midi.transforms.vel_decay": "Déclin de vél.",
- "midi.transforms.vel_slope": "Pente de vél.",
- "midi.transforms.velocity_shaper": "Façonneur de vélocité",
- "midi.transforms.warp_lengths": "Longueurs de warp",
- "midi.triangle": "Triangle",
- "midi.up": "Haut",
- "midi_learn.button": "Bouton {0}",
- "midi_learn.left_stick": "Stick gauche ←→",
- "midi_learn.left_stick_2": "Stick gauche ↑↓",
- "midi_learn.left_trigger": "Gâchette gauche",
- "midi_learn.note_ch": "Note {0} · canal {1}",
- "midi_learn.pad": "Pad · {0}",
- "midi_learn.phone": "Téléphone · {0}",
- "midi_learn.right_stick": "Stick droit ←→",
- "midi_learn.right_stick_2": "Stick droit ↑↓",
- "midi_learn.right_trigger": "Gâchette droite",
- "midi_map.invert": "Inverser",
- "midi_map.master_volume": "Volume master",
- "midi_map.max": "Max",
- "midi_map.midi_mappings": "Assignations MIDI",
- "midi_map.no_mappings_yet_click_midi": "Aucune assignation pour l’instant.\n\nCliquer sur MIDI (en haut à droite), puis sur une commande\nen surbrillance, et bouger un bouton ou un fader du contrôleur —\nou appuyer sur un bouton ou bouger un stick d’une manette.",
- "midi_map.play": "Lecture",
- "midi_map.track_pan": "Pan de la piste",
- "midi_map.track_volume": "Volume de la piste",
- "midi_tools.add": "Ajouter",
- "midi_tools.apply": "Appliquer",
- "midi_tools.clip": "clip · {0}",
- "midi_tools.defaults": "Valeurs par défaut",
- "midi_tools.generate": "Générer",
- "midi_tools.notes": "{0:+0;−0;±0} notes",
- "midi_tools.notes_applied": "{0} notes · appliqué",
- "midi_tools.notes_was": "{0} notes, au lieu de {1}",
- "midi_tools.parameters": "Paramètres",
- "midi_tools.pick_a_tool": "Choisir un outil",
- "midi_tools.pick_a_tool_to_see": "Choisir un outil pour voir ses paramètres",
- "midi_tools.replace": "Remplacer",
- "midi_tools.reroll": "Retirer au sort",
- "midi_tools.revert": "Rétablir",
- "midi_tools.seed": "Graine",
- "midi_tools.selected": "{0} sélectionné(s)",
- "midi_tools.transform": "Transformer",
- "mixer.a_hidden_track_clipped_click": "Une piste masquée a saturé · cliquer pour effacer",
- "mixer.a_hidden_track_is_armed": "Une piste masquée est armée",
- "mixer.a_hidden_track_is_soloed": "Une piste masquée est en solo",
- "mixer.balance": "Balance",
- "mixer.dock_the_mixer_in_the": "Ancrer le mixeur dans la fenêtre principale",
- "mixer.fold_group": "Replier le groupe {0}",
- "mixer.group_in": "Entrée du groupe",
- "mixer.groups_keep_a_unity_centre": "Les groupes gardent une balance centrée à gain unitaire, pour que le groupage reste transparent en niveau",
- "mixer.hidden_not_enough_height_click": "Masqué : hauteur insuffisante · cliquer pour afficher quand même",
- "mixer.in_1": "Entrée 1",
- "mixer.master": "→ Master",
- "mixer.midi_in": "Entrée MIDI",
- "mixer.monitor_auto": "Écoute auto",
- "mixer.monitor_in": "Écoute entrée",
- "mixer.older_project": "Ancien projet",
- "mixer.output": "→ Sortie",
- "mixer.pan_attenuates_the_opposite_channel": "Le pan atténue le canal opposé, comme dans les versions précédentes",
- "mixer.pan_law": "Loi de panoramique",
- "mixer.pan_moves_the_whole_image": "Le pan déplace toute l’image des pistes stéréo et des retours",
- "mixer.panning_attenuates_the_opposite_channel": "Le panoramique atténue le canal opposé (comportement historique)",
- "mixer.panning_moves_the_whole_stereo": "Le panoramique déplace toute l’image stéréo ; rien n’est supprimé",
- "mixer.projects_saved_before_stereo_pan": "Les projets enregistrés avant la loi de panoramique stéréo s’ouvrent avec Balance, pour que les mixages existants ne changent pas",
- "mixer.return_in": "Entrée de retour",
- "mixer.set_the_gain_drag_or": "Régler le gain : glisser, ou double-clic pour le saisir",
- "mixer.show_compact_strips_more_tracks": "Afficher des tranches compactes : plus de pistes à l’écran",
- "mixer.stereo": "Stéréo",
- "mixer.strips": "Tranches",
- "mixer.sum_bus": "Bus de somme",
- "mixer.unfold_group": "Déplier le groupe {0}",
- "model_store.ai_models_arent_available_for": "Les modèles d’IA ne sont pas disponibles pour cet ordinateur : ONNX Runtime n’en propose pas de version.",
- "model_store.couldnt_remove_it_may_be": "Impossible de supprimer {0} — il est peut-être utilisé. Redémarrer Nota puis réessayer.",
- "model_store.installing_this_model_needs_of": "L’installation de ce modèle demande {0} d’espace disque libre, et il y en a {1}.",
- "model_store.invalid_model_id": "Identifiant de modèle « {0} » invalide.",
- "model_store.model_catalog.ai_runtime": "Moteur d’IA",
- "model_store.model_catalog.convert_to_midi": "Convertir en MIDI",
- "model_store.model_catalog.hears_every_note_in_a": "Entend chaque note d’un enregistrement, accords compris, pour Convertir la mélodie et Convertir l’harmonie.",
- "model_store.model_catalog.separate_stems": "Séparer les stems",
- "model_store.model_catalog.splits_a_mix_into_drums": "Sépare un mix en batterie, basse, voix et tout le reste, chacun sur sa propre piste.",
- "model_store.model_catalog.the_library_notas_ai_models": "La bibliothèque sur laquelle tournent les modèles d’IA de Nota. Installée avec le premier modèle.",
- "model_store.the_download_of_doesnt_contain": "Le téléchargement de {0} ne contient pas {1}.",
- "model_store.unknown_ai_model": "Modèle d’IA « {0} » inconnu.",
- "modular.add": "+ Ajouter",
- "modular.add_2": "Ajouter",
- "modular.add_an_lfo_expose_a": "Ajouter d’abord un LFO / exposer un paramètre",
- "modular.audio_in": "Entrée audio",
- "modular.audio_out": "Sortie audio",
- "modular.bypass_b": "Contourner (B)",
- "modular.cross_track_cv_links": { "one": "{0} lien CV entre pistes", "other": "{0} liens CV entre pistes" },
- "modular.cv_link_lfo_caps": "LIEN CV · LFO {0}",
- "modular.cv_out": "CV out",
- "modular.delete": "Supprimer (⌫)",
- "modular.depth": "Depth",
- "modular.devices": { "one": "{0} appareil →", "other": "{0} appareils →" },
- "modular.drag_from_a_cv_out": "Glisser d’une sortie CV sur un nœud pour le moduler · Space + glisser — déplacer la vue · ⌘ + molette — zoom · F — ajuster · Esc — afficher moins",
- "modular.edges": { "one": "{0} lien", "other": "{0} liens" },
- "modular.edit_modulation": "Modifier la modulation · {0}…",
- "modular.env": "Env",
- "modular.expose_as_cv_output": "Exposer comme sortie CV",
- "modular.fit": "Ajuster",
- "modular.fixed_the_chain_leaves_the": "Fixe — la chaîne quitte la piste vers le mixeur ici, donc il ne peut pas être supprimé.",
- "modular.fixed_the_tracks_clips_and": "Fixe — les clips et l’entrée de la piste entrent dans la chaîne ici, donc il ne peut pas être supprimé.",
- "modular.fixed_the_tracks_instrument_takes": "Fixe — l’instrument de la piste reçoit son MIDI ici. Il ne peut pas être supprimé ; déposer un autre instrument sur la piste pour le remplacer.",
- "modular.free": "Libre",
- "modular.from": "Depuis {0} · {1}",
- "modular.gain": "Gain",
- "modular.global": "Global",
- "modular.global_n": "Global · {0}",
- "modular.hide_the_parameters_that_arent": "Masquer les paramètres non modulés (Esc)",
- "modular.inst": "Inst {0}",
- "modular.instrument": "Instrument {0}",
- "modular.invert": "Inverser",
- "modular.islands": { "one": "{0} îlot", "other": "{0} îlots" },
- "modular.khz_ms": "{0:0.0} kHz · {1} · {2:0.0} ms",
- "modular.lfo_caps": "LFO",
- "modular.lfo_caps_n": "LFO {0}",
- "modular.macro": "Macro",
- "modular.math": "Math",
- "modular.max": "Max",
- "modular.midi_in": "Entrée MIDI",
- "modular.midi_out": "Sortie MIDI",
- "modular.mode": "Mode",
- "modular.modulate_from_a_parameter": "Moduler depuis un paramètre",
- "modular.modulate_from_another_track": "Moduler depuis une autre piste",
- "modular.modulate_with": "Moduler avec {0} {1}",
- "modular.multiply": "Multiply",
- "modular.no_modulatable_parameters_on_that": "Aucun paramètre modulable sur cette piste",
- "modular.no_parameters": "Aucun paramètre",
- "modular.no_tracks_yet": "Aucune piste pour l’instant",
- "modular.nodes": "{0} nœuds",
- "modular.nodes_caps": "{0} NŒUDS",
- "modular.note": "Note",
- "modular.offset": "Offset",
- "modular.open_in_a_window": "Ouvrir dans une fenêtre",
- "modular.out": "Sortie",
- "modular.override": "Forcer",
- "modular.parameter": "Paramètre",
- "modular.pattern": " · {0}",
- "modular.pattern_n": "{0} · {1} · {2}",
- "modular.phase": "Phase",
- "modular.pick_a_track_to_see": "Choisir une piste pour voir son graphe de signal",
- "modular.rate": "Rate",
- "modular.remove_connection": "Retirer la connexion",
- "modular.remove_modulation": "Retirer la modulation",
- "modular.rnd": "Rnd",
- "modular.saw": "Saw",
- "modular.scale": "Gamme",
- "modular.scope": "Scope",
- "modular.scope.back_to_the_live_trace": "Retour à la trace en direct",
- "modular.scope.drag_to_resize_the_trace": "Glisser pour redimensionner la trace",
- "modular.scope.free_running_the_newest_value": "Défilement libre : la valeur la plus récente est à droite",
- "modular.scope.hold_the_trace_while_the": "Figer la trace pendant que l’entrée continue",
- "modular.scope.rise": "Montée",
- "modular.scope.scope": "Scope {0} · {1}",
- "modular.scope.the_window_is_in_beats": "La fenêtre est en temps, au tempo. Cliquer pour passer en millisecondes",
- "modular.scope.the_window_is_in_milliseconds": "La fenêtre est en millisecondes. Cliquer pour la synchroniser au tempo",
- "modular.scope.trigger_start_the_trace_where": "Déclencheur : démarrer la trace là où l’entrée franchit 0 en montant, pour qu’une forme répétée reste immobile",
- "modular.scope.watches_cv_drag_a_modulators": "Surveille le CV. Glisser la sortie CV d’un modulateur sur ce nœud. Pour l’audio, mettre Lens sur la chaîne.",
- "modular.scope.window": "Fenêtre",
- "modular.scope.zoom": "Zoom",
- "modular.show_all_parameters": "Afficher tous les paramètres",
- "modular.show_fewer": "Afficher moins",
- "modular.show_fewer_parameters_esc": "Afficher moins de paramètres (Esc)",
- "modular.sine": "Sine",
- "modular.smooth": "Lisse",
- "modular.sqr": "Sqr",
- "modular.subtract": "Subtract",
- "modular.sync": "Sync",
- "modular.track_output": "Sortie de piste",
- "modular.tracks": "Pistes",
- "modular.tri": "Tri",
- "modular.unexpose_cv_output": "Ne plus exposer la sortie CV",
- "modular.vel": "Vel",
- "mosaic.library.couldnt_load_the_preset": "Impossible de charger le préréglage : {0}",
- "mosaic_create.analysis": "{0} · analyse",
- "mosaic_create.by_name_stem": "par radical du nom",
- "mosaic_create.create_1_preset": "Créer 1 préréglage",
- "mosaic_create.create_multisample": "Créer un multi-échantillon",
- "mosaic_create.create_presets": "Créer des préréglages",
- "mosaic_create.create_presets_n": "Créer {0} préréglages",
- "mosaic_create.duplicates": { "one": "{0} doublon", "other": "{0} doublons" },
- "mosaic_create.edge_zone_stretch": "Étirement des zones de bord",
- "mosaic_create.files": "{0} fichiers · {1}",
- "mosaic_create.gap_at_neighbours_stretched": "Trou à {0} — voisines étirées",
- "mosaic_create.layer": "{0} couche",
- "mosaic_create.mapping": "Assignation",
- "mosaic_create.mapping_2": "Assignation…",
- "mosaic_create.midi_caps": "{0} · MIDI",
- "mosaic_create.multisamples": "Multi-échantillons",
- "mosaic_create.next_to_gap": "à côté du trou",
- "mosaic_create.no_audio_files_with_a": "Aucun fichier audio avec une note dans son nom ou une hauteur claire.",
- "mosaic_create.no_repeat": "Sans répétition",
- "mosaic_create.notes_from_sample_analysis": { "one": "{0} note issue de l’analyse de l’échantillon", "other": "{0} notes issues de l’analyse de l’échantillon" },
- "mosaic_create.nothing_to_map": "rien à assigner",
- "mosaic_create.octave": "Octave",
- "mosaic_create.presets_will_appear_in_nota": "Les préréglages apparaîtront dans Nota Mosaic → Packs → {0}",
- "mosaic_create.reading_the_files": "Lecture des fichiers…",
- "mosaic_create.release_samples_release_group": "Échantillons de relâchement → groupe de relâchement",
- "mosaic_create.rnd": "Rnd",
- "mosaic_create.round_robin": "Round-robin",
- "mosaic_create.seq": "Séq",
- "mosaic_create.the_names_are_taken_as": "Les noms sont pris tels quels (C4 = 60).",
- "mosaic_create.velocity_layers_by_dynamics": "Couches de vélocité par dynamique",
- "mosaic_create.without_a_note_left_out": "{0} sans note — ignoré",
- "mosaic_create.zones": "{0}–{1} · {2} zones",
- "palette.categories.distortion": "Distorsion",
- "palette.categories.drums": "Batterie",
- "palette.categories.dynamics": "Dynamique",
- "palette.categories.eq_filter": "EQ et filtre",
- "palette.categories.generate": "Générer",
- "palette.categories.keys_physical": "Claviers et modélisation",
- "palette.categories.modulation": "Modulation",
- "palette.categories.pitch_time": "Hauteur et temps",
- "palette.categories.racks": "Racks",
- "palette.categories.reverb_delay": "Réverbération et delay",
- "palette.categories.samplers": "Samplers",
- "palette.categories.shape": "Forme",
- "palette.categories.synths": "Synthés",
- "palette.categories.utility": "Utilitaires",
- "palette.devices.3_band_eq": "EQ 3 bandes",
- "palette.devices.8_band_eq": "EQ 8 bandes",
- "palette.devices.a_single_gain_stage_with": "Un seul étage de gain avec un grand affichage.",
- "palette.devices.a_synth_with_a_built": "Un synthé avec un moteur de motifs intégré pour arpèges et séquences.",
- "palette.devices.algorithmic_reverb_from_small_rooms": "Réverbération algorithmique, des petites pièces aux grandes salles.",
- "palette.devices.amplifier": "amplificateur",
- "palette.devices.analog_synth": "synthé analogique",
- "palette.devices.analyzer_scope": "analyseur / oscilloscope",
- "palette.devices.arp_synth": "synthé arpégiateur",
- "palette.devices.auto_pan": "auto-pan",
- "palette.devices.auto_pan_and_tremolo_synced": "Auto-pan et trémolo synchronisés au tempo.",
- "palette.devices.bit_crusher": "bit crusher",
- "palette.devices.bit_depth_and_sample_rate": "Réduction de la profondeur de bits et de la fréquence d’échantillonnage.",
- "palette.devices.brickwall_limiter_for_the_master": "Limiteur brickwall pour le master.",
- "palette.devices.built_in": "intégrés",
- "palette.devices.captures_and_repeats_slices_for": "Capture et répète des tranches pour des bégaiements et des glitchs.",
- "palette.devices.chains_of_midi_effects": "chaînes d’effets MIDI",
- "palette.devices.chorus": "chorus",
- "palette.devices.chorus_and_ensemble_for_width": "Chorus et ensemble pour la largeur et le scintillement.",
- "palette.devices.classic_jet_flanger": "Flanger jet classique.",
- "palette.devices.compressor_with_sidechain_and_five": "Compresseur avec sidechain et cinq caractères — glue, punch et pumping.",
- "palette.devices.drum_machine": "boîte à rythmes",
- "palette.devices.dynamic_eq": "EQ dynamique",
- "palette.devices.eight_band_parametric_eq_with": "EQ paramétrique à huit bandes avec spectre en direct.",
- "palette.devices.eight_voice_drum_machine_with": "Boîte à rythmes à huit voix avec séquenceur pas à pas.",
- "palette.devices.electric_piano": "piano électrique",
- "palette.devices.envelope_lfo": "enveloppe / LFO",
- "palette.devices.eq_bands_that_react_to": "Bandes d’EQ qui réagissent au niveau — dé-essage et contrôle des résonances.",
- "palette.devices.five_voice_vintage_polysynth_lush": "Polysynthé vintage à cinq voix — nappes riches, cuivres et claviers.",
- "palette.devices.flanger": "flanger",
- "palette.devices.fm_synth": "synthé FM",
- "palette.devices.fm_synthesis_bells_electric_pianos": "Synthèse FM — cloches, pianos électriques et basses dures.",
- "palette.devices.force_note_length": "durée de note imposée",
- "palette.devices.forces_note_lengths_staccato_legato": "Impose les durées de notes — staccato, legato ou fixes.",
- "palette.devices.gain": "gain",
- "palette.devices.gain_width_mono_and_phase": "Gain, largeur, mono et phase — l’outil de base.",
- "palette.devices.gate": "gate",
- "palette.devices.glitch_repeats": "glitch et répétitions",
- "palette.devices.granular_synth": "synthé granulaire",
- "palette.devices.granular_synth_that_turns_a": "Synthé granulaire qui transforme un échantillon en nuages, textures et drones.",
- "palette.devices.guitar_amp_and_cabinet_models": "Modèles d’amplis et de baffles de guitare, du son clair au fort gain.",
- "palette.devices.hybrid_reverb": "réverbération hybride",
- "palette.devices.hybrid_reverb_with_early_reflections": "Réverbération hybride avec premières réflexions et longue queue dense.",
- "palette.devices.keeps_notes_in_a_key": "Garde les notes dans une tonalité et une gamme.",
- "palette.devices.layered_looper_with_overdubs": "Looper à couches avec superpositions.",
- "palette.devices.layers_several_instruments_in_parallel": "Superpose plusieurs instruments dans des chaînes parallèles.",
- "palette.devices.limiter": "limiteur",
- "palette.devices.looper": "looper",
- "palette.devices.modelled_electric_piano_tine_suitcase": "Piano électrique modélisé — tine, suitcase, reed et clav avec trémolo, phaser et baffle.",
- "palette.devices.mono_synth": "synthé mono",
- "palette.devices.monophonic_analog_style_synth_for": "Synthé monophonique de style analogique pour basses épaisses et leads.",
- "palette.devices.multi_stage_phaser": "Phaser multi-étages.",
- "palette.devices.multiband_dynamics": "dynamique multibande",
- "palette.devices.multisample": "multi-échantillons",
- "palette.devices.multisample_instrument_zones_by_key": "Instrument multi-échantillons — zones par touche et vélocité, round-robin et échantillons de relâchement ; import SFZ et packs.",
- "palette.devices.noise_gate_and_rhythmic_trance": "Noise gate et trance gate rythmique.",
- "palette.devices.paraphonic_ensemble_synth_string_machines": "Synthé d’ensemble paraphonique — string machines et chœurs.",
- "palette.devices.paraphonic_synth": "synthé paraphonique",
- "palette.devices.phaser": "phaser",
- "palette.devices.physical_modelling_of_struck_plucked": "Modélisation physique de corps frappés, pincés et soufflés.",
- "palette.devices.physical_synth": "synthé à modélisation physique",
- "palette.devices.pitch_correction": "correction de hauteur",
- "palette.devices.pitch_quantize": "quantification de hauteur",
- "palette.devices.plays_a_sample_across_the": "Joue un échantillon sur tout le clavier.",
- "palette.devices.poly_synth": "synthé polyphonique",
- "palette.devices.random_transpose": "transposition aléatoire",
- "palette.devices.random_transposition_timing_and_dropouts": "Transposition, timing et silences aléatoires.",
- "palette.devices.real_time_pitch_correction_to": "Correction de hauteur en temps réel vers une tonalité et une gamme.",
- "palette.devices.reshapes_compresses_or_randomises_note": "Remodèle, comprime ou randomise les vélocités des notes.",
- "palette.devices.resonant_filter_swept_by_an": "Filtre résonant balayé par un suiveur d’enveloppe ou un LFO.",
- "palette.devices.runs_several_effect_chains_in": "Exécute plusieurs chaînes d’effets en parallèle.",
- "palette.devices.saturator": "saturateur",
- "palette.devices.shapes_this_tracks_sound_with": "Façonne le son de cette piste avec la voix d’une autre piste.",
- "palette.devices.sixteen_pads_each_with_its": "Seize pads, chacun avec son propre échantillon ou sa chaîne d’instruments.",
- "palette.devices.spectrum_analyser_oscilloscope_and_level": "Analyseur de spectre, oscilloscope et vumètre.",
- "palette.devices.splits_notes_across_chains_of": "Répartit les notes entre des chaînes d’effets MIDI selon la touche, la vélocité ou un sélecteur.",
- "palette.devices.stacked_intervals": "intervalles superposés",
- "palette.devices.step_arpeggiator": "arpégiateur pas à pas",
- "palette.devices.step_arpeggiator_with_groove_lanes": "Arpégiateur pas à pas avec voies de groove.",
- "palette.devices.stereo_and_ping_pong_delay": "Delay stéréo et ping-pong synchronisé au tempo.",
- "palette.devices.tape_and_tube_saturation_warmth": "Saturation à bande et à lampes — chaleur, wow et flutter.",
- "palette.devices.three_band_dj_style_eq": "EQ trois bandes façon DJ avec kills.",
- "palette.devices.three_band_upward_and_downward": "Compression ascendante et descendante en trois bandes — densité façon OTT.",
- "palette.devices.turns_single_notes_into_chords": "Transforme des notes seules en accords.",
- "palette.devices.two_oscillator_analog_style_synth": "Synthé de style analogique à deux oscillateurs avec drive et pile d’unissons — nappes, basses, lignes acid et leads.",
- "palette.devices.vector_morph_synth": "synthé à morphing vectoriel",
- "palette.devices.vector_synth_morphing_between_sources": "Synthé vectoriel qui fond entre des sources — nappes et textures mouvantes.",
- "palette.devices.velocity_shaping": "façonnage de la vélocité",
- "palette.devices.vintage_saturator": "saturateur vintage",
- "palette.devices.vocoder": "vocoder",
- "palette.devices.waveshaping_saturator_from_soft_warmth": "Saturateur à mise en forme d’onde, de la chaleur douce à l’écrêtage dur.",
- "palette.devices.wavetable_synth": "synthé à tables d’ondes",
- "palette.devices.wavetable_synth_with_warping_oscillators": "Synthé à tables d’ondes avec oscillateurs déformants — nappes évolutives et leads modernes.",
- "palette.index.1_item": "1 élément",
- "palette.index.indexing": "indexation de {0}… {1} %",
- "palette.index.items": "{0} éléments",
- "palette.modular.a_low_frequency_oscillator_free": "Un oscillateur basse fréquence, libre ou synchronisé au tempo.",
- "palette.modular.adds_multiplies_or_mixes_two": "Additionne, multiplie ou mélange deux signaux de contrôle.",
- "palette.modular.an_attack_decay_sustain_release": "Une enveloppe attaque-déclin-maintien-relâchement déclenchée par les notes.",
- "palette.modular.control": "Contrôle",
- "palette.modular.converter": "Convertisseur",
- "palette.modular.cv_utility": "Utilitaire CV",
- "palette.modular.modulator": "Modulateur",
- "palette.modular.monitor": "Écoute",
- "palette.modular.one_knob_driving_several_destinations": "Un potentiomètre qui pilote plusieurs destinations.",
- "palette.modular.shows_a_control_signal_over": "Affiche un signal de contrôle au fil du temps.",
- "palette.modular.turns_notes_velocity_and_controllers": "Transforme notes, vélocité et contrôleurs en signaux de contrôle.",
- "palette.modular.turns_the_tracks_loudness_into": "Transforme le volume de la piste en signal de contrôle : un contrôleur de crête, pour faire ducker une piste sous une autre.",
- "palette.search.actions": "Actions",
- "palette.search.device_window": "Fenêtre d’appareil",
- "palette.search.devices": "Appareils",
- "palette.search.presets": "Préréglages",
- "palette.search.suggested": "Suggestions · {0}",
- "palette.search.tracks": "Pistes",
- "palette.targets.after": "après {0}",
- "palette.targets.canvas_unconnected": "canevas, non connecté",
- "palette.targets.end_of_audio_fx": "fin des effets audio",
- "palette.targets.end_of_chain": "fin de la chaîne",
- "palette.targets.end_of_midi_fx": "fin des effets MIDI",
- "palette.targets.instrument": "instrument",
- "palette.targets.keep_open": " · garder ouvert",
- "palette.targets.loads_the_kit": "charge le kit",
- "palette.targets.midi_effects_need_an_instrument": "Les effets MIDI nécessitent une piste d’instrument",
- "palette.targets.midi_fx_end": "effets MIDI, fin",
- "palette.targets.new_chain_in_instrument_rack": "nouvelle chaîne dans Instrument Rack",
- "palette.targets.new_midi_track": "→ nouvelle piste MIDI{0}",
- "palette.targets.new_pad_in_drum_rack": "nouveau pad dans Drum Rack",
- "palette.targets.new_track": "→ nouvelle piste{0}",
- "palette.targets.open_in_devices": "→ ouvrir {0} dans Appareils",
- "palette.targets.pattern": "→ {0} · {1}{2}",
- "palette.targets.replaces": "remplace {0}",
- "palette.targets.replaces_the_instrument": "remplace l’instrument",
- "palette.targets.run": "↵ exécuter",
- "palette.targets.select_a_track_first": "Sélectionner d’abord une piste",
- "palette.targets.select_in": "→ sélectionner {0} dans {1}",
- "palette.targets.track": "piste {0}",
- "palette_providers.audio_fx": "Effets audio",
- "palette_providers.kits": "Kits",
- "palette_providers.midi_caps": "MIDI · {0}",
- "palette_providers.midi_fx_caps": "Effets MIDI",
- "palette_providers.modular": "Modular · {0}",
- "palette_providers.preset": "Préréglage",
- "persistence.preset.couldnt_load_the_sample": "Impossible de charger l’échantillon « {0} ».",
- "persistence.preset.couldnt_prepare_the_multisample": "Impossible de préparer le multi-échantillon « {0} ».",
- "persistence.preset.couldnt_prepare_the_sample": "Impossible de préparer l’échantillon « {0} ».",
- "persistence.preset.failed_to_add_device": "Échec de l’ajout de l’appareil.",
- "persistence.preset.failed_to_add_instrument": "Échec de l’ajout de l’instrument.",
- "persistence.preset.failed_to_add_midi_effect": "Échec de l’ajout de l’effet MIDI.",
- "persistence.preset.failed_to_load_instrument": "Échec du chargement de l’instrument.",
- "persistence.preset.failed_to_load_plugin": "Échec du chargement du plug-in.",
- "persistence.preset.not_a_midi_effect": "Ce n’est pas un effet MIDI.",
- "persistence.preset.not_an_effect": "Ce n’est pas un effet.",
- "persistence.preset.plugin_not_installed": "Plug-in non installé : {0}",
- "persistence.preset.preset_cant_be_applied_in": "Le préréglage ne peut pas être appliqué sur place.",
- "persistence.preset.unknown_preset_type": "Type de préréglage inconnu.",
- "persistence.project_history.this_version_was_saved_by": "Cette version a été enregistrée par Nota {0}, plus récent que celui-ci. Mettre Nota à jour pour l’ouvrir.",
- "piano_roll.1_note_vel": "1 note · {0} · vél {1}",
- "piano_roll.a_session_slot_plays_on": "Un emplacement de Session joue sur sa propre horloge de boucle — le lancer pour jouer depuis le début",
- "piano_roll.clear": "Effacer {0}",
- "piano_roll.clip_strip.click_a_clip_to_edit": "Clic sur un clip pour l’éditer · le verrou garde un clip comme référence",
- "piano_roll.controllers.drag_to_draw": "Glisser pour dessiner",
- "piano_roll.controllers.drag_to_draw_a_block": "Glisser pour dessiner un bloc",
- "piano_roll.controllers.other_cc": "Autre CC",
- "piano_roll.expression.bend": "Bend",
- "piano_roll.expression.clear_all_expression": "Effacer toute l’expression",
- "piano_roll.expression.pres": "Pres",
- "piano_roll.expression.pressure": "Pression",
- "piano_roll.expression.slide": "Slide",
- "piano_roll.expression.vel": "Vel",
- "piano_roll.no_selection": "Aucune sélection",
- "piano_roll.notes": "{0} notes",
- "piano_roll.reset_velocity": "Réinitialiser la vélocité",
- "plugin_scan.looking_for_plugins": "Recherche de plug-ins…",
- "plugin_scan.scanning_plugins_of": "Analyse des plug-ins · {0:N0} sur {1:N0}",
- "plugin_store.archive_unpacker.a_archive_can_only_be": "Une archive .{0} ne peut être décompressée que sous macOS.",
- "plugin_store.archive_unpacker.couldnt_start": "Impossible de lancer {0}.",
- "plugin_store.archive_unpacker.failed": "Échec de {0} ({1}) : {2}",
- "plugin_store.archive_unpacker.the_archive_contains_an_unsafe": "L’archive contient un chemin dangereux : {0}",
- "plugin_store.archive_unpacker.the_deb_archive_has_no": "L’archive .deb ne contient aucune donnée.",
- "plugin_store.archive_unpacker.the_deb_archive_is_damaged": "L’archive .deb est endommagée.",
- "plugin_store.archive_unpacker.the_deb_archive_is_truncated": "L’archive .deb est tronquée.",
- "plugin_store.archive_unpacker.unpacking_needs_which_wasnt_found": "La décompression demande « {0} », introuvable.",
- "plugin_store.archive_unpacker.unsupported_archive_type": "Type d’archive « {0} » non pris en charge.",
- "plugin_store.installing": "Installation de {0}…",
- "ports.i_process_cpu.of_all_cpus": "de tous les CPU",
- "ports.i_process_cpu.of_one_core": "d’un cœur",
- "preferences.a_b_compare_move_copy": "Comparaison A / B, déplacer, copier, supprimer, préréglages, enregistrer le préréglage",
- "preferences.a_multi_selection_gets_its": "Une sélection multiple a son propre menu : couleur, hauteur, gel, groupe, copie, duplication, suppression",
- "preferences.add_a_note_with_the": "Ajouter une note avec la longueur et la vélocité de la dernière note touchée · sur une note, la supprimer",
- "preferences.add_a_point_on_a": "Ajouter un point · sur un point, le supprimer · clic droit pour effacer la courbe",
- "preferences.add_a_warp_marker_on": "Ajouter un marqueur de warp · sur un marqueur, le supprimer",
- "preferences.add_an_instrument_audio_or": "Ajouter une piste d’instrument, audio ou de retour · en renommer ou en supprimer une",
- "preferences.add_folder": "Ajouter un dossier…",
- "preferences.add_plugin_scan_folder": "Ajouter un dossier d’analyse de plug-ins",
- "preferences.add_the_track_to_the": "Ajouter la piste à la sélection · de nouveau pour la retirer",
- "preferences.add_this_config_or_the": "Ajouter cette config (ou l’URL) comme serveur MCP dans Claude Desktop / Claude Code. Boucle locale uniquement ; désactivé par défaut.",
- "preferences.adding_a_plug_in_from": "L’ajout d’un plug-in depuis le navigateur, par glisser-déposer ou depuis la palette, ouvre son éditeur. Le chargement d’un projet, l’annulation et le collage ne l’ouvrent jamais.",
- "preferences.ai_control_mcp": "Contrôle par IA (MCP)",
- "preferences.align_the_audio_to_the": "Aligner l’audio sur la grille · la forme d’onde s’étire pendant le glissement",
- "preferences.all": "Tous",
- "preferences.always_start_a_new_track": "Toujours créer une nouvelle piste avec lui",
- "preferences.an_instrument_or_instrument_preset": "Un instrument ou un préréglage d’instrument sur une nouvelle piste · une piste : l’ouvrir dans Appareils",
- "preferences.any_button": "N’importe quel bouton",
- "preferences.any_button_can_be_mapped": "Un bouton quelconque peut être assigné à une commande à la place : cliquer sur MIDI en haut à droite, cliquer sur la commande, puis appuyer sur le bouton. Un bouton assigné pilote cette commande et ne joue plus sa note ; le reste de la manette garde la disposition ci-dessus. Les sticks et la course des gâchettes s’assignent de la même façon et sont continus, ce qui convient à un bouton rotatif ou à un fader : ils ne jouent aucune note et ne font rien tant qu’ils ne sont pas assignés. Les assignations sont listées dans l’onglet Carte MIDI du navigateur et suivent le projet.",
- "preferences.appearance": "Apparence",
- "preferences.apply_and_keep_the_palette": "Appliquer et garder la palette ouverte pour l’appareil suivant",
- "preferences.apply_where_the_palette_was": "Appliquer là où la palette a été ouverte (la cible s’affiche dans le champ)",
- "preferences.arrangement_editing": "Arrangement et édition",
- "preferences.asio_caps": "ASIO",
- "preferences.asio_frames": "ASIO · {0} échantillons @ {1}{2}",
- "preferences.asio_unavailable_wasapi": "ASIO indisponible ({0}) → WASAPI",
- "preferences.audio_clip_editor": "Éditeur de clips audio",
- "preferences.audio_clip_editor_on_adsr": "Éditeur de clips audio sur ADSR ou sur un clip non warpé",
- "preferences.audio_device": "Périphérique audio",
- "preferences.audio_device_not_running": "Le périphérique audio n’est pas démarré.",
- "preferences.audio_settings_are_unavailable_in": "Les réglages audio ne sont pas disponibles dans cette fenêtre.",
- "preferences.audio_system": "Système audio",
- "preferences.back_to_the_standard_height": "Retour à la hauteur standard",
- "preferences.bars": "Barres",
- "preferences.bend_range": "Amplitude du pitch bend",
- "preferences.black_keys_sharps": "Touches noires (dièses)",
- "preferences.browser_preview": "Navigateur · aperçu",
- "preferences.buffer_size": "Taille de la mémoire tampon",
- "preferences.bypass_the_selected_device": "Contourner l’appareil sélectionné",
- "preferences.cancel_the_current_gesture_clear": "Annuler le geste en cours / effacer la sélection · fermer la baie de brassage",
- "preferences.change_a_device_value_hold": "Changer une valeur d’appareil · maintenir ⌘ ou ⇧ pour des pas fins",
- "preferences.change_its_velocity_the_whole": "Changer sa vélocité · celle de toute la sélection si la note est sélectionnée · ailleurs, défiler latéralement",
- "preferences.change_the_notes_start_or": "Changer le début ou la fin de la note",
- "preferences.channels_2_16_each_carry": "Les canaux 2 à 16 portent chacun une note avec son propre pitch bend, sa pression et son glissement (CC74). Un contrôleur qui annonce son amplitude remplace celle-ci. Le canal 1 se joue comme un clavier ordinaire, sa molette de hauteur et son aftertouch agissant sur tout l’instrument. ",
- "preferences.choose": "Choisir…",
- "preferences.choose_folder": "Choisir le dossier {0}",
- "preferences.clear_the_device_selection_so": "Effacer la sélection d’appareils · un clic dans l’espace vide de la chaîne fait de même",
- "preferences.clear_the_route_volt_aurora": "Effacer la route (Volt, Aurora) · retirer le câble (Consort)",
- "preferences.click_a_clip_in_the": "Clic sur un clip du bandeau de clips",
- "preferences.click_a_clip_or_arm": "⌥-clic sur un clip ou sur Armer",
- "preferences.click_a_device": "Clic sur un appareil",
- "preferences.click_a_graph_handle_envelope": "⌥-clic sur une poignée de graphique, un nœud d’enveloppe ou une cellule de la matrice de modulation",
- "preferences.click_a_groups_link_key": "Clic sur la touche Link d’un groupe",
- "preferences.click_a_height_key_in": "⌥-clic sur une touche de hauteur dans le menu de piste",
- "preferences.click_a_key": "Clic sur une touche",
- "preferences.click_a_knob_fader_or": "⌥-clic sur un bouton rotatif, un fader ou un curseur",
- "preferences.click_a_rhythm_step": "Clic · ⇧ · ⌥ sur un pas Rhythm",
- "preferences.click_a_rhythm_voice": "Clic sur une voix Rhythm",
- "preferences.click_drag_the_ruler": "Clic · glisser sur la règle",
- "preferences.click_play_button": "Clic sur le bouton de lecture",
- "preferences.click_section": "Clic sur une section",
- "preferences.click_the_bend_lanes_range": "Clic sur l’amplitude du couloir Bend",
- "preferences.click_the_controller_tab": "Clic sur l’onglet de contrôleur",
- "preferences.click_the_position_read_out": "Clic sur l’affichage de la position",
- "preferences.click_track_header": "⇧-clic sur un en-tête de piste",
- "preferences.click_wave_spec": "Clic sur WAVE / SPEC",
- "preferences.click_waveform": "Clic sur la forme d’onde",
- "preferences.close_and_go_back_where": "Fermer et revenir où l’on était",
- "preferences.close_to_the_limit_consider": "proche de la limite : envisager un tampon plus grand",
- "preferences.colour_theme": "Thème de couleurs",
- "preferences.command_palette": "Palette de commandes",
- "preferences.consolidate_the_selection_into_one": "Consolider la sélection en un clip par piste",
- "preferences.content_folders": "Dossiers de contenu",
- "preferences.content_folders_and_version_history": "Dossiers de contenu et historique des versions",
- "preferences.content_folders_are_unavailable_in": "Les dossiers de contenu ne sont pas disponibles dans cette fenêtre.",
- "preferences.controllers_nota_listens_to": "Contrôleurs écoutés par Nota",
- "preferences.copied": "Copié",
- "preferences.copy_config": "Copier la config",
- "preferences.copy_cut_paste_a_clip": "Copier / couper / coller un clip · un clip coupé se déplace au collage · les clips copiés dans l’arrangement se collent ici",
- "preferences.copy_cut_paste_clips_a": "Copier / couper / coller des clips, une plage de temps ou une plage d’automation · colle sur la dernière piste cliquée",
- "preferences.copy_cut_paste_notes_paste": "Copier / couper / coller des notes · le collage se place sur les originaux",
- "preferences.copy_cut_paste_the_selected": "Copier / couper / coller les appareils sélectionnés avec tous leurs réglages · chacun se place dans sa section après l’appareil sélectionné · un instrument copié remplace l’instrument sur lequel il est collé",
- "preferences.copy_cut_paste_the_selected_2": "Copier / couper / coller les pistes sélectionnées · le collage se place après la dernière",
- "preferences.copy_it_there": "L’y copier",
- "preferences.copy_the_selected_clip_group": "Copier le clip, l’emplacement de groupe ou la scène sélectionnés vers l’arrangement, à la tête de lecture",
- "preferences.copy_the_selected_clips_to": "Copier les clips sélectionnés vers Session · dans la première rangée de scènes où ils tiennent",
- "preferences.couldnt_be_loaded_see_plugin": " Impossible d’en charger {0:N0} : voir plugin-scan.log dans le dossier de journaux de Nota.",
- "preferences.count_in_before_play_record": "Décompte avant Lecture / Enregistrement : désactivé · 1 · 2 · 4 mesures",
- "preferences.cpu_check": "Test du CPU",
- "preferences.custom": "personnalisé",
- "preferences.cycle_devices_pattern_clip_in": "Passer d’Appareils à Pattern puis à Clip dans le panneau de détail",
- "preferences.d_pad_left_right": "Croix ← / →",
- "preferences.d_pad_up_down": "Croix ↑ / ↓",
- "preferences.dark": "Sombre",
- "preferences.deactivate_activate_the_selected_clip": "Désactiver / activer le ou les clips sélectionnés",
- "preferences.default": "par défaut",
- "preferences.delete_device_selected": "Delete (appareil sélectionné)",
- "preferences.delete_the_selected_clip_or": "Supprimer le clip ou la scène sélectionnés",
- "preferences.delete_the_selected_clip_range": "Supprimer le clip / la plage sélectionnés",
- "preferences.delete_the_selected_device_modulator": "Supprimer l’appareil, le modulateur ou le câble sélectionné · l’entrée, l’instrument et la sortie de la piste sont fixes",
- "preferences.delete_the_selected_devices_with": "Supprimer les appareils sélectionnés · avec l’instrument, sa piste",
- "preferences.delete_the_selected_notes": "Supprimer les notes sélectionnées",
- "preferences.delete_the_selected_tracks_a": "Supprimer les pistes sélectionnées · un groupe part avec ses pistes",
- "preferences.deselect_moved_or_pasted_notes": "Désélectionner · les notes déplacées ou collées remplacent celles qui sont dessous",
- "preferences.detail_panel": "Panneau de détail",
- "preferences.device_default": "Par défaut du périphérique",
- "preferences.device_sample_rate_and_buffer": "Périphérique, fréquence d’échantillonnage et mémoire tampon",
- "preferences.devices_after_a_click_on": "Appareils (après un clic sur un appareil)",
- "preferences.devices_settings": "Périphériques",
- "preferences.direction": "Sens",
- "preferences.double_click_a_browser_instrument": "Double-clic sur un instrument du navigateur",
- "preferences.double_click_a_chain_or": "Double-clic sur le nom d’une chaîne ou d’une macro",
- "preferences.double_click_a_knob_fader": "Double-clic sur un bouton rotatif, un fader ou un curseur",
- "preferences.double_click_a_mod_matrix": "Double-clic sur une cellule de la matrice de modulation",
- "preferences.double_click_a_panel_edge": "Double-clic sur le bord d’un panneau",
- "preferences.double_click_a_track_header": "Double-clic sur un en-tête de piste",
- "preferences.double_click_a_tracks_bottom": "Double-clic sur le bord inférieur d’une piste",
- "preferences.double_click_and_hold_drag": "Double-clic maintenu, puis glisser",
- "preferences.double_click_clip": "Double-clic sur un clip",
- "preferences.double_click_empty_grid": "Double-clic sur la grille vide",
- "preferences.double_click_header": "Double-clic sur un en-tête",
- "preferences.double_click_in_an_mpe": "Double-clic dans un couloir MPE",
- "preferences.double_click_loop_brace": "Double-clic sur l’accolade de boucle",
- "preferences.double_click_overview": "Double-clic sur l’aperçu",
- "preferences.double_click_section": "Double-clic sur une section",
- "preferences.double_click_slot": "Double-clic sur un emplacement",
- "preferences.double_click_the_wave": "Double-clic sur la forme d’onde",
- "preferences.double_click_velocity_stem": "Double-clic sur une tige de vélocité",
- "preferences.downloading": "Téléchargement de {0}…",
- "preferences.downloads": "Téléchargements",
- "preferences.downloads.ai_models": "Modèles d’IA",
- "preferences.downloads.sample_packs": "Packs d’échantillons",
- "preferences.drag_a_device_header": "Glisser l’en-tête d’un appareil",
- "preferences.drag_a_device_onto_a": "Glisser un appareil sur une piste",
- "preferences.drag_a_device_onto_a_2": "⌥-glisser un appareil sur une piste",
- "preferences.drag_a_devices_header": "Glisser l’en-tête d’un appareil",
- "preferences.drag_a_returns_or_the": "Glisser le bord inférieur d’un retour ou du master",
- "preferences.drag_a_selected_devices_header": "Glisser l’en-tête d’un appareil sélectionné",
- "preferences.drag_a_tracks_bottom_edge": "Glisser le bord inférieur d’une piste",
- "preferences.drag_a_tracks_bottom_edge_2": "Glisser le bord inférieur d’une piste + ⌥",
- "preferences.drag_a_warp_marker": "Glisser un marqueur de warp",
- "preferences.drag_a_zone_edge": "Glisser le bord d’une zone",
- "preferences.drag_an_audio_clip_onto": "Glisser un clip audio sur une piste d’instrument",
- "preferences.drag_an_audio_clip_out": "Glisser un clip audio hors de l’arrangement",
- "preferences.drag_an_audio_clips_adsr": "Glisser la poignée ADSR d’un clip audio",
- "preferences.drag_below_the_last_track": "Glisser sous la dernière piste",
- "preferences.drag_clip": "Glisser un clip",
- "preferences.drag_clip_2": "Glisser un clip + ⌥",
- "preferences.drag_double_click_tempo": "Glisser · double-clic sur Tempo",
- "preferences.drag_in_a_controller_lane": "Glisser dans un couloir de contrôleur",
- "preferences.drag_in_the_bend_pres": "Glisser dans le couloir Bend / Pres / Slide",
- "preferences.drag_in_the_sustain_lane": "Glisser dans le couloir Sustain",
- "preferences.drag_jack_jack": "Glisser jack → jack",
- "preferences.drag_knob": "Glisser un bouton rotatif",
- "preferences.drag_loop_edge_drag_loop": "Glisser le bord de la boucle · glisser l’accolade de boucle",
- "preferences.drag_note_edge": "Glisser le bord d’une note",
- "preferences.drag_on_the_keys": "Glisser sur les touches",
- "preferences.drag_overview_edge": "Glisser le bord de l’aperçu",
- "preferences.drag_overview_strip": "Glisser le bandeau d’aperçu",
- "preferences.drag_scene": "Glisser une scène",
- "preferences.drag_section": "Glisser une section",
- "preferences.drag_section_2": "⌥-glisser une section",
- "preferences.drag_section_edge": "Glisser le bord d’une section",
- "preferences.drag_sections_lane": "Glisser dans le couloir des sections",
- "preferences.drag_sideways_to_scroll_up": "Glisser latéralement pour défiler · vers le haut / le bas pour dézoomer / zoomer",
- "preferences.drag_slider": "Glisser un curseur",
- "preferences.drag_the_playhead_line": "Glisser la ligne de la tête de lecture",
- "preferences.drag_the_track_list_edge": "Glisser le bord de la liste des pistes",
- "preferences.drag_velocity_stem": "Glisser une tige de vélocité",
- "preferences.draw_a_pedal_block_on": "Dessiner un bloc de pédale sur la grille · ⌘ hors de la grille · glisser un bord pour redimensionner, le corps pour déplacer · double-clic ou Delete le supprime",
- "preferences.draw_the_controllers_curve_draws": "Dessiner la courbe du contrôleur · ⌥ trace une ligne droite · glisser un point pour le déplacer · double-clic ajoute ou supprime un point",
- "preferences.draw_the_selected_notes_mpe": "Dessiner la courbe MPE de la note sélectionnée · ⌥ trace une ligne droite · glisser un point pour le déplacer",
- "preferences.driver": "Pilote",
- "preferences.driver_settings": "Réglages du pilote…",
- "preferences.dropouts": { "one": "{0} décrochage", "other": "{0} décrochages" },
- "preferences.duplicate_a_clip_into_the": "Dupliquer un clip dans l’emplacement du dessous · une scène sous elle-même",
- "preferences.duplicate_the_selected_clip_s": "Dupliquer le ou les clips / la plage sélectionnés",
- "preferences.duplicate_the_selected_device_with": "Dupliquer l’appareil sélectionné avec tous ses réglages",
- "preferences.duplicate_the_selected_devices_each": "Dupliquer les appareils sélectionnés · chaque série juste après elle-même",
- "preferences.duplicate_the_selected_tracks": "Dupliquer les pistes sélectionnées",
- "preferences.duplicate_the_selection_replaces_the": "Dupliquer la sélection · remplace les notes sur lesquelles elle tombe",
- "preferences.duplicate_time_insert_a_copy": "Dupliquer le temps · insérer une copie de la plage de temps après elle, en repoussant tout ce qui suit",
- "preferences.edit_the_clip_an_empty": "Éditer le clip · un emplacement MIDI vide reçoit un nouveau clip",
- "preferences.enable_mcp_server_let_an": "Activer le serveur MCP (laisser une IA piloter Nota)",
- "preferences.end_macro_mapping_map_on": "Terminer l’assignation de macro (Assigner sur la carte du rack)",
- "preferences.enter_leave_full_screen_the": "Entrer dans le plein écran / en sortir : la barre de titre se masque en plein écran",
- "preferences.every_save_records_a_version": "Chaque enregistrement crée une version, listée dans l’onglet Historique du navigateur. Les versions partagent leur audio : chacune ne coûte que ce qu’elle ajoute.",
- "preferences.exclusive_mode": "Mode exclusif",
- "preferences.export_audio": "Exporter l’audio",
- "preferences.expression": "Expression",
- "preferences.extra_folders_are_searched_for": "Des dossiers supplémentaires sont explorés à la recherche de plug-ins VST3 à la prochaine analyse (les AU utilisent le registre du système).",
- "preferences.face_buttons": "Boutons de face",
- "preferences.filter_all_actions_tracks_devices": "Filtre : tout · actions · pistes · appareils · préréglages",
- "preferences.filter_shortcuts": "Filtrer les raccourcis",
- "preferences.fit_every_node_on_screen": "Ajuster tous les nœuds à l’écran",
- "preferences.fit_the_whole_project_on": "Ajuster tout le projet à l’écran",
- "preferences.fit_to_notes": "Ajuster aux notes",
- "preferences.fold_only_the_scales_notes": "Replier : seulement les notes de la gamme, ou les pads d’un Drum Rack",
- "preferences.follow_system": "Suivre le système",
- "preferences.found_plugins": { "one": "{0:N0} plug-in trouvé.", "other": "{0:N0} plug-ins trouvés." },
- "preferences.frames": "{0} échantillons @ {1}{2}",
- "preferences.frames_set_in_the_drivers": "{0} échantillons (défini dans les réglages du pilote)",
- "preferences.gamepad_input": "Entrée manette",
- "preferences.gamepad_input_is_macos_only": "Les manettes ne sont prises en charge que sous macOS dans cette version.",
- "preferences.gamepad_macos": "Manette (macOS)",
- "preferences.gamepad_settings_are_unavailable_in": "Les réglages des manettes ne sont pas disponibles dans cette fenêtre.",
- "preferences.gamepads": "Manettes",
- "preferences.general": "Général",
- "preferences.grid_arrangement_or_clip_editor": "Grille (arrangement ou éditeur de clips : le dernier utilisé)",
- "preferences.group_the_selected_devices_into": "Grouper les appareils sélectionnés dans un rack · effets audio : Audio Effect Rack · effets MIDI : MIDI Effect Rack · avec l’instrument : Instrument Rack",
- "preferences.group_ungroup_selected_tracks_on": "Grouper / dégrouper les pistes sélectionnées · sur des appareils sélectionnés : les grouper dans un rack / défaire un rack",
- "preferences.hover_the_zones": "Survoler les zones",
- "preferences.how_audio_clips_draw_on": "Dessin des clips audio dans l’arrangement : « Lisse » trace le contour des pics autour du niveau RMS ; « Plein » dessine chaque pixel ; « Barres » espace les pics pour que le rythme se lise. « Plein » et « Barres » règlent aussi l’aperçu du navigateur.",
- "preferences.hz_sine_at_14_dbfs": "Sinus de {0:0} Hz à −14 dBFS, via le master.",
- "preferences.in_a_linked_group_select": "Dans un groupe lié : sélectionner ce clip seul, ou armer cette piste seule",
- "preferences.in_dark_mode": "En mode sombre",
- "preferences.in_light_mode": "En mode clair",
- "preferences.insert_a_scene_below_the": "Insérer une scène sous la sélection",
- "preferences.insert_silence_push_everything_from": "Insérer du silence · repousser tout ce qui suit le début de la plage de sa longueur",
- "preferences.install": "Installer",
- "preferences.installed": "Installé",
- "preferences.installed_to": "Installé dans {0}",
- "preferences.installing": "Installation…",
- "preferences.interface_scale": "Échelle de l’interface",
- "preferences.jump_the_playhead_to_its": "Placer la tête de lecture à son début",
- "preferences.keep_a_version_history_of": "Conserver un historique des versions de chaque projet",
- "preferences.keep_the_name_empty_automatic": "Garder le nom (vide = automatique) · annuler",
- "preferences.keyboard_reference": "Référence du clavier",
- "preferences.label_every_note_in_the": "Nommer chaque note dans le piano roll",
- "preferences.language": "Langue",
- "preferences.language.applies_after_restart": "S’applique au redémarrage",
- "preferences.language.applies_the_next_time_nota": "S’applique au prochain démarrage de Nota",
- "preferences.language.restart": "Redémarrer",
- "preferences.last": "Dernier",
- "preferences.last_check_average_peak": "Dernier contrôle : {0:0} % en moyenne, {1:0} % au pic · {2} — {3}.",
- "preferences.latency": "Latence",
- "preferences.launch_the_selected_clip_or": "Lancer le clip ou la scène sélectionnés",
- "preferences.layout": "Disposition",
- "preferences.left": "Gauche",
- "preferences.left_right_or_up_down": "Gauche / droite (ou haut / bas) change la valeur · maintenir ⌘ ou ⇧ pour des pas fins",
- "preferences.library": "Bibliothèque",
- "preferences.light": "Clair",
- "preferences.link_the_groups_tracks_arming": "Lier les pistes du groupe : en armer une les arme toutes, et l’édition d’un clip agit sur les clips au même endroit sur chacune",
- "preferences.listening_on_http_127_0": "Écoute sur http://127.0.0.1:{0}/ (boucle locale)",
- "preferences.load_its_audio_into_the": "Charger son audio dans le Sampler, le Grain, le Drum Rack (prochain pad libre) ou l’Instrument Rack · s’y arrêter pour ouvrir ses appareils",
- "preferences.loop_on_off_in_the": "Boucle activée / désactivée dans la règle · la région reste, grisée tant qu’elle est désactivée",
- "preferences.loop_on_off_loop_the": "Boucle activée / désactivée · mettre en boucle les clips ou la plage de temps sélectionnés",
- "preferences.loop_on_off_loop_the_2": "Boucle activée / désactivée · mettre la sélection en boucle · effacer la région de boucle",
- "preferences.loop_recording_overdub_every_pass": "Enregistrement en boucle : Superposer (chaque passage s’ajoute) / Remplacer (garder le dernier passage)",
- "preferences.lower_raise_velocity": "Baisser / augmenter la vélocité",
- "preferences.make_it_the_active_clip": "En faire le clip actif (plusieurs clips ouverts) · son verrou le garde comme référence en lecture seule",
- "preferences.makes_the_whole_interface_larger": "Agrandit ou réduit toute l’interface. Le zoom de la timeline, du piano roll et de l’éditeur audio s’applique par-dessus.",
- "preferences.map_it_to_a_parameter": "L’assigner à un paramètre ou au sélecteur · effacer ses assignations",
- "preferences.mappable_as_continuous_controls_a": "Assignables comme commandes continues (un bouton rotatif, un fader) ; ils ne jouent aucune note",
- "preferences.mappable_through_midi_learn_a": "Assignable par MIDI Learn : un bouton assigné pilote la commande à la place",
- "preferences.mark_a_new_section_over": "Marquer une nouvelle section sur les mesures parcourues",
- "preferences.measures_audio_thread_load_for": "Mesure la charge du thread audio pendant 5 s : lancer la lecture du projet pour obtenir une valeur réaliste.",
- "preferences.measuring": "Mesure…",
- "preferences.measuring_5_s_left_play": "Mesure… encore 5 s : lancer la lecture du projet pour obtenir une valeur réaliste.",
- "preferences.measuring_s_left_now": "Mesure… encore {0} s · actuellement {1:0} %",
- "preferences.midi_inputs": "Entrées MIDI",
- "preferences.midi_settings_are_unavailable_in": "Les réglages MIDI ne sont pas disponibles dans cette fenêtre.",
- "preferences.models.ai_models_that_run_on": "Modèles d’IA exécutés sur cet ordinateur : l’audio qui leur est confié ne le quitte jamais. Chacun est téléchargé une seule fois depuis le site de ses auteurs, puis vérifié avec la somme de contrôle que Nota lui associe.",
- "preferences.models.comes_with_a_model": "Fourni avec un modèle",
- "preferences.models.is_installed_convert_melody_and": "{0} est installé : « Convertir la mélodie » et « Convertir l’harmonie » l’utilisent désormais.",
- "preferences.models.is_installed_right_click_an": "{0} est installé : clic droit sur un clip audio, puis « Séparer les stems ».",
- "preferences.models.model_ai_runtime_downloaded_once": "Modèle de {0} + environnement d’exécution IA de {1}, téléchargés une seule fois",
- "preferences.models.on_disk": "Sur le disque",
- "preferences.models.onnx_runtime_has_no_build": "ONNX Runtime n’existe pas pour cet ordinateur : les modèles ne peuvent pas s’y exécuter.",
- "preferences.models.open_the_models_project_page": "Ouvrir la page du projet du modèle",
- "preferences.models.remove_ai_model": "Supprimer le modèle d’IA",
- "preferences.models.remove_will_offer_to_download": "Supprimer {0} ? {1} proposera de le télécharger à nouveau.",
- "preferences.models.removing": "Suppression…",
- "preferences.models.the_ai_runtime_goes_too": " Le moteur d’IA est supprimé aussi.",
- "preferences.modular_after_a_click_on": "Modular (après un clic sur le canevas)",
- "preferences.mouse": "Souris",
- "preferences.move_earlier_later_duplicate_or": "Déplacer plus tôt / plus tard · dupliquer ou supprimer avec le contenu",
- "preferences.move_freely_ignoring_the_grid": "Déplacer librement, sans tenir compte de la grille",
- "preferences.move_it_there_out_of": "L’y déplacer (hors du panneau, sur une rangée de piste ou une colonne Session) · l’instrument remplace celui de cette piste et sa propre piste disparaît",
- "preferences.move_it_to_another_slot": "Le déplacer vers un autre emplacement · ⌥ copie",
- "preferences.move_it_within_its_chain": "Le déplacer dans sa chaîne · sur la rangée d’une autre chaîne pour l’y déplacer",
- "preferences.move_notes_by_the_grid": "Déplacer les notes selon la grille",
- "preferences.move_only_the_section_marker": "Déplacer seulement le repère de la section, calé sur les mesures",
- "preferences.move_the_clips_to_a": "Déplacer les clips vers une nouvelle piste du même type que la leur · une par piste d’origine",
- "preferences.move_the_playhead_there_drag": "Y déplacer la tête de lecture · glisser pour balayer · calé sur la grille sur un clip warpé, ⌥ hors de la grille",
- "preferences.move_the_playhead_there_drag_2": "Y déplacer la tête de lecture · glisser pour balayer, calé sur la grille · ⌥ hors de la grille",
- "preferences.move_the_selected_clips_to": "Déplacer les clips sélectionnés vers la piste suivante qui les accepte, sur les mêmes temps",
- "preferences.move_the_selected_devices_of": "Déplacer ensemble les appareils sélectionnés de cette section",
- "preferences.move_the_selection_between_slots": "Déplacer la sélection entre les emplacements et les scènes",
- "preferences.move_through_samples_presets_and": "Parcourir les échantillons, les préréglages et les appareils · avec Auto activé, chacun est joué dès qu’il est sélectionné",
- "preferences.move_through_the_results": "Parcourir les résultats",
- "preferences.narrow_widen_the_grid_in": "Réduire / élargir la grille · en Auto, changer la densité",
- "preferences.new_project_open_a_project": "Nouveau projet / ouvrir un projet",
- "preferences.new_versions_of_nota": "Nouvelles versions de Nota",
- "preferences.no_asio_driver_found_few": "Aucun pilote ASIO trouvé. Peu d’interfaces proposent déjà un pilote ASIO ARM64 : en installer un auprès du fabricant de l’interface, ou un pilote générique comme FlexASIO.",
- "preferences.no_asio_driver_found_install": "Aucun pilote ASIO trouvé. Installer le pilote de l’interface, ou un pilote générique comme FlexASIO.",
- "preferences.no_gamepad_detected_connect_one": "Aucune manette détectée. Une manette connectée apparaît ici.",
- "preferences.no_inputs_on_this_driver": "Aucune entrée sur ce pilote",
- "preferences.no_midi_inputs_detected_connect": "Aucune entrée MIDI détectée. Connecter un contrôleur, puis rouvrir les réglages.",
- "preferences.nota_synth_volt_aurora_operator": "Nota Synth, Volt, Aurora, Operator, Pentad et Physical jouent l’expression par note.",
- "preferences.notes_go_to_the_armed": "Les notes vont à la piste d’instrument armée (prête à enregistrer) : activer l’enregistrement pour les capturer, ou utiliser la piste d’écoute pour simplement jouer.",
- "preferences.nothing_matches": "Aucun résultat.",
- "preferences.nudge_the_selected_clips_by": "Décaler les clips sélectionnés d’une quadruple croche",
- "preferences.nudge_the_selected_clips_by_2": "Décaler les clips sélectionnés du pas de la grille · s’arrête au début du morceau",
- "preferences.octave_1_1": "Octave −1 / +1",
- "preferences.off_a_click_only_selects": "Désactivé : un clic ne fait que sélectionner, et un panneau ouvert suit la sélection. Double-cliquer sur une piste pour ses appareils ou sur un clip pour le modifier.",
- "preferences.open_close_the_command_palette": "Ouvrir / fermer la palette de commandes : depuis n’importe quelle fenêtre, même pendant la saisie",
- "preferences.open_in_the_clip_editor": "Ouvrir dans l’éditeur de clips, en ouvrant le panneau de détail · sur l’un de plusieurs clips MIDI sélectionnés, les ouvrir tous ensemble",
- "preferences.open_its_devices_in_the": "Ouvrir ses appareils dans le panneau de détail · la fenêtre d’un plug-in s’ouvre avec Open editor sur sa carte",
- "preferences.open_plug_in_window_on": "Ouvrir la fenêtre du plug-in à l’insertion",
- "preferences.open_the_detail_panel_when": "Ouvrir le panneau de détail à la sélection d’une piste ou d’un clip",
- "preferences.output_check": "Contrôle de la sortie",
- "preferences.overloaded_raise_the_buffer_size": "surchargé : augmenter la taille du tampon",
- "preferences.paste_the_last_range_as": "Coller la dernière plage sous forme d’audio rendu à travers ses appareils",
- "preferences.patch_a_cable_in_nota": "Brancher un câble dans Nota Consort · ⌥-clic sur un jack pour retirer ses câbles",
- "preferences.per_note_expression_from_mpe": "Expression par note des contrôleurs MPE",
- "preferences.performance": "Performances",
- "preferences.phones_and_tablets_on_this": "Téléphones et tablettes sur ce réseau",
- "preferences.pick_how_far_the_bend": "Choisir l’amplitude du couloir Bend : ±2, 12, 24, 48 ou 96 demi-tons · un bend déjà présent sur les notes peut l’élargir davantage",
- "preferences.play_c4_d4_e4_f4": "Jouer C4 D4 E4 F4",
- "preferences.play_from_that_point": "Lire à partir de ce point",
- "preferences.play_g4_a4_b4_c5": "Jouer G4 A4 B4 C5",
- "preferences.play_it_on_the_tracks": "La jouer sur l’instrument de la piste · ⇧-glisser parcourt les touches · ⌘-clic sélectionne toutes les notes de cette hauteur",
- "preferences.play_notes_computer_keyboard": "Jouer des notes (clavier de l’ordinateur)",
- "preferences.play_notes_or_drive_mapped": "Jouer des notes ou piloter les commandes assignées",
- "preferences.play_pause_the_playhead_stays": "Lecture / pause · la tête de lecture reste en place et la lecture reprend à partir de là",
- "preferences.play_stop_stop_goes_back": "Lecture / Arrêt · l’arrêt revient là où la lecture a commencé",
- "preferences.play_stop_the_selected_sample": "Lire / arrêter l’échantillon, le préréglage ou l’appareil sélectionné",
- "preferences.play_test_tone": "Jouer une tonalité de test",
- "preferences.plenty_of_headroom": "large marge",
- "preferences.plug_in_window": "Fenêtre du plug-in",
- "preferences.plug_ins": "Plug-ins",
- "preferences.plug_ins_sample_packs_and": "Plug-ins, packs d’échantillons et modèles d’IA",
- "preferences.plugin_scan_folders": "Dossiers d’analyse des plug-ins",
- "preferences.plugin_scanning_is_unavailable_in": "L’analyse des plug-ins n’est pas disponible dans cette fenêtre.",
- "preferences.port": "Port",
- "preferences.position_freely_ignoring_the_grid": "Positionner librement, sans tenir compte de la grille pour ce glissement (l’aimant du transport verrouille la même chose)",
- "preferences.projects": "Projets",
- "preferences.put_the_note_back_to": "Remettre la note à la vélocité par défaut (0,8) · toute la sélection si la note est sélectionnée · l’annulation se fait en une seule étape",
- "preferences.quit_nota_asks_about_unsaved": "Quitter Nota · demande d’abord quoi faire des modifications non enregistrées",
- "preferences.racks": "Racks",
- "preferences.rearrange_the_song_it_and": "Réorganiser le morceau · la section et tout ce qu’elle contient vont à la limite marquée, les sections entre elles se resserrent · Esc annule",
- "preferences.refresh": "Actualiser",
- "preferences.refreshing": "Actualisation…",
- "preferences.reload_the_registry": "Recharger le registre",
- "preferences.remote": "Télécommande",
- "preferences.remote.a_trusted_phone_reconnects_from": "Un téléphone de confiance se reconnecte depuis l’icône de son écran d’accueil, sans code. L’oublier l’oblige à scanner de nouveau. Désactiver la télécommande déconnecte tout le monde.",
- "preferences.remote.allow_control_from_a_phone": "Autoriser le contrôle depuis un téléphone",
- "preferences.remote.also_mixer_transport_macros_xy": "Aussi le mixeur, le transport, les macros, le XY et la vue Session.",
- "preferences.remote.days_ago": "il y a {0} jours",
- "preferences.remote.disconnect_it_and_make_it": "Le déconnecter et lui faire scanner un nouveau code pour revenir",
- "preferences.remote.forget": "Oublier",
- "preferences.remote.h_ago": "il y a {0} h",
- "preferences.remote.just_now": "à l’instant",
- "preferences.remote.listening_on": "Écoute sur {0}",
- "preferences.remote.min_ago": "il y a {0} min",
- "preferences.remote.no_phone_has_paired_yet": "Aucun téléphone n’est encore associé. Activer la télécommande et scanner le code dans « Connecter un téléphone ».",
- "preferences.remote.nota_never_shows_files_or": " Nota n’affiche jamais de fichiers ni de chemins sur le téléphone, et ne sert rien depuis le disque.",
- "preferences.remote.nota_remote": "Nota Remote",
- "preferences.remote.now": "maintenant",
- "preferences.remote.on_no_network": "Activée · pas de réseau",
- "preferences.remote.pads_and_keys_mixer_transport": "Pads et touches. Le mixeur, le transport et les assignations sont en lecture seule.",
- "preferences.remote.phones_may": "Les téléphones peuvent",
- "preferences.remote.phones_reach_nota_on_the": "Les téléphones joignent Nota sur le port ci-dessus : si un pare-feu est actif, l’autoriser.",
- "preferences.remote.play_and_control_the_project": "Jouer et piloter le projet",
- "preferences.remote.play_notes_only": "Jouer des notes uniquement",
- "preferences.remote.trusted_devices": "Appareils de confiance",
- "preferences.remote.usb_caps": "USB ",
- "preferences.remote.when_you_turn_this_on": "À l’activation, Windows demande si Nota peut utiliser le réseau. Il faut autoriser les réseaux privés, sinon les téléphones ne peuvent pas joindre Nota.",
- "preferences.remote.when_you_turn_this_on_2": "À l’activation, macOS demande si Nota peut trouver des appareils sur le réseau local. Il faut l’autoriser, sinon les téléphones ne peuvent pas joindre Nota.",
- "preferences.remove": "Supprimer",
- "preferences.remove_the_selected_device_the": "Supprimer l’appareil sélectionné : l’en-tête n’a plus de bouton de fermeture",
- "preferences.removing": "Suppression de {0}…",
- "preferences.rename_it": "La renommer",
- "preferences.rename_it_right_click_reset": "La renommer · clic droit → « Rétablir le nom par défaut » pour sa « Section N » automatique",
- "preferences.rename_the_selected_clip_or": "Renommer le clip ou la scène sélectionnés",
- "preferences.rename_the_track": "Renommer la piste",
- "preferences.reorder_devices_or_right_click": "Réordonner les appareils (ou clic droit sur l’en-tête → Déplacer à gauche / à droite)",
- "preferences.reorder_scenes": "Réordonner les scènes",
- "preferences.replace_the_selected_device_instead": "Remplacer l’appareil sélectionné au lieu d’insérer après lui",
- "preferences.rescan_plugins": "Relancer l’analyse des plug-ins",
- "preferences.reset_the_detail_panel_the": "Rétablir la taille par défaut du panneau de détail, du mixeur ou du navigateur",
- "preferences.reset_the_value_to_its": "Remettre la valeur par défaut",
- "preferences.reset_velocity_from_a_menu": "Réinitialiser la vélocité depuis un menu · comme le double-clic",
- "preferences.resize_every_track_at_once": "Redimensionner toutes les pistes à la fois",
- "preferences.resize_it_snapped_to_bars": "La redimensionner, calée sur les mesures",
- "preferences.resize_that_end_of_the": "Redimensionner cette extrémité de la région de boucle · déplacer toute la région · ⌥ hors de la grille",
- "preferences.resize_that_row_header_or": "Redimensionner cette rangée (en-tête ou couloir) · mêmes crans · double-clic revient à compact",
- "preferences.resize_the_track_header_or": "Redimensionner la piste (en-tête ou couloir) · se cale sur compact / standard / grand · une sélection multiple se redimensionne ensemble",
- "preferences.return_esc_renaming_a_section": "Return · Esc (renommage d’une section)",
- "preferences.return_esc_tab_tab_typing": "Return · Esc · Tab / ⇧Tab (saisie d’une valeur)",
- "preferences.right": "Droite",
- "preferences.right_click_a_device_header": "Clic droit sur l’en-tête d’un appareil",
- "preferences.right_click_a_knob_fader": "Clic droit sur un bouton rotatif, un fader ou un curseur",
- "preferences.right_click_a_macro": "Clic droit sur une macro",
- "preferences.right_click_header_or_grid": "Clic droit sur un en-tête ou la grille",
- "preferences.right_click_ruler": "Clic droit sur la règle",
- "preferences.right_click_section": "Clic droit sur une section",
- "preferences.right_click_the_metronome": "Clic droit sur le métronome",
- "preferences.right_click_track_headers": "Clic droit sur les en-têtes de piste",
- "preferences.right_click_velocity_stem": "Clic droit sur une tige de vélocité",
- "preferences.round_trip": " · aller-retour {0}",
- "preferences.sample_rate": "Fréquence d’échantillonnage",
- "preferences.samples": "Échantillons",
- "preferences.samples.credit": "Crédit : {0}",
- "preferences.samples.download_samples_on_disk": "{0} à télécharger · {1} échantillons · {2} sur le disque · {3}",
- "preferences.samples.free_sample_packs_from_the": "Packs d’échantillons gratuits issus du registre d’échantillons de Nota, utilisables pour toute musique, sorties commerciales comprises. Chaque pack est téléchargé depuis le site de son auteur, vérifié avec la somme de contrôle du registre, puis décompressé dans le dossier d’échantillons.",
- "preferences.samples.is_installed_find_it_under": "{0} est installé : il se trouve sous « Téléchargés » dans l’onglet Fichiers du navigateur, où son tempo et sa tonalité sont en cours d’analyse ; ses instruments apparaissent sous Nota Mosaic → Packs.",
- "preferences.samples.loading_the_sample_registry": "Chargement du registre d’échantillons…",
- "preferences.samples.loops": "Boucles",
- "preferences.samples.mixed": "Mixte",
- "preferences.samples.no_sample_packs_installed_from": "Aucun pack d’échantillons installé depuis le registre pour l’instant.",
- "preferences.samples.one_shots": "One-shots",
- "preferences.samples.open_the_packs_page": "Ouvrir la page du pack",
- "preferences.samples.remove_its_folder_is_deleted": "Supprimer {0} ? Son dossier ({1}) sera supprimé.",
- "preferences.samples.remove_sample_pack": "Supprimer le pack d’échantillons",
- "preferences.samples.samples": { "one": "{0} échantillon", "other": "{0} échantillons" },
- "preferences.samples.samples_n": "{0} · {1} échantillons",
- "preferences.samples.show_the_packs_folder": "Afficher le dossier du pack",
- "preferences.save_a_version_with_a": "Enregistrer une version avec une note",
- "preferences.save_records_a_version_save": "Enregistrer (crée une version) / enregistrer sous",
- "preferences.saved_driver_not_found": "Pilote enregistré introuvable",
- "preferences.scan": "Analyse",
- "preferences.scanner_worker_not_found": "Processus d’analyse introuvable.",
- "preferences.scanning": "Analyse…",
- "preferences.scroll_it_sideways_over_an": "Le faire défiler latéralement · sur la poignée d’une bande d’EQ, la molette règle son Q ; sur une case de valeur, elle change la valeur par pas",
- "preferences.scroll_on_the_track_button": "Défiler sur le bouton de piste",
- "preferences.scrub_the_playhead": "Balayer avec la tête de lecture",
- "preferences.scrub_the_playhead_on_the": "Balayer avec la tête de lecture · sur la règle ou sur la grille vide",
- "preferences.search": "Rechercher",
- "preferences.searching_folders": { "one": "Recherche dans {0} dossier", "other": "Recherche dans {0} dossiers" },
- "preferences.see_which_chains_a_note": "Voir quelles chaînes jouerait une note",
- "preferences.select_a_range_of_devices": "Sélectionner une série d’appareils (effets MIDI, instrument, effets audio) / en ajouter ou en retirer un",
- "preferences.select_a_range_of_tracks": "Sélectionner une série de pistes / ajouter ou retirer une piste",
- "preferences.select_all_clips": "Sélectionner tous les clips",
- "preferences.select_all_notes": "Sélectionner toutes les notes",
- "preferences.select_all_tracks": "Sélectionner toutes les pistes",
- "preferences.select_and_play_it_drop": "La sélectionner et la jouer · y déposer un fichier pour charger un échantillon",
- "preferences.select_it_for_c_x": "Le sélectionner pour ⌘C ⌘X ⌘V ⌘D et Delete",
- "preferences.select_several_returns_they_resize": "Sélectionner plusieurs retours · ils se redimensionnent ensemble",
- "preferences.semitones": "±{0} demi-tons",
- "preferences.session_after_a_click_in": "Session (après un clic dans la grille)",
- "preferences.set_a_chains_key_velocity": "Régler la plage de notes, de vélocité ou de sélection d’une chaîne · les bords ne se croisent jamais",
- "preferences.set_every_track_to_compact": "Mettre toutes les pistes en Compact · Standard · Grand",
- "preferences.set_in_the_drivers_settings": "Défini dans les réglages du pilote",
- "preferences.set_it_cancel_set_it": "La valider · annuler · la valider et saisir la valeur suivante / précédente de la carte",
- "preferences.set_the_tempo_the_clip": "Régler le tempo auquel le clip a été enregistré · ÷2 / ×2 le divisent ou le doublent",
- "preferences.set_velocity_selected_notes_move": "Régler la vélocité · les notes sélectionnées bougent ensemble · ⇧ ajoute une note",
- "preferences.shape_attack_decay_sustain_release": "Façonner l’attaque · le déclin + le maintien · le relâchement (coins du haut et point au survol) · ⌥-clic permet de saisir l’étape · double-clic la réinitialise",
- "preferences.shape_the_new_note_move": "Façonner la nouvelle note : la déplacer · ⇧ pour régler sa longueur · ⌘ glisser vers le haut / le bas pour la vélocité",
- "preferences.shift_octave_down_up": "Octave vers le bas / vers le haut",
- "preferences.shift_the_gamepad_octave": "Changer l’octave de la manette",
- "preferences.shortcuts": "Raccourcis",
- "preferences.shorten_lengthen_the_notes_by": "Raccourcir / allonger les notes selon la grille",
- "preferences.shoulder_buttons": "Boutons d’épaule",
- "preferences.show_a_midi_controller_under": "Afficher un contrôleur MIDI sous les notes · cliquer à nouveau pour choisir un autre CC, la molette de hauteur ou la pression de canal",
- "preferences.show_fewer_parameters_on_every": "Afficher moins de paramètres sur chaque nœud ouvert",
- "preferences.show_playhead_scroll_the_arrangement": "Afficher la tête de lecture · faire défiler l’arrangement jusqu’à elle sans la déplacer · reprend un suivi en pause",
- "preferences.shows_every_note_name_c": "Affiche le nom de chaque note (C, D, E…) sur les touches du piano roll, et non seulement celui des C. Utile pour apprendre les notes.",
- "preferences.smooth": "Lisse",
- "preferences.snap_to_grid_on_off": "Magnétisme sur la grille activé / désactivé",
- "preferences.solid": "Plein",
- "preferences.source": "Source",
- "preferences.split_at_the_playhead_at": "Découper à la tête de lecture · aux bords de la plage",
- "preferences.status": "État",
- "preferences.step": "Pas",
- "preferences.step_on_off_accent_quiet": "Pas activé / désactivé · accent · pas doux — glisser pour peindre, haut / bas (ou défilement) pour sa vélocité",
- "preferences.step_through_the_demo_tracks": "Parcourir les pistes de démonstration à travers lesquelles un préréglage d’effet s’écoute",
- "preferences.sticks_triggers": "Sticks · gâchettes",
- "preferences.stop_again_back_to_the": "Arrêt (de nouveau → retour au début) · dans la grille Session, lance la sélection",
- "preferences.stop_tone": "Arrêter la tonalité",
- "preferences.store.apple_silicon": "Apple silicon",
- "preferences.store.apple_silicon_intel": "Apple silicon + Intel",
- "preferences.store.collection": "Collection",
- "preferences.store.effect": "Effet",
- "preferences.store.effects": "Effets",
- "preferences.store.is_installed_find_it_in": "{0} {1} est installé : il se trouve dans le navigateur.",
- "preferences.store.is_installed_rescan_plugins_to": "{0} est installé. Relancer l’analyse des plug-ins pour l’utiliser.",
- "preferences.store.linux": "Linux",
- "preferences.store.loading_the_plugin_registry": "Chargement du registre de plug-ins…",
- "preferences.store.no_version": "Pas de version {0}",
- "preferences.store.no_version_for": "Pas de version {0} pour {1}",
- "preferences.store.not_available_for_this_computer": "Indisponibles pour cet ordinateur",
- "preferences.store.nothing_installed_from_the_registry": "Rien d’installé depuis le registre pour l’instant.",
- "preferences.store.open_source_vst3_plugins_from": "Plug-ins VST3 open source issus du registre de plug-ins de Nota. Chacun est téléchargé depuis la publication GitHub du projet, vérifié avec la somme de contrôle du registre, puis décompressé : aucun installeur n’est jamais exécuté.",
- "preferences.store.open_the_source_repository": "Ouvrir le dépôt source",
- "preferences.store.remove_plugin": "Supprimer le plug-in",
- "preferences.store.remove_projects_that_use_it": "Supprimer {0} ? Les projets qui l’utilisent se chargeront sans lui tant qu’il ne sera pas réinstallé.",
- "preferences.store.scanning": "Analyse de {0}…",
- "preferences.store.stop_the_download_nothing_is": "Arrêter le téléchargement : rien n’est modifié",
- "preferences.store.windows": "Windows",
- "preferences.swap_it_onto_the_selected": "L’échanger sur la piste d’instrument sélectionnée · les clips et les effets restent · sans piste sélectionnée, en crée une",
- "preferences.switch_a_controller_off_to": "Désactiver un contrôleur pour que Nota cesse de l’écouter. Les nouveaux périphériques sont activés par défaut.",
- "preferences.switch_between_the_adaptive_auto": "Basculer entre la grille adaptative (Auto) et une grille fixe",
- "preferences.switch_it_between_bars_and": "Basculer entre mesures et temps · toutes les règles suivent",
- "preferences.switch_the_well_between_the": "Basculer la zone entre la forme d’onde et un spectre en direct",
- "preferences.system_default": "Par défaut du système",
- "preferences.take_it_as_a_sample": "Le prendre comme échantillon : le déposer sur un pad, un Grain, une voix Rhythm, un emplacement Session ; le clip reste en place",
- "preferences.take_the_devices_out_of": "Sortir les appareils d’un rack à une seule chaîne sélectionné",
- "preferences.test": "Test",
- "preferences.the_clip_editor_fills_the": "L’éditeur de clips remplit la fenêtre / retour à la répartition précédente",
- "preferences.the_devices_native_sample_rate": "La fréquence d’échantillonnage et la taille de tampon natives du périphérique remplacent celles ci-dessus. Si le périphérique est occupé ou n’autorise pas l’accès exclusif, Nota revient au mode partagé.",
- "preferences.the_driver_didnt_start": "le pilote ne s’est pas lancé",
- "preferences.the_driver_doesnt_support": "Le pilote ne prend pas en charge {0}",
- "preferences.the_language_of_menus_panels": "La langue des menus, des panneaux et des messages. Elle change au redémarrage de Nota. Les fichiers de projet et les noms saisis ne sont jamais traduits.",
- "preferences.theme_scale_waveforms_and_ai": "Thème, échelle, formes d’onde et contrôle par IA",
- "preferences.themes_change_colours_only_follow": "Les thèmes ne changent que les couleurs. « Suivre le système » alterne entre le thème du mode sombre et celui du mode clair, selon l’apparence de l’OS.",
- "preferences.this_erases_the_version_history": "Cela efface dès maintenant l’historique des versions du projet ouvert, et celui de tout autre projet au prochain enregistrement. Les anciennes versions ne pourront pas être restaurées.",
- "preferences.toggle_automation_mode": "Activer / désactiver le mode automation",
- "preferences.toggle_the_mixer_view": "Afficher / masquer la vue Mixeur",
- "preferences.track_headers": "En-têtes de piste",
- "preferences.tracks_after_a_click_in": "Pistes (après un clic dans les en-têtes de piste)",
- "preferences.transpose_by_a_semitone": "Transposer d’un demi-ton",
- "preferences.transpose_by_an_octave": "Transposer d’une octave",
- "preferences.triplet_grid_on_off": "Grille en triolets activée / désactivée",
- "preferences.turn_off_and_erase": "Désactiver et effacer",
- "preferences.turn_off_version_history": "Désactiver l’historique des versions",
- "preferences.type_a_value_units_like": "Saisir une valeur (les unités comme k, ms, dB, L / R fonctionnent) · un double-clic sur sa valeur fait de même",
- "preferences.type_first_to_filter_actions": "Saisir d’abord pour filtrer : actions, pistes, appareils, préréglages, nœuds Modular",
- "preferences.type_its_values_a_node": "Saisir ses valeurs : un nœud qui en a plusieurs (fréquence · gain · Q, déclin · maintien) utilise Tab pour passer de l’une à l’autre",
- "preferences.type_the_preview_volume_double": "Saisir le volume d’aperçu · double-clic le remet à 0 dB",
- "preferences.type_value_reset_to_default": "Saisir une valeur… · Rétablir la valeur par défaut",
- "preferences.undo_redo": "Annuler / rétablir",
- "preferences.update_to": "Mettre à jour vers {0}",
- "preferences.updates": "Mises à jour",
- "preferences.updates.automatic_updates": "Mises à jour automatiques",
- "preferences.updates.check_for_updates_automatically": "Rechercher les mises à jour automatiquement",
- "preferences.updates.check_now": "Rechercher maintenant",
- "preferences.updates.checking": "Recherche…",
- "preferences.updates.couldnt_reach_github_to_check": "Impossible de joindre GitHub pour rechercher une nouvelle version. Vérifier la connexion Internet, puis réessayer.",
- "preferences.updates.download_opens_the_release_page": "« Télécharger » ouvre la page de la version.",
- "preferences.updates.it_installs_the_next_time": "Elle s’installe à la prochaine fermeture de Nota, ou en cliquant sur « Redémarrer pour mettre à jour » dans la barre d’état.",
- "preferences.updates.last_checked": "Dernière recherche : {0}.",
- "preferences.updates.not_checked_yet": "Pas encore recherchée.",
- "preferences.updates.nota_is_available_you_have": "Nota {0} est disponible : la version installée est la {1}.",
- "preferences.updates.nota_is_ready_to_install": "Nota {0} est prêt à être installé.",
- "preferences.updates.nota_is_the_latest_version": "Nota {0} est la dernière version.",
- "preferences.updates.on_launch_and_once_a": "Au lancement, puis une fois par jour, Nota demande à GitHub si une version plus récente est disponible et l’indique dans la barre d’état. Rien n’est téléchargé avant un clic sur « Mettre à jour ».",
- "preferences.updates.the_update_didnt_download": "La mise à jour n’a pas pu être téléchargée.",
- "preferences.updates.this_copy_of_nota_cant": "Cet exemplaire de Nota ne peut pas se remplacer lui-même (version de développement, ou lancée directement depuis l’image disque) : une nouvelle version ouvre donc sa page de publication pour être téléchargée.",
- "preferences.updates.this_version": "Cette version",
- "preferences.updates.update_downloads_it_here_it": "« Mettre à jour » la télécharge ici ; elle s’installe au redémarrage ou à la fermeture de Nota.",
- "preferences.updates.you_have_nota": "La version installée de Nota est la {0}.",
- "preferences.use_a_connected_gamepad_for": "Utiliser une manette connectée pour les notes et les commandes assignées",
- "preferences.velocity": "Vélocité − / +",
- "preferences.velocity_10_10_by_1": "Vélocité +10 / −10 · ⌥⇧ par 1",
- "preferences.velocity_wheel": "Molette de vélocité",
- "preferences.version_history": "Historique des versions",
- "preferences.was_removed": "{0} a été supprimé.",
- "preferences.wasapi_exclusive_lowest_latency_mutes": "WASAPI exclusif : latence minimale, coupe le son des autres applications",
- "preferences.waveform": "Forme d’onde",
- "preferences.wheel_over_a_note": "⇧ + molette sur une note",
- "preferences.wheel_over_a_note_in": "⇧ + molette sur une note du piano roll change sa vélocité, ou celle de toute la sélection si cette note est sélectionnée : un pas MIDI par cran à 1×. Partout ailleurs, ⇧ + molette fait défiler, et « Désactivé » la laisse défiler partout.",
- "preferences.wheel_over_the_device_chain": "Molette sur la chaîne d’appareils",
- "preferences.wheel_up_lowers_the_velocity": "Molette vers le haut : baisse la vélocité",
- "preferences.where_nota_looks_for_vst3": "Où Nota cherche les VST3",
- "preferences.which_side_of_the_arrangement": "Côté de l’arrangement où se trouve la liste des pistes. « Droite » fait commencer la timeline au bord gauche, contre le navigateur. Aussi dans le menu Affichage.",
- "preferences.while_dragging_a_warp_marker": "Pendant le glissement d’un marqueur de warp ou d’un tempo de segment : le remettre en place",
- "preferences.white_keys_from_c4": "Touches blanches, à partir de C4",
- "preferences.widen_or_narrow_the_track": "Élargir ou rétrécir les en-têtes de piste · double-clic réinitialise",
- "preferences.window": "Fenêtre",
- "preferences.working": "En cours…",
- "preferences.zoom_by_resizing_the_viewport": "Zoomer en redimensionnant la fenêtre de visualisation",
- "preferences.zoom_rows_down_taller_up": "Zoom des rangées · vers le bas plus hautes, vers le haut plus basses",
- "preferences.zoom_rows_trackpad": "Zoom des rangées (trackpad)",
- "preferences.zoom_rows_vertical_zoom": "Zoom des rangées (zoom vertical)",
- "preview_player.auto": "Auto ({0})",
- "preview_player.auto_audition_play_a_preset": "Pré-écoute auto : jouer un préréglage ou un appareil à la sélection",
- "preview_player.auto_audition_play_a_sample": "Pré-écoute auto : jouer un échantillon à la sélection",
- "preview_player.auto_audition_play_on_select": "Pré-écoute auto : jouer à la sélection",
- "preview_player.auto_for_this_effect": " (auto pour cet effet)",
- "preview_player.bit_float": "{0} bits flottants",
- "preview_player.heard_through_click_to_pick": "Entendu via {0} — cliquer pour choisir une piste, défiler pour les parcourir",
- "preview_player.no_sound_to_preview": "aucun son à pré-écouter",
- "preview_player.picked_for_this_effect_drums": "Choisi pour cet effet : batterie pour la dynamique, claviers pour le temps et la modulation, mix complet pour le timbre",
- "preview_player.play_to_see_the_spectrum": "lancer la lecture pour voir le spectre",
- "preview_player.preview_failed": "Échec de la pré-écoute : {0}",
- "preview_player.preview_volume": "Volume de pré-écoute",
- "preview_player.preview_volume_click_to_type": "Volume de pré-écoute {0} · ⌥-clic pour saisir · double-clic pour 0{1}dB",
- "preview_player.previewing": "Pré-écoute de {0}",
- "preview_player.sample": "Échantillon — {0}",
- "preview_player.sample_pick_one_in_files": "Échantillon — en choisir un dans Fichiers",
- "preview_player.spec": "Spec",
- "preview_player.wave": "Onde",
- "progress.cancelling": "Annulation…",
- "record_input_pick.audio_input_1_mono": "Entrée audio 1 (mono)",
- "record_input_pick.audio_input_2_mono": "Entrée audio 2 (mono)",
- "record_input_pick.audio_inputs_1_2_stereo": "Entrées audio 1/2 (stéréo)",
- "record_input_pick.ext": "Ext",
- "record_input_pick.ext_1": "Ext 1",
- "record_input_pick.ext_2": "Ext 2",
- "registry.client.couldnt_download": "Impossible de télécharger {0} : {1}",
- "registry.client.couldnt_reach_the_check_your": "Impossible de joindre le {0}. Vérifier la connexion Internet.",
- "registry.client.the_download_of_doesnt_match": "Le téléchargement de {0} ne correspond pas à la somme de contrôle du registre — il n’est pas installé.",
- "registry.client.the_download_of_is_larger": "Le téléchargement de {0} est plus volumineux que ce qu’indique le registre — il n’est pas installé.",
- "registry.client.unsafe_path_in_the_registry": "Chemin dangereux dans l’entrée du registre : {0}",
- "remote.connect.address": "Adresse",
- "remote.connect.allow": "Autoriser",
- "remote.connect.code": "Code",
- "remote.connect.connect_phone": "Connecter un téléphone",
- "remote.connect.connected": "connecté",
- "remote.connect.connecting": "connexion",
- "remote.connect.disconnect_this_phone_it_stays": "Déconnecter ce téléphone (il reste de confiance — l’oublier dans Réglages → Télécommande)",
- "remote.connect.ms": "{0} ms · {1}",
- "remote.connect.ms_weak_network": "{0} ms · réseau faible",
- "remote.connect.point_the_phone_camera_at": "Pointer la caméra du téléphone vers le code. Par câble, la liaison est instantanée et sans Wi-Fi ; le code change toutes les 2 minutes et après chaque connexion.",
- "remote.connect.point_the_phone_camera_at_2": "Pointer la caméra du téléphone vers le code. Même Wi-Fi uniquement — ou brancher un câble USB (partage de connexion USB sur le téléphone ; Partage Internet sur le Mac) pour une liaison instantanée. Le code change toutes les 2 minutes et après chaque connexion.",
- "remote.connect.remote_is_off_turn_it": "La télécommande est désactivée. L’activer pour afficher un code QR qu’un téléphone sur le même Wi-Fi peut scanner.",
- "remote.connect.remote_is_off_turn_it_2": "La télécommande est désactivée. L’activer pour afficher un code QR. La première fois, Windows demande si Nota peut utiliser le réseau ; autoriser les réseaux privés.",
- "remote.connect.remote_is_off_turn_it_3": "La télécommande est désactivée. L’activer pour afficher un code QR. La première fois, macOS demande d’autoriser Nota sur le réseau local ; cliquer sur Autoriser.",
- "remote.connect.this_computer_isnt_on_a": "Cet ordinateur n’est pas sur un réseau. Rejoindre le même Wi-Fi que le téléphone, partager le point d’accès du téléphone avec lui, ou brancher un câble USB (partage de connexion USB sur le téléphone ; Partage Internet sur le Mac).",
- "remote.connect.usb_caps": "USB",
- "remote.connect.usb_ms": "USB · {0} ms · {1}",
- "remote.port_is_in_use_by": "Le port {0} est utilisé par une autre application. Choisir un autre port.",
- "sample_store.couldnt_remove_the_packs_files": "Impossible de supprimer les fichiers du pack — fermer ce qui les utilise puis réessayer.",
- "sample_store.installing": "Installation de {0}…",
- "sample_store.invalid_pack_id": "Identifiant de pack « {0} » invalide.",
- "sample_store.needs_of_free_space_in": "{0} demande {1} d’espace libre dans le dossier Échantillons, qui en a {2}.",
- "sample_store.sample_index.the_sample_registry_needs_a": "Le registre d’échantillons demande une version plus récente de Nota.",
- "sample_store.the_download_of_contains_no": "Le téléchargement de {0} ne contient aucun échantillon utilisable par Nota.",
- "sample_store.the_download_of_doesnt_contain": "Le téléchargement de {0} ne contient pas {1}.",
- "sample_store.the_sample_registry_index_is": "L’index du registre d’échantillons est endommagé.",
- "sample_store.unpacking_needs_of_free_space": "La décompression de {0} demande {1} d’espace libre sur le disque système, qui en a {2}.",
- "save_changes.dont_save": "Ne pas enregistrer",
- "save_changes.save": "Enregistrer",
- "save_changes.saving": "Enregistrement…",
- "session.bars": { "one": "{0} mesure", "other": "{0} mesures" },
- "session.bars_n": "{0}.{1} mesures",
- "session.captured": "Capturé",
- "session.captured_the_playing_clips_into": "Clips en lecture capturés dans une nouvelle scène",
- "session.copied_clip": "Clip copié",
- "session.copied_clip_to_the_arrangement": "Clip copié dans l’arrangement à la tête de lecture",
- "session.copied_clips_to_the_arrangement": "{0} clips copiés dans l’arrangement à la tête de lecture",
- "session.cut_clip_paste_to_move": "Clip coupé — coller pour le déplacer",
- "session.deleted_clip": "Clip supprimé",
- "session.deleted_scene": "Scène supprimée",
- "session.duplicated_clip": "Clip dupliqué",
- "session.duplicated_scene": "Scène dupliquée",
- "session.grid.add_a_scene_at_the": "Ajouter une scène à la fin",
- "session.grid.add_audio_track": "Ajouter une piste audio",
- "session.grid.add_instrument_track": "Ajouter une piste d’instrument",
- "session.grid.add_return_track": "Ajouter une piste de retour",
- "session.grid.add_stop_button": "Ajouter un bouton d’arrêt",
- "session.grid.add_track": "Ajouter une piste",
- "session.grid.arr": "Arr",
- "session.grid.back_to_arrangement_for_this": "Retour à l’arrangement pour cette piste",
- "session.grid.capture_playing_clips_below": "Capturer les clips en lecture dessous",
- "session.grid.copy_scene_to_arrangement": "Copier la scène vers l’arrangement",
- "session.grid.copy_to_arrangement": "Copier vers l’arrangement",
- "session.grid.delete_group_and_its_tracks": "Supprimer le groupe et ses pistes",
- "session.grid.delete_scene": "Supprimer la scène",
- "session.grid.drop_a_midi_clip_on": "Déposer un clip MIDI sur une piste MIDI, de l’audio sur de l’audio.",
- "session.grid.fold_the_group_into_one": "Replier le groupe en une colonne",
- "session.grid.insert_scene_below": "Insérer une scène dessous",
- "session.grid.launch_scene": "Lancer la scène",
- "session.grid.moved_scene": "Scène déplacée",
- "session.grid.rec_in": "Rec dans…",
- "session.grid.remove_stop_button": "Retirer le bouton d’arrêt",
- "session.grid.scene": "+ Scène",
- "session.grid.scene_2": "{0} · scène {1}",
- "session.grid.scene_n": "Scène · {0}",
- "session.grid.scenes": "Scènes",
- "session.grid.show_the_groups_tracks": "Afficher les pistes du groupe",
- "session.grid.stop_all_clips": "Arrêter tous les clips",
- "session.grid.stop_every_track_in_this": "Arrêter toutes les pistes de ce groupe",
- "session.grid.stop_scene": "Arrêter la scène",
- "session.grid.stop_this_track": "Arrêter cette piste",
- "session.group": "Groupe · {0}{1}",
- "session.insert_midi_clip": "Insérer un clip MIDI",
- "session.inserted_scene": "Scène insérée",
- "session.inspector.16_bars": "16 mesures",
- "session.inspector.1_beat": "1 temps",
- "session.inspector.2_bars": "2 mesures",
- "session.inspector.2_beats": "2 temps",
- "session.inspector.4_bars": "4 mesures",
- "session.inspector.8_bars": "8 mesures",
- "session.inspector.after": "Après",
- "session.inspector.again": "Encore",
- "session.inspector.any": "Quelconque",
- "session.inspector.chance_of_a_in_percent": "Probabilité de A en pourcentage · B reçoit le reste · glisser",
- "session.inspector.click_again_to_use_the": "Cliquer de nouveau pour utiliser la couleur par défaut",
- "session.inspector.click_selects_the_triangle_launches": "Clic sélectionne · le triangle lance · Entrée lance la sélection\n←↑↓→ déplacer · ⌘C ⌘V ⌘D · ⌫ supprimer · ⌘I insérer une scène\n⌘⇧C copier vers l’arrangement · ⌘V colle les clips copiés là",
- "session.inspector.clips": { "one": "{0} clip", "other": "{0} clips" },
- "session.inspector.color": "Couleur",
- "session.inspector.empty_slot": "Emplacement vide",
- "session.inspector.every_track_ends_up_here": "Toutes les pistes aboutissent ici. Ses appareils sont dans le panneau Appareils.",
- "session.inspector.first": "Premier",
- "session.inspector.follow_action": "Action de suivi",
- "session.inspector.global": "Global",
- "session.inspector.group_slot_tracks_caps": "EMPLACEMENT DE GROUPE · {0} PISTES",
- "session.inspector.insert_below": "Insérer dessous",
- "session.inspector.jump": "Saut",
- "session.inspector.jump_to": "Sauter à",
- "session.inspector.last": "Dernier",
- "session.inspector.launch_group_slot": "Lancer l’emplacement du groupe",
- "session.inspector.launch_without_a_tempo_change": "Lancer sans changement de tempo",
- "session.inspector.launches_every_tracks_slot_in": "Lance l’emplacement de chaque piste dans cette scène. Le bouton d’arrêt les arrête tous.",
- "session.inspector.launching_this_scene_keeps_playing": "Le lancement de cette scène laisse {0} en lecture.",
- "session.inspector.launching_this_scene_stops": "Le lancement de cette scène arrête {0}.",
- "session.inspector.legato": "Legato",
- "session.inspector.loop_end": "Fin de boucle",
- "session.inspector.next": "Suivant",
- "session.inspector.next_after": "Suivant après {0}",
- "session.inspector.next_n": "Suivant · {0}",
- "session.inspector.off_globally": "Désactivé globalement",
- "session.inspector.off_one_shot": "Désactivé · one-shot",
- "session.inspector.one_pass": "Un passage",
- "session.inspector.previous": "Précédent",
- "session.inspector.removed": "Retiré",
- "session.inspector.rename": "Renommer",
- "session.inspector.repeat": "Répéter",
- "session.inspector.scene_caps": "SCÈNE {0:00} · {1}",
- "session.inspector.select_next_scene_on_launch": "Sélectionner la scène suivante au lancement",
- "session.inspector.signature": "Signature",
- "session.inspector.stop_button": "Bouton d’arrêt",
- "session.inspector.stop_group": "Arrêter le groupe",
- "session.inspector.stop_recording": "Arrêter l’enregistrement",
- "session.inspector.tempo": "Tempo",
- "session.inspector.tempo_set_when_the_scene": "Tempo réglé au lancement de la scène · glisser pour le changer",
- "session.inspector.to_arrangement": "Vers l’arrangement",
- "session.inspector.toggle": "Bascule",
- "session.inspector.tracks_reach_it_through_their": "Les pistes l’atteignent par leurs envois. Il n’a pas d’emplacements de clips ; ses appareils sont dans le panneau Appareils.",
- "session.inspector.trigger": "Déclencheur",
- "session.inspector.trigger_starts_gate_plays_while": "Déclencheur démarre · Gate joue tant que tenu · Bascule démarre et arrête · Répéter redéclenche tant que tenu",
- "session.inspector.velocity": "Vélocité %",
- "session.inspector.velocity_amount_how_far_the": "Quantité de vélocité : dans quelle mesure la vélocité de lancement met le clip à l’échelle · glisser",
- "session.launch": "Lancer",
- "session.mixer.all_ins": "Toutes les entrées",
- "session.mixer.in_hear_the_input_live": "Entrée : entendre l’entrée en direct à travers cette piste · Auto : seulement pendant l’enregistrement",
- "session.mixer.midi_input_every_input_or": "Entrée MIDI : toutes les entrées, ou une autre piste d’instrument",
- "session.mixer.monitor": "Écoute",
- "session.mixer.output_group_a_track_to": "Sortie — grouper une piste pour la router à travers le groupe",
- "session.mixer.send": "Envoi",
- "session.mixer.send_n": "Envoi {0} · {1}",
- "session.moved_clip": "Clip déplacé",
- "session.paste_a_midi_clip_onto": "Coller un clip MIDI sur une piste MIDI, de l’audio sur de l’audio.",
- "session.pasted_clip": "Clip collé",
- "session.pasted_clip_from_the_arrangement": "Clip de l’arrangement collé",
- "session.pasted_clips_from_the_arrangement": "{0} clips de l’arrangement collés",
- "session.record_here": "Enregistrer ici",
- "session.recording": "Enregistrement",
- "session.scene": "Scène {0}",
- "session.stop_every_session_clip": "Arrêter tous les clips de la session",
- "session.the_slot_below_is_taken": "L’emplacement du dessous est occupé.",
- "session.toolbar.1_bar": "1 mesure",
- "session.toolbar.2_bars": "2 mesures",
- "session.toolbar.4_bars": "4 mesures",
- "session.toolbar.8_bars": "8 mesures",
- "session.toolbar.arm_a_track_with_an": "Armer une piste avec un emplacement vide dans cette scène pour enregistrer.",
- "session.toolbar.back_to_arrangement": "Retour à l’arrangement",
- "session.toolbar.capture_scene": "Capturer la scène",
- "session.toolbar.copy_the_clips_playing_now": "Copier les clips en lecture dans une nouvelle scène",
- "session.toolbar.fixed": "Fixe",
- "session.toolbar.fixed_record_length_in_bars": "Durée d’enregistrement fixe en mesures — la prise s’arrête d’elle-même",
- "session.toolbar.follow": "Suivi",
- "session.toolbar.follow_actions_on_or_off": "Actions de suivi activées ou désactivées pour chaque clip et chaque scène",
- "session.toolbar.hide": "Masquer",
- "session.toolbar.inspector": "Inspecteur",
- "session.toolbar.inspector_show_or_hide_it": "Inspecteur — l’afficher ou le masquer",
- "session.toolbar.launch_quantize_when_clips_and": "Quantification du lancement : quand les clips et les scènes démarrent",
- "session.toolbar.more_session_controls": "Plus de commandes de session",
- "session.toolbar.quant": "Quant",
- "session.toolbar.record_into_the_armed_track": "Enregistrer dans la piste armée à la scène sélectionnée · cliquer de nouveau pour garder la prise",
- "session.toolbar.session_rec": "Rec session",
- "session.toolbar.stop_all": "Tout arrêter",
- "session.toolbar.stop_session_clips_and_hand": "Arrêter les clips de la session et rendre chaque piste à l’arrangement",
- "session.toolbar.turn_follow_off": "Désactiver le suivi",
- "session.toolbar.turn_follow_on": "Activer le suivi",
- "snap_chip.1_2_narrow_widen_3": "⌘1 ⌘2 réduire / élargir · ⌘3 triolets · ⌘4 magnétisme · ⌘5 auto",
- "snap_chip.auto": "Auto · {0}",
- "snap_chip.auto_grid": "Grille auto",
- "snap_chip.finer_than_the_visible_grid": "{0} — plus fin que la grille visible · zoomer pour la voir",
- "snap_chip.hold_to_drag_freely": "{0}\n{1} · maintenir ⌥ pour déplacer librement",
- "snap_chip.snap_grid_auto_follows_the": "Grille magnétique · Auto suit le zoom ({0})",
- "snap_chip.snap_grid_fixed": "Grille magnétique · fixe {0}",
- "snap_chip.snap_off_items_move_freely": "Magnétisme désactivé — les éléments se déplacent librement (⌘4)",
- "snap_chip.snap_to_grid": "Magnétisme sur la grille",
- "snap_chip.triplets": "Triolets",
- "stereo_map.balance": "Balance",
- "stereo_map.below_60_dbfs_so_the": "Sous −60 dBFS : le nuage est masqué.",
- "stereo_map.correlation": "Corrélation",
- "stereo_map.drag_pan_volume_shift_locks": "Glisser : pan + volume · Shift verrouille l’axe · double-clic centre le pan · ⌥-clic pour saisir",
- "stereo_map.image_is_off_the_pan": "L’image est décalée du pan",
- "stereo_map.level": "Niveau",
- "stereo_map.muted": "En sourdine",
- "stereo_map.no_cloud_while_the_track": "Pas de nuage tant que la piste est en sourdine.",
- "stereo_map.silent": "Silence",
- "stereo_map.the_pan_is_at_but": "Le pan est à {0}, mais le signal mesure {1}. La source elle-même est déséquilibrée.",
- "stereo_map.width": "Largeur",
- "tag_editor.add_tag": "Ajouter une étiquette",
- "tag_editor.edit_tags": "Modifier les étiquettes",
- "tag_editor.new_tag": "Nouvelle étiquette",
- "tag_editor.no_tags_yet_add_one": "Aucune étiquette pour l’instant — en ajouter une ci-dessous.",
- "tag_editor.tags_title_colour": "Étiquettes — titre et couleur",
- "text_prompt.ok_caps": "OK",
- "track_arming.arm_for_recording_click_to": "Armer pour l’enregistrement · ⌘-clic pour armer plusieurs pistes · ⌥-clic pour armer une seule piste d’un groupe lié",
- "track_inspector.arm": "Armer",
- "track_inspector.audio_track": "Piste audio",
- "track_inspector.color": "Couleur",
- "track_inspector.every_track_ends_up_here": "Toutes les pistes aboutissent ici. Ses appareils sont dans le panneau Appareils.",
- "track_inspector.hear_the_input_live_through": "Entendre l’entrée en direct à travers cette piste",
- "track_inspector.height": "Hauteur",
- "track_inspector.large": "Grand",
- "track_inspector.master_cant_be_monitored_it": "Le master ne peut pas être écouté (il y aurait un larsen)",
- "track_inspector.midi_from": "MIDI depuis",
- "track_inspector.midi_track": "Piste MIDI",
- "track_inspector.monitor_input": "Écoute de l’entrée",
- "track_inspector.mute_the_track": "Mettre la piste en sourdine",
- "track_inspector.name": "Nom",
- "track_inspector.no_track_selected": "Aucune piste sélectionnée",
- "track_inspector.play_another_instrument_tracks_midi": "Jouer le MIDI d’une autre piste d’instrument avec l’instrument de cette piste",
- "track_inspector.solo_the_track": "Mettre la piste en solo",
- "track_inspector.standard": "Standard",
- "track_inspector.the_colour_the_tracks_position": "La couleur que lui donne la position de la piste",
- "track_names.inst": "Inst {0}",
- "transport.bars": "mesures",
- "transport.cant_record_arm_a_track": "Enregistrement impossible : armer d’abord une piste (cliquer sur Armer dans l’en-tête d’une piste).",
- "transport.cant_record_no_audio_input": "Enregistrement impossible : aucune entrée audio — autoriser l’accès au microphone (nécessite une app empaquetée).",
- "transport.count_in": "décompte",
- "transport.paused_play_carries_on_from": "En pause · la lecture reprend à partir d’ici",
- "transport.recording_didnt_start": "L’enregistrement n’a pas démarré.",
- "transport.time": "durée",
- "update.app_updater.couldnt_download_the_update": "Impossible de télécharger la mise à jour : {0}",
- "update.app_updater.couldnt_prepare_the_update": "Impossible de préparer la mise à jour ({0} : {1}).",
- "update.app_updater.couldnt_start": "Impossible de lancer {0}.",
- "update.app_updater.nota_has_no_download_for": "Nota {0} n’a pas de téléchargement pour cet ordinateur.",
- "update.app_updater.preparing_the_update": "Préparation de la mise à jour…",
- "update.app_updater.the_downloaded_nota_app_isnt": "Le Nota.app téléchargé n’est pas la version attendue — il n’est pas installé.",
- "update.app_updater.the_update_disk_image_doesnt": "L’image disque de la mise à jour ne contient pas Nota.app.",
- "update.app_updater.the_update_download_is_damaged": "Le téléchargement de la mise à jour est endommagé (somme de contrôle différente) — il n’est pas installé.",
- "update.app_updater.the_update_download_is_larger": "Le téléchargement de la mise à jour est plus volumineux que prévu — il n’est pas installé.",
- "update.app_updater.this_copy_of_nota_cant": "Cet exemplaire de Nota ne peut pas se mettre à jour lui-même — télécharger la nouvelle version depuis la page de publication.",
- "update.app_updater.timed_out": "{0} : délai dépassé.",
- "version_summary.added": "{0} ajouté",
- "version_summary.devices_on": "Appareils sur {0}",
- "version_summary.edited": "{0} modifié",
- "version_summary.first_save": "Premier enregistrement",
- "version_summary.first_save_tracks": { "one": "Premier enregistrement · {0} piste", "other": "Premier enregistrement · {0} pistes" },
- "version_summary.mix_of": "Mixage de {0}",
- "version_summary.mix_of_tracks": { "one": "Mixage de {0} piste", "other": "Mixage de {0} pistes" },
- "version_summary.new_audio": "Nouvel audio",
- "version_summary.new_audio_files": "{0} nouveaux fichiers audio",
- "version_summary.removed": "{0} supprimé",
- "version_summary.tempo": "Tempo {0} → {1}",
- "welcome.a_new_version_of_nota": "Une nouvelle version de Nota est disponible",
- "welcome.dismiss": "Ignorer",
- "welcome.later": "Plus tard",
- "welcome.no_recent_projects": "Aucun projet récent",
- "welcome.nota_is_out_you_have": "Nota {0} est disponible — la version installée est la {1}.",
- "welcome.nota_is_ready_to_install": "Nota {0} est prêt à être installé",
- "welcome.open_project": "Ouvrir un projet…",
- "welcome.opening": "Ouverture…",
- "welcome.recent_projects": "Projets récents",
- "welcome.recover": "Récupérer",
- "welcome.release_notes": "Notes de version",
- "welcome.restart_nota_to_finish_updating": "Redémarrer Nota pour terminer la mise à jour — ou elle s’installe à la prochaine fermeture.",
- "welcome.restart_now": "Redémarrer maintenant",
- "welcome.show_on_startup": "Afficher au démarrage",
- "welcome.the_update_didnt_download": "La mise à jour n’a pas pu être téléchargée",
- "welcome.unsaved_work_available": "Travail non enregistré disponible",
- "welcome.version_engine_desktop_daw": "Version {0} · Moteur {1} · DAW de bureau",
- "welcome.welcome_to_nota": "Bienvenue dans Nota",
- "welcome.whats_new": "Nouveautés",
- "whats_new.all_changes": "Toutes les modifications",
- "whats_new.got_it": "Compris",
- "whats_new.no_release_notes_available": "Aucune note de version disponible.",
- "whats_new.nota": "Nota {0}",
- "whats_new.whats_new_in_nota": "Nouveautés de Nota"
- }
-}
diff --git a/src/managed/Nota.App/MainWindow.Recovery.cs b/src/managed/Nota.App/MainWindow.Recovery.cs
index 103b4d0c..ee280c7b 100644
--- a/src/managed/Nota.App/MainWindow.Recovery.cs
+++ b/src/managed/Nota.App/MainWindow.Recovery.cs
@@ -100,6 +100,9 @@ public partial class MainWindow
// Look for a newer release now and once a day (unless Settings → Updates says not to);
// the start screen and the status bar show what it finds.
AppUpdates.Shared.Start();
+ // The stored interface language is not installed (Nota used to ship French): fetch it in
+ // the background, under the same rule, and offer the restart when it is in (spec 077).
+ LanguageDownloads.Shared.StartupCheck(App.Services.GetRequiredService<ILogSink>());
// What's New shows once per new app version, ahead of the launcher.
await ShowWhatsNewIfNeeded();
diff --git a/src/managed/Nota.App/MainWindow.Updates.cs b/src/managed/Nota.App/MainWindow.Updates.cs
index a3fba25a..91c93e26 100644
--- a/src/managed/Nota.App/MainWindow.Updates.cs
+++ b/src/managed/Nota.App/MainWindow.Updates.cs
@@ -25,6 +25,8 @@ public partial class MainWindow
private ProgressBar _upBar = null!;
private Button _upClose = null!;
private Border _upOpen = null!;
+ private StackPanel _upPanel = null!, _langPanel = null!;
+ private TextBlock _langText = null!;
private void BuildUpdateIndicator()
{
@@ -68,18 +70,22 @@ public partial class MainWindow
else updates.Dismiss();
};
- UpdateHost.Children.Add(new StackPanel
+ _upPanel = new StackPanel
{
Orientation = Orientation.Horizontal, Spacing = 8, Margin = new Thickness(0, 0, 14, 0),
Children = { open, _upBar, _upDetail, _upClose },
- });
+ };
+ BuildLanguageNotice();
+ UpdateHost.Children.Add(new StackPanel { Orientation = Orientation.Horizontal, Children = { _langPanel, _upPanel } });
updates.Changed += UpdateUpdateIndicator;
updates.ProgressChanged += UpdateUpdateIndicator;
+ LanguageDownloads.Shared.Changed += UpdateUpdateIndicator;
Closed += (_, _) =>
{
updates.Changed -= UpdateUpdateIndicator;
updates.ProgressChanged -= UpdateUpdateIndicator;
+ LanguageDownloads.Shared.Changed -= UpdateUpdateIndicator;
};
UpdateUpdateIndicator();
}
@@ -87,8 +93,14 @@ public partial class MainWindow
private void UpdateUpdateIndicator()
{
var u = AppUpdates.Shared;
- UpdateHost.IsVisible = u.Release is { } && u.State != AppUpdates.Stage.None && !u.Dismissed;
- if (!UpdateHost.IsVisible) return;
+ var lang = LanguageDownloads.Shared;
+ _langPanel.IsVisible = lang.Ready is { } && !lang.Dismissed;
+ if (lang.Ready is { } ready)
+ _langText.Text = AppRestart.CanRelaunch ? Loc.F("main.updates.language_is_ready_restart", ready.Name)
+ : Loc.F("main.updates.language_is_ready_next_start", ready.Name);
+ _upPanel.IsVisible = u.Release is { } && u.State != AppUpdates.Stage.None && !u.Dismissed;
+ UpdateHost.IsVisible = _upPanel.IsVisible || _langPanel.IsVisible;
+ if (!_upPanel.IsVisible) return;
var version = u.Release!.Version;
bool busy = u.State == AppUpdates.Stage.Downloading;
var p = u.Progress;
@@ -116,6 +128,42 @@ public partial class MainWindow
: u.State == AppUpdates.Stage.Ready ? Loc.T("main.updates.hide_it_still_installs_when") : Loc.T("main.not_now"));
}
+ // A language Nota downloaded on its own at start (the stored one was not installed, spec 077
+ // story 5) is ready: the same quiet notice, with a restart on click.
+ private void BuildLanguageNotice()
+ {
+ var dot = new Ellipse { Width = 6, Height = 6, VerticalAlignment = VerticalAlignment.Center };
+ dot.BindResource(Shape.FillProperty, "Brush.Accent");
+ _langText = new TextBlock { Classes = { "Caption" }, VerticalAlignment = VerticalAlignment.Center };
+ var open = new Border
+ {
+ Background = Brushes.Transparent, Cursor = new Cursor(StandardCursorType.Hand),
+ Child = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 6, Children = { dot, _langText } },
+ };
+ open.PointerEntered += (_, _) => _langText.TextDecorations = AppRestart.CanRelaunch ? TextDecorations.Underline : null;
+ open.PointerExited += (_, _) => _langText.TextDecorations = null;
+ open.PointerPressed += (_, e) =>
+ {
+ if (!e.GetCurrentPoint(open).Properties.IsLeftButtonPressed || !AppRestart.CanRelaunch) return;
+ e.Handled = true;
+ AppRestart.Request(); // the usual close: it asks about unsaved changes
+ Close();
+ };
+ var close = new Button
+ {
+ Classes = { "ghost" }, Width = 18, Height = 18, Padding = new Thickness(0), MinHeight = 0, MinWidth = 0,
+ VerticalAlignment = VerticalAlignment.Center, Content = new Glyph(GlyphKind.Close, 8),
+ };
+ close.BindResource(Button.ForegroundProperty, "Brush.TextTertiary");
+ ToolTip.SetTip(close, Loc.T("main.not_now"));
+ close.Click += (_, _) => LanguageDownloads.Shared.Dismiss();
+ _langPanel = new StackPanel
+ {
+ Orientation = Orientation.Horizontal, Spacing = 8, Margin = new Thickness(0, 0, 14, 0), IsVisible = false,
+ Children = { open, close },
+ };
+ }
+
// Available / failed: what to do about it.
private ContextMenu UpdateMenu()
{
diff --git a/src/managed/Nota.App/Nota.App.csproj b/src/managed/Nota.App/Nota.App.csproj
index 3c6ca7a6..7b8b55f7 100644
--- a/src/managed/Nota.App/Nota.App.csproj
+++ b/src/managed/Nota.App/Nota.App.csproj
@@ -52,14 +52,6 @@
<EmbeddedResource Include="Theme\Themes\*.json" LogicalName="Nota.Themes.%(Filename)%(Extension)" />
</ItemGroup>
- <!-- The interface translations (spec 068, keyed since spec 077): one JSON file per language,
- key → translation. English is not here: it is the reference, embedded in Nota.Application
- beside Loc. Read by NotaLanguages at startup; the picker lists whatever is embedded here.
- The smoke test reads the same files from disk. -->
- <ItemGroup>
- <EmbeddedResource Include="Languages\*.json" LogicalName="Nota.Languages.%(Filename)%(Extension)" />
- </ItemGroup>
-
<ItemGroup>
<ProjectReference Include="..\Nota.Presentation\Nota.Presentation.csproj" />
<ProjectReference Include="..\Nota.Infrastructure\Nota.Infrastructure.csproj" />
diff --git a/src/managed/Nota.App/PreferencesWindow.Language.cs b/src/managed/Nota.App/PreferencesWindow.Language.cs
index 2efe3777..698493a8 100644
--- a/src/managed/Nota.App/PreferencesWindow.Language.cs
+++ b/src/managed/Nota.App/PreferencesWindow.Language.cs
@@ -1,51 +1,59 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
//
-// Settings → Appearance → Language (spec 068). The interface language is fixed for a run, so
-// choosing one saves it and says so on the row itself, with no dialog: a note beside the list
-// and, where Nota can start itself again, a small Restart button that closes the main window by
-// its usual path (the unsaved-changes prompt included) so Nota comes back in the new language.
-// Leaving it alone is fine — the choice applies at the next start. Each choice is written in its
-// own language ("English", "Français"), so the row can be found and read whichever language is
-// running — and choosing the running language again cancels a pending change.
+// Settings → Appearance → Language (specs 068 and 077, contracts/language-row.md). The interface
+// language is fixed for a run, so choosing one saves it and says so on the row itself, with no
+// dialog: a note beside the list and, where Nota can start itself again, a small Restart button
+// that closes the main window by its usual path (the unsaved-changes prompt included).
+//
+// Nota ships English only. The list holds English, the installed languages and — once the list
+// from nota-translations is in (LanguageDownloads) — the ones that can be downloaded, each with
+// how complete it is for this Nota. Choosing one that is not installed downloads it in place
+// (progress, then the restart note; a failure says why and changes nothing). Beside the list:
+// Update when a newer version of the chosen language is published, Remove, and Load file… for a
+// translator's file, whose problems are listed under the row. Each language is written in its
+// own name, so the row can be found and read whichever language is running.
using System;
using System.Collections.Generic;
+using System.IO;
+using System.Linq;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Platform.Storage;
using Microsoft.Extensions.DependencyInjection;
using Nota.Application;
using Nota.Application.Localization;
+using Nota.Infrastructure;
namespace Nota.App;
public sealed partial class PreferencesWindow
{
+ private enum LanguageKind { English, Installed, Available }
+
+ private sealed record LanguageItem(string Code, string Name, LanguageKind Kind, string Detail,
+ InstalledLanguage? Installed, CatalogLanguage? Offered);
+
private Control LanguagePicker()
{
var settings = App.Services.GetRequiredService<ISettingsService>();
- var codes = NotaLanguages.Codes;
+ var installed = App.Services.GetRequiredService<InstalledLanguages>();
+ var downloads = LanguageDownloads.Shared;
+
var combo = Combo(160);
- var languages = new List<string>();
- foreach (var language in NotaLanguages.Available)
- {
- languages.Add(language.Code);
- combo.Items.Add(new ComboBoxItem { Content = language.Name });
- }
+ combo.HorizontalContentAlignment = HorizontalAlignment.Left; // a panel, not a string: keep it where text sits
+ var items = new List<LanguageItem>();
- // Where Nota can start itself again the note comes with a button; in a development run
- // there is nothing to start, so the note says when the change lands.
var canRelaunch = AppRestart.CanRelaunch;
var pending = new TextBlock
{
Text = canRelaunch ? Loc.T("preferences.language.applies_after_restart") : Loc.T("preferences.language.applies_the_next_time_nota"),
- FontSize = 11, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center,
- TextWrapping = Avalonia.Media.TextWrapping.Wrap,
+ FontSize = 11, Foreground = Brass, VerticalAlignment = VerticalAlignment.Center, TextWrapping = TextWrapping.Wrap,
};
- var restart = Btn(Loc.T("preferences.language.restart"));
- restart.Height = 24;
- restart.Padding = new Avalonia.Thickness(10, 0);
+ var restart = SmallBtn(Loc.T("preferences.language.restart"));
restart.Click += (_, _) =>
{
// The usual close: it asks about unsaved changes, and cancelling that cancels the
@@ -59,32 +67,263 @@ public sealed partial class PreferencesWindow
note.Children.Add(pending);
if (canRelaunch) note.Children.Add(restart);
- // The stored choice drives both the selected item and the note.
+ var update = SmallBtn(Loc.T("preferences.language.update"));
+ var remove = SmallBtn(Loc.T("preferences.language.remove"));
+ var load = SmallBtn(Loc.T("preferences.language.load_file"));
+ var show = SmallBtn(Loc.T("preferences.language.show_available_languages"));
+ var fetchStored = SmallBtn("");
+ var status = new TextBlock { FontSize = 11, Foreground = TextMuted, TextWrapping = TextWrapping.Wrap, VerticalAlignment = VerticalAlignment.Center };
+ var progress = new ProgressBar { Width = 90, Height = 4, MinWidth = 0, Minimum = 0, Maximum = 1, VerticalAlignment = VerticalAlignment.Center, IsVisible = false };
+ progress.BindResource(ProgressBar.ForegroundProperty, "Brush.Accent");
+ var problems = new TextBlock { FontSize = 11, LineHeight = 17, Foreground = TextMuted, TextWrapping = TextWrapping.Wrap, IsVisible = false };
+
+ string Stored() => (settings.Current.Language ?? UiLanguage.Default).Trim().ToLowerInvariant();
+
+ void Save(string code)
+ {
+ settings.Current.Language = code;
+ settings.Save();
+ MacSystemLanguage.Set(code); // macOS's own text follows from the next start
+ }
+
+ IReadOnlyList<LanguageItem> Build()
+ {
+ var list = new List<LanguageItem> { new(UiLanguage.Default, Loc.English.Name, LanguageKind.English, "", null, null) };
+ var index = downloads.Index;
+ var mine = installed.List().Where(l => l.Code != UiLanguage.Default).ToList();
+ foreach (var l in mine)
+ {
+ var offered = index?.Languages.FirstOrDefault(o => o.Code == l.Code);
+ string detail = l.Table is null ? Loc.T("preferences.language.unreadable")
+ : l.Meta.IsLocal ? Loc.T("preferences.language.local_file")
+ // The published coverage describes the published file: use it only when that
+ // is the file installed, else measure the installed one.
+ : index is not null && offered is not null && offered.Sha256 == l.Meta.Sha256
+ && LanguageDownloads.CoverageOf(index, offered) is { } c ? NotaNum.Unit(c, "0", "%")
+ : NotaNum.Unit(l.Table.ValidateAgainst(Loc.English).Coverage, "0", "%");
+ list.Add(new(l.Code, l.Table?.Name ?? l.Code, LanguageKind.Installed, detail, l, offered));
+ }
+ if (index is not null)
+ foreach (var o in index.Languages.Where(o => o.Code != UiLanguage.Default && mine.All(m => m.Code != o.Code)))
+ {
+ var c = LanguageDownloads.CoverageOf(index, o);
+ list.Add(new(o.Code, o.Name, LanguageKind.Available, (c is { } cc ? NotaNum.Unit(cc, "0", "%") + " · " : "") + Loc.T("preferences.language.download"), null, o));
+ }
+ return list;
+ }
+
var syncing = false;
- void ShowSaved()
+ void Refresh()
{
- var stored = UiLanguage.Normalize(settings.Current.Language, codes);
+ var fresh = Build();
+ // Rebuild the list only when it changed: the combo's items are not replaced under an
+ // open drop-down or a selection change for nothing.
+ bool same = fresh.Count == items.Count && fresh.Zip(items).All(p => p.First.Code == p.Second.Code
+ && p.First.Kind == p.Second.Kind && p.First.Detail == p.Second.Detail && p.First.Name == p.Second.Name);
+ items.Clear();
+ items.AddRange(fresh);
syncing = true;
- combo.SelectedIndex = Math.Max(0, languages.IndexOf(stored));
+ if (!same) combo.Items.Clear();
+ foreach (var it in same ? (IEnumerable<LanguageItem>)Array.Empty<LanguageItem>() : items)
+ {
+ var row = new StackPanel { Orientation = Orientation.Horizontal, Spacing = 8, HorizontalAlignment = HorizontalAlignment.Left };
+ row.Children.Add(new TextBlock { Text = it.Name, VerticalAlignment = VerticalAlignment.Center });
+ if (it.Detail.Length > 0)
+ row.Children.Add(new TextBlock { Text = it.Detail, FontSize = 11, Foreground = TextMuted, VerticalAlignment = VerticalAlignment.Center });
+ // A line above the first language to download sets them apart from the installed
+ // ones; drawn on the item itself, so the items stay one per language.
+ bool firstAvailable = it.Kind == LanguageKind.Available && items.First(i => i.Kind == LanguageKind.Available) == it;
+ Control content = row;
+ if (firstAvailable)
+ {
+ var rule = new Border { BorderThickness = new Avalonia.Thickness(0, 1, 0, 0), Padding = new Avalonia.Thickness(0, 6, 0, 0), Child = row, HorizontalAlignment = HorizontalAlignment.Stretch };
+ rule.BindResource(Border.BorderBrushProperty, "Brush.BorderDefault");
+ content = rule;
+ }
+ combo.Items.Add(new ComboBoxItem { Content = content, HorizontalContentAlignment = HorizontalAlignment.Stretch });
+ }
+ var stored = Stored();
+ int at = items.FindIndex(i => i.Code == stored && i.Kind != LanguageKind.Available);
+ combo.SelectedIndex = Math.Max(0, at);
syncing = false;
- note.IsVisible = UiLanguage.IsPending(stored, Loc.Language, codes);
+
+ var chosen = items[combo.SelectedIndex];
+ bool storedInstalled = at >= 0;
+ note.IsVisible = storedInstalled && (stored != Loc.Language || downloads.UpdatedThisRun.Contains(stored));
+ // One choice at a time: while a language downloads, the list and Load file… wait.
+ combo.IsEnabled = load.IsEnabled = downloads.Downloading is null;
+ update.IsVisible = chosen.Kind == LanguageKind.Installed && chosen.Installed is { } inst && chosen.Offered is { } off
+ && LanguageCatalog.UpdateAvailable(inst, off) && downloads.Downloading is null;
+ remove.IsVisible = chosen.Kind == LanguageKind.Installed && downloads.Downloading is null;
+ show.IsVisible = downloads.Index is null && !LanguageDownloads.MayCheck && storedInstalled;
+ // The stored language is not installed (Nota used to ship French) and Nota does not go
+ // online on its own: one click fetches the list and the language (FR-021).
+ fetchStored.IsVisible = !storedInstalled && stored != UiLanguage.Default && !LanguageDownloads.MayCheck && downloads.Downloading is null;
+ fetchStored.Content = Loc.F("preferences.language.download_language", NameOf(stored));
+
+ progress.IsVisible = downloads.Downloading is not null;
+ progress.IsIndeterminate = downloads.Progress < 0;
+ if (downloads.Progress >= 0) progress.Value = downloads.Progress;
+ status.Foreground = TextMuted;
+ if (downloads.Downloading is { } dl)
+ status.Text = Loc.F("preferences.language.downloading", NameOf(dl));
+ else if (downloads.Failed is { } f)
+ {
+ status.Text = Loc.F("preferences.language.couldnt_download", NameOf(f.Code), f.Message);
+ status.Foreground = NotaPalette.DangerBright;
+ }
+ else if (!storedInstalled && stored != UiLanguage.Default)
+ status.Text = LanguageDownloads.MayCheck
+ ? Loc.F("preferences.language.will_be_downloaded_when_online", NameOf(stored))
+ : Loc.F("preferences.language.is_not_installed", NameOf(stored));
+ else if (chosen.Installed is { Table: null } broken)
+ status.Text = Loc.F("preferences.language.cannot_be_used", broken.Error ?? "");
+ else if (downloads.Index is null && downloads.IndexError is { } why)
+ status.Text = Loc.F("preferences.language.couldnt_get_the_list", why);
+ else status.Text = "";
+ status.IsVisible = status.Text.Length > 0;
+ }
+
+ // Download progress moves only the bar: nothing is re-read for it.
+ void Progress()
+ {
+ progress.IsIndeterminate = downloads.Progress < 0;
+ if (downloads.Progress >= 0) progress.Value = downloads.Progress;
+ }
+
+ string NameOf(string code)
+ => items.FirstOrDefault(i => i.Code == code)?.Name
+ ?? downloads.Index?.Languages.FirstOrDefault(l => l.Code == code)?.Name ?? OwnName(code);
+
+ async void Download(CatalogLanguage language, bool choose)
+ {
+ // Saved only if nothing else was chosen meanwhile (the list is locked, but a remove
+ // or a change from another window may still land).
+ var before = Stored();
+ if (await downloads.DownloadAsync(language) && choose && Stored() == before) Save(language.Code);
+ downloads.NoteReady(language.Code, language.Name);
+ Refresh();
}
+
+ // Handled after the selection change has finished: Refresh may replace the combo's items,
+ // which Avalonia does not allow from inside its own SelectionChanged.
combo.SelectionChanged += (_, _) =>
{
- if (syncing || combo.SelectedIndex < 0 || combo.SelectedIndex >= languages.Count) return;
- var code = languages[combo.SelectedIndex];
- if (UiLanguage.Normalize(settings.Current.Language, codes) == code) return;
- settings.Current.Language = code;
- settings.Save();
- MacSystemLanguage.Set(code); // macOS's own text follows from the next start
- ShowSaved();
+ if (syncing) return;
+ Avalonia.Threading.Dispatcher.UIThread.Post(Choose);
+ };
+ void Choose()
+ {
+ if (combo.SelectedIndex < 0 || combo.SelectedIndex >= items.Count) return;
+ var it = items[combo.SelectedIndex];
+ problems.IsVisible = false;
+ if (it.Kind == LanguageKind.Available)
+ {
+ if (it.Offered is { } o && downloads.Downloading is null) Download(o, choose: true);
+ Refresh(); // back to the stored language until the download is in
+ return;
+ }
+ if (Stored() == it.Code) { Refresh(); return; }
+ Save(it.Code);
+ downloads.NoteReady(it.Code, it.Name);
+ Refresh();
+ }
+ update.Click += (_, _) =>
+ {
+ var it = items[combo.SelectedIndex];
+ if (it.Offered is { } o) Download(o, choose: false);
+ };
+ remove.Click += (_, _) =>
+ {
+ var it = items[combo.SelectedIndex];
+ installed.Remove(it.Code);
+ // Removing the chosen language goes back to English from the next start (and keeps
+ // the start-up download from fetching it again); a running one stays until then.
+ if (Stored() == it.Code) Save(UiLanguage.Default);
+ downloads.ClearReady();
+ Refresh();
+ };
+ show.Click += async (_, _) => { await downloads.FetchAsync(refresh: true); Refresh(); };
+ fetchStored.Click += async (_, _) =>
+ {
+ var code = Stored();
+ await downloads.FetchAsync(refresh: true);
+ if (downloads.Index?.Languages.FirstOrDefault(l => l.Code == code) is { } offered) Download(offered, choose: true);
+ Refresh();
+ };
+ load.Click += async (_, _) =>
+ {
+ var files = await this.PickFilesAsync(new FilePickerOpenOptions
+ {
+ Title = Loc.T("preferences.language.load_a_language_file"), AllowMultiple = false,
+ FileTypeFilter = new[] { new FilePickerFileType(Loc.T("preferences.language.language_file")) { Patterns = new[] { "*.json" } } },
+ });
+ if (files.Count == 0 || files[0].TryGetLocalPath() is not { } path) return;
+ TranslationTable? table;
+ string? error;
+ try { table = TranslationTable.Parse(File.ReadAllText(path), out error); }
+ catch (Exception e) when (e is IOException or UnauthorizedAccessException) { table = null; error = e.Message; }
+ if (table is null || table.Code == UiLanguage.Default || !InstalledLanguages.IsSafeCode(table.Code))
+ {
+ problems.Text = Loc.F("preferences.language.not_a_language_file", Path.GetFileName(path), error ?? table?.Code ?? "");
+ problems.Foreground = NotaPalette.DangerBright;
+ problems.IsVisible = true;
+ return;
+ }
+ installed.InstallLocal(path, table.Code);
+ Save(table.Code);
+ downloads.NoteReady(table.Code, table.Name);
+ var (found, coverage) = table.ValidateAgainst(Loc.English);
+ var log = App.Services.GetRequiredService<ILogSink>();
+ log.Info($"Interface language file {path}: {table.Code}, covers {coverage}% of the English keys, {found.Count} entries show English");
+ foreach (var p in found) log.Warn($"Interface language file {path}: {p.Key} — {p.Problem}");
+ var lines = new List<string> { Loc.F("preferences.language.loaded_file", table.Name, NotaNum.Unit(coverage, "0", "%"), found.Count) };
+ lines.AddRange(found.Take(10).Select(p => $"{p.Key} — {p.Problem}"));
+ if (found.Count > 10) lines.Add(Loc.F("preferences.language.and_more_see_the_log", found.Count - 10));
+ problems.Text = string.Join("\n", lines);
+ problems.Foreground = TextMuted;
+ problems.IsVisible = true;
+ Refresh();
};
- ShowSaved();
+
+
+ // The list: the cache at once, the network when Nota may ask on its own.
+ downloads.LoadCached();
+ Refresh();
+ if (LanguageDownloads.MayCheck) _ = downloads.FetchAsync();
var line = new WrapPanel { Orientation = Orientation.Horizontal, VerticalAlignment = VerticalAlignment.Center };
combo.Margin = new Avalonia.Thickness(0, 0, 12, 0);
line.Children.Add(combo);
- line.Children.Add(note);
- return line;
+ foreach (var c in new Control[] { note, update, remove, fetchStored, load, show, progress, status })
+ {
+ c.Margin = new Avalonia.Thickness(0, 2, 10, 2);
+ line.Children.Add(c);
+ }
+ // Listen only while the row is on screen: Settings builds a new row each time the page is
+ // shown, and a hidden one must not keep re-reading the installed languages.
+ var panel = new StackPanel { Spacing = 6, Children = { line, problems } };
+ panel.AttachedToVisualTree += (_, _) => { downloads.Changed += Refresh; downloads.ProgressChanged += Progress; };
+ panel.DetachedFromVisualTree += (_, _) => { downloads.Changed -= Refresh; downloads.ProgressChanged -= Progress; };
+ return panel;
+ }
+
+ // A language's own name before the list is in ("fr" → "Français"), from the OS's culture data.
+ private static string OwnName(string code)
+ {
+ try
+ {
+ var name = System.Globalization.CultureInfo.GetCultureInfo(code).NativeName;
+ return name.Length > 0 && !name.StartsWith("Unknown", StringComparison.Ordinal) ? char.ToUpperInvariant(name[0]) + name[1..] : code;
+ }
+ catch (System.Globalization.CultureNotFoundException) { return code; }
+ }
+
+ private static Button SmallBtn(string text)
+ {
+ var b = Btn(text);
+ b.Height = 24;
+ b.Padding = new Avalonia.Thickness(10, 0);
+ return b;
}
}
diff --git a/src/managed/Nota.Application/Localization/en.json b/src/managed/Nota.Application/Localization/en.json
index a2db9a59..9e21be38 100644
--- a/src/managed/Nota.Application/Localization/en.json
+++ b/src/managed/Nota.Application/Localization/en.json
@@ -1885,6 +1885,10 @@
"kits.drum_kit.couldnt_create_a_drum_rack": "Couldn't create a Drum Rack track.",
"kits.drum_kit.couldnt_create_a_nota_rhythm": "Couldn't create a Nota Rhythm track.",
"kits.drum_kit.unknown_drum_kit": "Unknown drum kit.",
+ "language_catalog.the_downloaded_file_is_not_a_language": "The downloaded {0} is not a language file: {1}",
+ "language_catalog.the_language_list_entry_for_is_invalid": "The language list entry for {0} is invalid.",
+ "language_catalog.update_nota_to_see_more_languages": "Update Nota to see more languages.",
+ "language_downloads.cancelled": "Cancelled",
"lens.nota_lens": "Nota Lens · {0}",
"linux_file_dialogs.the_system_file_dialog_answered": "the system file dialog answered without showing",
"linux_file_dialogs.the_system_file_dialog_didnt": "the system file dialog didn't open within {0:0} s",
@@ -2340,6 +2344,8 @@
"main.updates.download_it_from_the_release": " Download it from the release page.",
"main.updates.download_nota": "Download Nota {0}…",
"main.updates.hide_it_still_installs_when": "Hide — it still installs when you quit",
+ "main.updates.language_is_ready_next_start": "{0} is ready — it applies the next time Nota starts",
+ "main.updates.language_is_ready_restart": "{0} is ready — restart to use it",
"main.updates.later": "Later",
"main.updates.nota_downloads_it_here_and": " Nota downloads it here and installs it when you restart or quit.",
"main.updates.nota_is_available": "Nota {0} is available",
@@ -3117,9 +3123,28 @@
"preferences.keyboard_reference": "Keyboard reference",
"preferences.label_every_note_in_the": "Label every note in the piano roll",
"preferences.language": "Language",
+ "preferences.language.and_more_see_the_log": "…and {0} more (see the log)",
"preferences.language.applies_after_restart": "Applies after restart",
"preferences.language.applies_the_next_time_nota": "Applies the next time Nota starts",
+ "preferences.language.cannot_be_used": "This language can't be used: {0}",
+ "preferences.language.couldnt_download": "Couldn't download {0} — {1}",
+ "preferences.language.couldnt_get_the_list": "Couldn't get the language list — {0}",
+ "preferences.language.download": "download",
+ "preferences.language.download_language": "Download {0}",
+ "preferences.language.downloading": "Downloading {0}…",
+ "preferences.language.is_not_installed": "{0} isn't installed — choose it again to download it",
+ "preferences.language.language_file": "Language file",
+ "preferences.language.load_a_language_file": "Load a language file",
+ "preferences.language.load_file": "Load file…",
+ "preferences.language.loaded_file": "Loaded {0} · {1} complete · {2} entries show English",
+ "preferences.language.local_file": "local file",
+ "preferences.language.not_a_language_file": "{0} is not a language file: {1}",
+ "preferences.language.remove": "Remove",
"preferences.language.restart": "Restart",
+ "preferences.language.show_available_languages": "Show available languages",
+ "preferences.language.unreadable": "unreadable",
+ "preferences.language.update": "Update",
+ "preferences.language.will_be_downloaded_when_online": "{0} isn't installed yet — Nota downloads it when it's online",
"preferences.last": "Last",
"preferences.last_check_average_peak": "Last check: {0:0} % average, {1:0} % peak · {2} — {3}.",
"preferences.latency": "Latency",
diff --git a/src/managed/Nota.Infrastructure/Languages/InstalledLanguages.cs b/src/managed/Nota.Infrastructure/Languages/InstalledLanguages.cs
new file mode 100644
index 00000000..606097ad
--- /dev/null
+++ b/src/managed/Nota.Infrastructure/Languages/InstalledLanguages.cs
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
+//
+// The interface languages on this computer (spec 077, data-model § Installed language). Nota
+// ships English only; a language downloaded from nota-translations is kept here, and a file a
+// translator loads is remembered here by its path, so Nota starts in either with no network.
+//
+// Layout (<data>/languages, NOTA_DATA_DIR in tests):
+// <code>.json a downloaded language file
+// <code>.meta.json where it came from: { source: repository|local, path?, version?, commit?, sha256?, installed }
+// .staging-<code>.json a download in progress; left-overs are removed on start
+// A download is written to its staging file and moved over the installed one only once it has
+// been checked, so a failed or interrupted one never replaces a working language.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Nota.Application.Localization;
+
+namespace Nota.Infrastructure;
+
+/// <summary>Where an installed language came from.</summary>
+public sealed record InstalledLanguageMeta(
+ string Source, string? Path = null, int? Version = null, string? Commit = null, string? Sha256 = null, DateTime? Installed = null)
+{
+ public const string Repository = "repository";
+ public const string Local = "local";
+
+ [JsonIgnore] public bool IsLocal => Source == Local;
+}
+
+/// <summary>One language on this computer, as read at start-up.</summary>
+public sealed record InstalledLanguage(string Code, InstalledLanguageMeta Meta, TranslationTable? Table, string? Error);
+
+public sealed class InstalledLanguages
+{
+ private static readonly JsonSerializerOptions Json = new()
+ {
+ PropertyNamingPolicy = JsonNamingPolicy.CamelCase, WriteIndented = true,
+ DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+ };
+
+ public InstalledLanguages() : this(NotaPaths.SubDir("languages")) { }
+
+ /// <param name="root">The languages folder (tests pass a temp dir).</param>
+ public InstalledLanguages(string root)
+ {
+ Root = root;
+ Directory.CreateDirectory(root);
+ try
+ {
+ foreach (var f in Directory.EnumerateFiles(root, ".staging-*").Concat(Directory.EnumerateFiles(root, "*.bak")))
+ try { File.Delete(f); } catch { /* next start */ }
+ }
+ catch (Exception e) when (e is IOException or UnauthorizedAccessException) { /* an unreadable folder: List says so */ }
+ }
+
+ public string Root { get; }
+
+ /// <summary>Every language with a meta file, read and parsed (a file that cannot be read or
+ /// parsed is listed with its error and no table). Sorted by code.</summary>
+ public IReadOnlyList<InstalledLanguage> List()
+ {
+ var list = new List<InstalledLanguage>();
+ IEnumerable<string> metas;
+ try { metas = Directory.EnumerateFiles(Root, "*.meta.json").Order(StringComparer.Ordinal).ToList(); }
+ catch (Exception e) when (e is IOException or UnauthorizedAccessException) { return list; }
+ foreach (var metaFile in metas)
+ {
+ var code = System.IO.Path.GetFileName(metaFile)[..^".meta.json".Length];
+ if (Read(code) is { } l) list.Add(l);
+ }
+ return list;
+ }
+
+ /// <summary>One installed language, or null if <paramref name="code"/> has no meta file.</summary>
+ public InstalledLanguage? Read(string code)
+ {
+ if (!IsSafeCode(code)) return null;
+ var metaFile = MetaPath(code);
+ if (!File.Exists(metaFile)) return null;
+ InstalledLanguageMeta? meta;
+ try { meta = JsonSerializer.Deserialize<InstalledLanguageMeta>(File.ReadAllText(metaFile), Json); }
+ catch (Exception e) when (e is JsonException or IOException or UnauthorizedAccessException) { meta = null; }
+ if (meta is null) return new InstalledLanguage(code, new InstalledLanguageMeta(InstalledLanguageMeta.Repository), null, "its record is unreadable");
+ var file = meta.IsLocal ? meta.Path : FilePath(code);
+ if (string.IsNullOrEmpty(file) || !File.Exists(file))
+ return new InstalledLanguage(code, meta, null, meta.IsLocal ? $"the file {meta.Path} is missing" : "the language file is missing");
+ string text;
+ try { text = File.ReadAllText(file); }
+ catch (Exception e) when (e is IOException or UnauthorizedAccessException) { return new InstalledLanguage(code, meta, null, e.Message); }
+ var table = TranslationTable.Parse(text, out var error);
+ if (table is not null && table.Code != code) return new InstalledLanguage(code, meta, null, $"the file is for '{table.Code}', not '{code}'");
+ return new InstalledLanguage(code, meta, table, error);
+ }
+
+ /// <summary>A file for a staging download of <paramref name="code"/>.</summary>
+ public string StagingPath(string code) => System.IO.Path.Combine(Root, $".staging-{code}.json");
+
+ /// <summary>Moves a checked download into place and records where it came from. If either
+ /// write fails, the language as it was — file and record — is put back and the error thrown.</summary>
+ public void InstallFrom(string staging, string code, InstalledLanguageMeta meta)
+ {
+ if (!IsSafeCode(code)) throw new ArgumentException($"not a language code: {code}");
+ string file = FilePath(code), metaFile = MetaPath(code);
+ string fileBak = file + ".bak", metaBak = metaFile + ".bak";
+ bool hadFile = File.Exists(file), hadMeta = File.Exists(metaFile);
+ if (hadFile) File.Copy(file, fileBak, overwrite: true);
+ if (hadMeta) File.Copy(metaFile, metaBak, overwrite: true);
+ try
+ {
+ File.Move(staging, file, overwrite: true);
+ WriteMeta(code, meta with { Source = InstalledLanguageMeta.Repository, Path = null, Installed = DateTime.UtcNow });
+ }
+ catch
+ {
+ Restore(file, fileBak, hadFile);
+ Restore(metaFile, metaBak, hadMeta);
+ throw;
+ }
+ finally
+ {
+ foreach (var b in new[] { fileBak, metaBak }) try { File.Delete(b); } catch { /* next start */ }
+ }
+ }
+
+ private static void Restore(string path, string backup, bool had)
+ {
+ try
+ {
+ if (had) File.Copy(backup, path, overwrite: true);
+ else if (File.Exists(path)) File.Delete(path);
+ }
+ catch { /* best effort: the error being thrown says what failed */ }
+ }
+
+ /// <summary>Remembers a translator's file by its path; it is read in place at each start
+ /// and is never replaced by a download.</summary>
+ public void InstallLocal(string path, string code)
+ {
+ if (!IsSafeCode(code)) throw new ArgumentException($"not a language code: {code}");
+ var full = System.IO.Path.GetFullPath(path);
+ // The record first: if it cannot be written, the installed language is untouched.
+ WriteMeta(code, new InstalledLanguageMeta(InstalledLanguageMeta.Local, full, Installed: DateTime.UtcNow));
+ // A downloaded copy is no longer used — unless it is the very file being loaded.
+ var downloaded = FilePath(code);
+ if (!string.Equals(System.IO.Path.GetFullPath(downloaded), full, OperatingSystem.IsLinux() ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase))
+ try { File.Delete(downloaded); } catch { /* unused either way */ }
+ }
+
+ /// <summary>Forgets a language. A running one keeps working until the restart (its table is
+ /// already in memory), then Nota is in English.</summary>
+ public void Remove(string code)
+ {
+ if (!IsSafeCode(code)) return;
+ foreach (var f in new[] { MetaPath(code), FilePath(code) })
+ try { File.Delete(f); } catch { /* best effort */ }
+ }
+
+ /// <summary>A language code is also a file name here: refuse anything that could leave the folder.</summary>
+ public static bool IsSafeCode(string code)
+ => code.Length is >= 2 and <= 12 && code.All(c => c is >= 'a' and <= 'z' or >= '0' and <= '9' or '-') && code[0] != '-';
+
+ private string FilePath(string code) => System.IO.Path.Combine(Root, code + ".json");
+ private string MetaPath(string code) => System.IO.Path.Combine(Root, code + ".meta.json");
+
+ private void WriteMeta(string code, InstalledLanguageMeta meta)
+ => RegistryClient.WriteAtomic(MetaPath(code), JsonSerializer.Serialize(meta, Json));
+}
diff --git a/src/managed/Nota.Infrastructure/Languages/LanguageCatalog.cs b/src/managed/Nota.Infrastructure/Languages/LanguageCatalog.cs
new file mode 100644
index 00000000..a50e4db5
--- /dev/null
+++ b/src/managed/Nota.Infrastructure/Languages/LanguageCatalog.cs
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
+//
+// The languages nota-translations offers (spec 077, contracts/index.md) and their download. The
+// index is the published branch's index.json, cached a day under <data>/languages and used as
+// the offline fallback, like the plugin and sample registries (RegistryClient). A language file
+// is fetched from <base>/<commit>/<path> — the commit the index pins — so it always matches the
+// size + sha256 the index states; it is parsed and checked before it replaces anything.
+// NOTA_LANGUAGES_URL relocates <base> (a URL or a local folder laid out the same way: tests,
+// staging). Nothing fetched is executed: a language file is data.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Nota.Application.Localization;
+
+namespace Nota.Infrastructure;
+
+/// <summary>One language the index offers.</summary>
+public sealed record CatalogLanguage(
+ string Code, string Name, int Version, string Commit, string Path, long Size, string Sha256,
+ IReadOnlyDictionary<string, int> Coverage);
+
+/// <summary>The parsed index: Nota version → key-set hash, and the languages.</summary>
+public sealed record LanguageIndex(IReadOnlyDictionary<string, string> References, IReadOnlyList<CatalogLanguage> Languages);
+
+public sealed class LanguageCatalog
+{
+ /// <summary>The index shape this build reads; a higher one is ignored ("update Nota").</summary>
+ public const int IndexFormat = 1;
+ public const string DefaultBase = "https://raw.githubusercontent.com/nota-daw/nota-translations";
+
+ private static readonly JsonSerializerOptions Json = new() { PropertyNameCaseInsensitive = true };
+
+ private readonly InstalledLanguages _installed;
+ private readonly RegistryClient _http;
+ private readonly string _base;
+ private readonly string _cachePath;
+
+ public LanguageCatalog(InstalledLanguages installed)
+ : this(installed, Environment.GetEnvironmentVariable("NOTA_LANGUAGES_URL") is { Length: > 0 } b ? b : DefaultBase) { }
+
+ /// <param name="baseUrl">nota-translations raw root (or a local folder with the same layout).</param>
+ public LanguageCatalog(InstalledLanguages installed, string baseUrl, HttpMessageHandler? handler = null)
+ {
+ _installed = installed;
+ _base = baseUrl.TrimEnd('/');
+ _cachePath = System.IO.Path.Combine(installed.Root, "index.json");
+ _http = new RegistryClient(_base + "/published/index.json", _cachePath, "language list", "Nota-Languages", handler);
+ }
+
+ /// <summary>The last index fetched, without any network, or null if there is none yet (or it
+ /// is unreadable).</summary>
+ public LanguageIndex? Cached()
+ {
+ try { return File.Exists(_cachePath) ? Parse(File.ReadAllText(_cachePath)) : null; }
+ catch (Exception e) when (e is JsonException or IOException or StoreException) { return null; }
+ }
+
+ /// <summary>The index: the cache while it is a day fresh (unless <paramref name="refresh"/>),
+ /// else the network, falling back to the cache offline. Throws <see cref="StoreException"/>
+ /// when there is neither, or the index is newer than this Nota reads.</summary>
+ public async Task<LanguageIndex> FetchAsync(bool refresh, CancellationToken ct = default)
+ => Parse(await _http.FetchIndexAsync(refresh, json => Parse(json), ct).ConfigureAwait(false));
+
+ /// <summary>How complete <paramref name="language"/> is for this Nota: its coverage for the
+ /// running key set, else for the newest reference of a version at or below
+ /// <paramref name="appVersion"/>; null when the index has neither.</summary>
+ public static int? CoverageFor(LanguageIndex index, CatalogLanguage language, string keySetHash, string appVersion)
+ {
+ if (language.Coverage.TryGetValue(keySetHash, out var exact)) return exact;
+ var app = VersionOf(appVersion);
+ var older = index.References
+ .Where(r => r.Key != "develop" && VersionOf(r.Key) is { } v && app is not null && v <= app)
+ .OrderByDescending(r => VersionOf(r.Key))
+ .Select(r => language.Coverage.TryGetValue(r.Value, out var c) ? c : (int?)null)
+ .FirstOrDefault(c => c is not null);
+ return older;
+ }
+
+ /// <summary>Whether the index has a newer version of an installed repository language.</summary>
+ public static bool UpdateAvailable(InstalledLanguage installed, CatalogLanguage offered)
+ => !installed.Meta.IsLocal && (installed.Meta.Version ?? 0) < offered.Version;
+
+ /// <summary>Downloads a language, checks its size, sha256 and that it reads as a language
+ /// file for its code, and installs it. On any failure the installed copy (if any) stays.</summary>
+ public async Task<InstalledLanguage> DownloadAsync(CatalogLanguage language, IProgress<StoreProgress>? progress = null, CancellationToken ct = default)
+ {
+ if (!InstalledLanguages.IsSafeCode(language.Code) || !IsSafePath(language.Path) || !IsCommit(language.Commit))
+ throw new StoreException(Loc.F("language_catalog.the_language_list_entry_for_is_invalid", language.Code));
+ var staging = _installed.StagingPath(language.Code);
+ try
+ {
+ await _http.DownloadAsync($"{_base}/{language.Commit}/{language.Path}", language.Size, language.Sha256,
+ staging, language.Name, progress, ct).ConfigureAwait(false);
+ var table = TranslationTable.Parse(await File.ReadAllTextAsync(staging, ct).ConfigureAwait(false), out var error);
+ if (table is null) throw new StoreException(Loc.F("language_catalog.the_downloaded_file_is_not_a_language", language.Name, error ?? ""));
+ if (table.Code != language.Code) throw new StoreException(Loc.F("language_catalog.the_downloaded_file_is_not_a_language", language.Name, table.Code));
+ _installed.InstallFrom(staging, language.Code,
+ new InstalledLanguageMeta(InstalledLanguageMeta.Repository, Version: language.Version, Commit: language.Commit, Sha256: language.Sha256));
+ return _installed.Read(language.Code)!;
+ }
+ finally
+ {
+ try { File.Delete(staging); } catch { /* moved, or never written */ }
+ }
+ }
+
+ /// <summary>Parses an index; throws on a malformed one or one of a newer format.</summary>
+ public static LanguageIndex Parse(string json)
+ {
+ var raw = JsonSerializer.Deserialize<RawIndex>(json, Json) ?? throw new JsonException("empty language list");
+ if (raw.FormatVersion > IndexFormat)
+ throw new StoreException(Loc.T("language_catalog.update_nota_to_see_more_languages"));
+ // A malformed entry (null, missing fields, an unsafe code) is left out, never thrown.
+ var langs = (raw.Languages ?? new())
+ .Where(l => l is { Code: { } c, Name.Length: > 0, Commit: not null, Path: not null, Sha256: not null } && InstalledLanguages.IsSafeCode(c))
+ .Select(l => new CatalogLanguage(l!.Code!, l.Name!, l.Version, l.Commit!, l.Path!, l.Size, l.Sha256!,
+ l.Coverage ?? new Dictionary<string, int>()))
+ .OrderBy(l => l.Code, StringComparer.Ordinal).ToList();
+ var references = (raw.References ?? new Dictionary<string, string>())
+ .Where(r => r.Value is { Length: > 0 }).ToDictionary(r => r.Key, r => r.Value!);
+ return new LanguageIndex(references, langs);
+ }
+
+ private static Version? VersionOf(string s)
+ {
+ var core = s.Split('-', '+')[0];
+ return System.Version.TryParse(core, out var v) ? v : null;
+ }
+
+ private static bool IsSafePath(string p)
+ => p.Length > 0 && !p.StartsWith('/') && !p.Contains("..") && !p.Contains('\\') && !p.Contains("://");
+
+ private static bool IsCommit(string c) => c.Length is >= 7 and <= 64 && c.All(char.IsAsciiHexDigitLower);
+
+ private sealed class RawIndex
+ {
+ public int FormatVersion { get; set; }
+ public Dictionary<string, string?>? References { get; set; }
+ public List<RawLanguage?>? Languages { get; set; }
+ }
+
+ private sealed class RawLanguage
+ {
+ public string? Code { get; set; }
+ public string? Name { get; set; }
+ public int Version { get; set; }
+ public string? Commit { get; set; }
+ public string? Path { get; set; }
+ public long Size { get; set; }
+ public string? Sha256 { get; set; }
+ public Dictionary<string, int>? Coverage { get; set; }
+ }
+}
diff --git a/tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs b/tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs
index 29c5bc11..4db9dd7e 100644
--- a/tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs
+++ b/tests/Nota.SmokeTest/DesignTokenCheck.Localization.cs
@@ -185,19 +185,7 @@ internal static partial class DesignTokenCheck
Loc.EnglishError is null ? $"the embedded English reference is valid ({real.Count} keys, key set {real.KeySetHash()})" : "the embedded English reference: " + Loc.EnglishError);
var onDisk = TranslationTable.Parse(File.ReadAllText(Path.Combine(root, "src/managed/Nota.Application/Localization/en.json")), out _);
yield return (onDisk is not null && onDisk.KeySetHash() == real.KeySetHash(), "the embedded English is the en.json in the source");
- var dir = Path.Combine(root, "src/managed/Nota.App/Languages");
- var files = Directory.EnumerateFiles(dir, "*.json").OrderBy(f => f, StringComparer.Ordinal).ToArray();
- foreach (var file in files)
- {
- var id = Path.GetFileNameWithoutExtension(file)!;
- var table = TranslationTable.Parse(File.ReadAllText(file), out var error);
- yield return (table is not null && table.Code == id && id != "en",
- table is null ? $"{id}.json: {error}" : $"{id}.json: valid ({table.Name}, {table.Count} texts, rule {table.PluralRule})");
- }
- var names = files.Select(f => TranslationTable.Parse(File.ReadAllText(f), out _)).Where(t => t is not null)
- .ToDictionary(t => t!.Code, t => t!.Name);
- yield return (real.Name == "English" && names.GetValueOrDefault("fr") == "Français",
- "the picker offers English and Français, each by its own name");
+ yield return (real.Name == "English", "English is offered by its own name");
Loc.ResetForTests();
Loc.Install(null, "en"); // as the app leaves it: English installed
@@ -349,22 +337,15 @@ internal static partial class DesignTokenCheck
shape.Count == 0 ? "each key is used the way en.json shapes it (counted, formatted or plain)"
: "key used against its shape: " + string.Join("; ", shape.Take(6)));
- // -- French, still embedded until the languages move to nota-translations (spec 077 PR 3) --
- var frPath = Path.Combine(root, "src/managed/Nota.App/Languages/fr.json");
- var fr = TranslationTable.Parse(File.ReadAllText(frPath), out var frError);
- yield return (fr is not null, fr is null ? "fr.json: " + frError : "fr.json parsed");
- if (fr is null) yield break;
- var (frProblems, frCoverage) = fr.ValidateAgainst(en);
- var frMissing = en.Keys.Where(k => !fr.TryGet(k, out _)).Order(StringComparer.Ordinal).ToList();
- // NOTA_LOC_DUMP_MISSING=<file> writes the keys French still lacks (key, English, counted?, file) as JSON.
+ // -- Nota ships English only: every other language comes from nota-translations (spec 077) --
+ var embedded = Directory.EnumerateFiles(Path.Combine(root, "src/managed/Nota.App/Languages"), "*.json").Select(Path.GetFileName).ToList();
+ var appProject = File.ReadAllText(Path.Combine(root, "src/managed/Nota.App/Nota.App.csproj"));
+ yield return (embedded.Count == 0 && !appProject.Contains("Languages\\"),
+ embedded.Count == 0 ? "the app embeds no translation: English is the only built-in language (SC-008)"
+ : "translation files in the app (they belong in nota-translations): " + string.Join(", ", embedded));
+ // NOTA_LOC_DUMP_MISSING=<file> writes every key with its English (for translators) as JSON.
if (Environment.GetEnvironmentVariable("NOTA_LOC_DUMP_MISSING") is { Length: > 0 } dump)
- File.WriteAllText(dump, JsonSerializer.Serialize(frMissing.Select(k => new { key = k, english = en.TryGet(k, out var t) ? t.Other : "", plural = t.IsPlural, file = used.GetValueOrDefault(k).Path })));
- yield return (frMissing.Count == 0,
- frMissing.Count == 0 ? $"French covers all {en.Count} keys ({frCoverage} %)"
- : $"{frMissing.Count} keys have no French: {string.Join(", ", frMissing.Take(8))}");
- yield return (frProblems.Count == 0,
- frProblems.Count == 0 ? "every French entry is a key of en.json with its shape and placeholders"
- : "French entries that cannot be used: " + string.Join("; ", frProblems.Take(6).Select(p => $"{p.Key} — {p.Problem}")));
+ File.WriteAllText(dump, JsonSerializer.Serialize(en.Keys.Order(StringComparer.Ordinal).Select(k => new { key = k, english = en.TryGet(k, out var t) ? t.Other : "", plural = t.IsPlural, file = used.GetValueOrDefault(k).Path })));
// -- the language is a view setting: it follows only the stored choice, and writes nothing --
var osLanguage = new List<string>();
@@ -385,7 +366,8 @@ internal static partial class DesignTokenCheck
persistedText.Count == 0 ? "no project, preset or settings writer uses Loc (the language never changes saved work)"
: "translated text in code that is saved: " + string.Join(", ", persistedText));
// macOS shows its own text (Hide, Quit, the open panels) in a language the Info.plist lists.
- var shipped = Directory.EnumerateFiles(Path.Combine(root, "src/managed/Nota.App/Languages"), "*.json").Select(f => Path.GetFileNameWithoutExtension(f)!).ToList();
+ // English, plus the languages nota-translations offers today: macOS follows only listed ones.
+ var shipped = new List<string> { "en", "fr" };
var unlisted = new List<string>();
foreach (var script in new[] { "scripts/bundle-mac.sh", "scripts/package-dmg.sh" })
{
@@ -393,7 +375,7 @@ internal static partial class DesignTokenCheck
foreach (var code in shipped.Where(c => !plist.Contains($"<string>{c}</string>"))) unlisted.Add($"{script}: {code}");
}
yield return (unlisted.Count == 0,
- unlisted.Count == 0 ? "the macOS Info.plist lists every shipped language (CFBundleLocalizations)"
+ unlisted.Count == 0 ? "the macOS Info.plist lists English and the published languages (CFBundleLocalizations)"
: "language missing from CFBundleLocalizations: " + string.Join(", ", unlisted));
var appStart = File.ReadAllText(Path.Combine(root, "src/managed/Nota.App/App.axaml.cs"));
int installAt = appStart.IndexOf("private static void InstallLanguage", StringComparison.Ordinal);
diff --git a/tests/Nota.SmokeTest/LanguageCatalogTests.cs b/tests/Nota.SmokeTest/LanguageCatalogTests.cs
new file mode 100644
index 00000000..d6ec96ac
--- /dev/null
+++ b/tests/Nota.SmokeTest/LanguageCatalogTests.cs
@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Egor Khindikaynen (Nota). See LICENSES/ for license terms.
+//
+// Downloadable interface languages (spec 077 stories 3–5): the language list from
+// nota-translations, a download pinned to size + sha256, update / remove, a translator's local
+// file, and the offline cases — against a fake nota-translations served from memory (an
+// HttpMessageHandler), so the real network path and its on-disk cache are exercised with no
+// network. The fixture language is Fixtures/Languages/xx.json, checked against the real English.
+
+using System.Net;
+using System.Security.Cryptography;
+using System.Text;
+using Nota.Application;
+using Nota.Application.Localization;
+using Nota.Infrastructure;
+
+namespace Nota.SmokeTest;
+
+internal static class LanguageCatalogTests
+{
+ private const string Base = "https://translations.test";
+ private const string Commit = "0123456789abcdef0123456789abcdef01234567";
+
+ /// <summary>Serves a dictionary of URL → body; any other URL is 404, and Offline makes every
+ /// request fail as an unreachable network does. Counts requests.</summary>
+ private sealed class FakeServer : HttpMessageHandler
+ {
+ public readonly Dictionary<string, byte[]> Files = new(StringComparer.Ordinal);
+ public bool Offline;
+ public int Requests;
+
+ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken ct)
+ {
+ Requests++;
+ if (Offline) throw new HttpRequestException("offline (test)");
+ var url = request.RequestUri!.ToString();
+ return Task.FromResult(Files.TryGetValue(url, out var body)
+ ? new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(body) }
+ : new HttpResponseMessage(HttpStatusCode.NotFound));
+ }
+ }
+
+ private static string Index(string hash, int version, byte[] file, int formatVersion = 1, string commit = Commit)
+ => $$"""
+ { "formatVersion": {{formatVersion}}, "generated": "2026-11-04T00:00:00Z",
+ "references": { "0.58.0": "0000000000000000", "develop": "{{hash}}" },
+ "languages": [ { "code": "xx", "name": "Xxxx", "version": {{version}}, "commit": "{{commit}}",
+ "path": "languages/xx.json", "size": {{file.Length}},
+ "sha256": "{{Convert.ToHexStringLower(SHA256.HashData(file))}}", "coverage": { "{{hash}}": 1, "0000000000000000": 2 } } ] }
+ """;
+
+ public static IEnumerable<(bool Ok, string Label)> Run()
+ {
+ var root = RepoRoot();
+ if (root is null) { yield return (false, "repo root located"); yield break; }
+ var xx = File.ReadAllBytes(Path.Combine(root, "tests/Nota.SmokeTest/Fixtures/Languages/xx.json"));
+ var hash = Loc.English.KeySetHash();
+ var dir = Path.Combine(Path.GetTempPath(), "nota-smoke-languages-" + Guid.NewGuid().ToString("N"));
+ try
+ {
+ foreach (var r in Scenario(dir, xx, hash)) yield return r;
+ }
+ finally
+ {
+ try { Directory.Delete(dir, true); } catch { }
+ }
+ }
+
+ private static IEnumerable<(bool Ok, string Label)> Scenario(string dir, byte[] xx, string hash)
+ {
+ var server = new FakeServer();
+ server.Files[$"{Base}/published/index.json"] = Encoding.UTF8.GetBytes(Index(hash, 1, xx));
+ server.Files[$"{Base}/{Commit}/languages/xx.json"] = xx;
+ var installed = new InstalledLanguages(dir);
+ var catalog = new LanguageCatalog(installed, Base, server);
+
+ // Nothing installed, nothing cached: a fresh Nota ships English only.
+ yield return (installed.List().Count == 0 && catalog.Cached() is null, "a fresh data folder has no language and no list");
+
+ // The list, and coverage for this Nota's key set (contracts/index.md § App behaviour).
+ var index = catalog.FetchAsync(refresh: false).GetAwaiter().GetResult();
+ var offered = index.Languages.SingleOrDefault(l => l.Code == "xx");
+ yield return (offered is { Name: "Xxxx", Version: 1 } && index.References.Count == 2, "the list offers the language with its name and version");
+ yield return (offered is not null && LanguageCatalog.CoverageFor(index, offered, hash, "0.60.0") == 1
+ && LanguageCatalog.CoverageFor(index, offered, "ffffffffffffffff", "0.60.0") == 2
+ && LanguageCatalog.CoverageFor(index, offered, "ffffffffffffffff", "0.57.0") is null,
+ "coverage is the running key set's, else the newest older release's, else unknown");
+ if (offered is null) yield break;
+
+ // Install: pinned commit, size and sha256; recorded with its version.
+ var got = catalog.DownloadAsync(offered).GetAwaiter().GetResult();
+ yield return (got.Table is { Code: "xx" } && got.Meta is { Source: InstalledLanguageMeta.Repository, Version: 1, Commit: Commit },
+ "a download installs the language and records where it came from");
+ yield return (installed.List().Select(l => l.Code).SequenceEqual(new[] { "xx" }) && !Directory.EnumerateFiles(dir, ".staging-*").Any(),
+ "the installed language is listed and no staging file is left");
+ yield return (!LanguageCatalog.UpdateAvailable(got, offered), "the same version offers no update");
+
+ // A newer version is offered as an update; a download that does not match its sha256 is
+ // refused and the installed copy stays.
+ // Same size, one byte changed: only the sha256 can tell.
+ var tampered = (byte[])xx.Clone();
+ tampered[Array.IndexOf(tampered, (byte)'X')] = (byte)'Y';
+ server.Files[$"{Base}/published/index.json"] = Encoding.UTF8.GetBytes(Index(hash, 2, xx));
+ server.Files[$"{Base}/{Commit}/languages/xx.json"] = tampered;
+ var newer = catalog.FetchAsync(refresh: true).GetAwaiter().GetResult().Languages.Single();
+ yield return (LanguageCatalog.UpdateAvailable(installed.Read("xx")!, newer), "a newer version in the list is offered as an update");
+ string? refused = null;
+ try { catalog.DownloadAsync(newer).GetAwaiter().GetResult(); }
+ catch (StoreException e) { refused = e.Message; }
+ var kept = installed.Read("xx");
+ yield return (refused is not null && kept is { Table: not null, Meta.Version: 1 } && !Directory.EnumerateFiles(dir, ".staging-*").Any(),
+ $"a download that does not match its checksum is refused and the installed copy stays ({refused})");
+ server.Files[$"{Base}/{Commit}/languages/xx.json"] = xx;
+ var updated = catalog.DownloadAsync(newer).GetAwaiter().GetResult();
+ yield return (updated.Meta.Version == 2, "the update installs the newer version");
+
+ // An unsafe entry is never fetched.
+ var evil = newer with { Path = "../../etc/passwd" };
+ string? unsafeError = null;
+ try { catalog.DownloadAsync(evil).GetAwaiter().GetResult(); }
+ catch (StoreException e) { unsafeError = e.Message; }
+ yield return (unsafeError is not null, "a list entry with a path outside the repository is refused");
+
+ // Offline: the list falls back to the cache; an installed language needs no network.
+ server.Offline = true;
+ int before = server.Requests;
+ var offline = catalog.FetchAsync(refresh: true).GetAwaiter().GetResult();
+ yield return (offline.Languages.Count == 1 && server.Requests == before + 1, "offline, the list is the cached one");
+ yield return (installed.Read("xx") is { Table: not null } && server.Requests == before + 1, "an installed language is read with no network");
+ var noCache = new LanguageCatalog(new InstalledLanguages(Path.Combine(dir, "other")), Base, server);
+ bool threw = false;
+ try { noCache.FetchAsync(refresh: false).GetAwaiter().GetResult(); } catch (StoreException) { threw = true; }
+ yield return (threw && noCache.Cached() is null, "offline with no cached list: a StoreException to show in place, nothing thrown at the UI");
+ server.Offline = false;
+
+ // A list from a newer Nota format is not read.
+ bool newerFormat = false;
+ try { LanguageCatalog.Parse(Index(hash, 3, xx, formatVersion: 2)); } catch (StoreException) { newerFormat = true; }
+ yield return (newerFormat, "a list of a newer format asks to update Nota instead of guessing");
+
+ // Review of #485: a malformed entry is skipped, not thrown.
+ var withNull = Index(hash, 3, xx).Replace("\"languages\": [", "\"languages\": [ null, { \"code\": \"zz\" },");
+ var parsedNull = LanguageCatalog.Parse(withNull);
+ yield return (parsedNull.Languages.Count == 1 && parsedNull.Languages[0].Code == "xx", "null and incomplete entries in the list are skipped");
+
+ // A failed install puts the language back as it was (file and record).
+ var fileBefore = File.ReadAllText(Path.Combine(dir, "xx.json"));
+ var metaPath = Path.Combine(dir, "xx.meta.json");
+ var metaBefore = File.ReadAllText(metaPath);
+ var staging = installed.StagingPath("xx");
+ File.WriteAllText(staging, "{\"formatVersion\":2,\"code\":\"xx\",\"name\":\"New\",\"plural\":\"one_is_1\"}");
+ File.Delete(metaPath);
+ Directory.CreateDirectory(metaPath); // the record cannot be written
+ bool installFailed = false;
+ try { installed.InstallFrom(staging, "xx", new InstalledLanguageMeta(InstalledLanguageMeta.Repository, Version: 9)); }
+ catch (Exception) { installFailed = true; }
+ Directory.Delete(metaPath, true);
+ File.WriteAllText(metaPath, metaBefore);
+ yield return (installFailed && File.ReadAllText(Path.Combine(dir, "xx.json")) == fileBefore,
+ "a failed install leaves the installed file as it was");
+
+ // Loading the installed file itself through Load file… keeps it.
+ installed.InstallLocal(Path.Combine(dir, "xx.json"), "xx");
+ yield return (installed.Read("xx") is { Meta.IsLocal: true, Table: not null }, "loading the installed file as a local file keeps it readable");
+
+ // A file that cannot be read (permissions) is reported, not thrown.
+ if (!OperatingSystem.IsWindows())
+ {
+ var locked = Path.Combine(dir, "locked.json");
+ File.WriteAllBytes(locked, xx);
+ installed.InstallLocal(locked, "xx");
+ File.SetUnixFileMode(locked, UnixFileMode.None);
+ InstalledLanguage? lockedRead = null;
+ bool threwLocked = false;
+ try { lockedRead = installed.Read("xx"); } catch (Exception) { threwLocked = true; }
+ File.SetUnixFileMode(locked, UnixFileMode.UserRead | UnixFileMode.UserWrite);
+ yield return (!threwLocked && lockedRead is { Table: null, Error: not null } || !threwLocked && lockedRead is { Table: not null },
+ "a language file without read permission is reported, not thrown");
+ }
+
+ // Remove: the files go; the code is no longer installed.
+ installed.Remove("xx");
+ yield return (installed.Read("xx") is null && installed.List().Count == 0, "removing a language deletes it");
+
+ // Story 5: a stored language that is not installed is fetched and installed.
+ var settings = new Settings { Language = "xx" };
+ yield return (installed.Read(settings.Language) is null, "a stored language that is not installed reads as not installed");
+ var again = catalog.FetchAsync(refresh: true).GetAwaiter().GetResult().Languages.Single(l => l.Code == settings.Language);
+ yield return (catalog.DownloadAsync(again).GetAwaiter().GetResult().Table is not null, "…and the start-up download installs it");
+
+ // A translator's local file: read in place, problems listed, never replaced by a download.
+ var root = RepoRoot()!;
+ var brokenPath = Path.Combine(root, "tests/Nota.SmokeTest/Fixtures/Languages/xx-broken.json");
+ installed.InstallLocal(brokenPath, "xx");
+ var local = installed.Read("xx");
+ var (problems, _) = local?.Table?.ValidateAgainst(Loc.English) ?? (Array.Empty<TranslationProblem>(), 0);
+ yield return (local is { Meta.IsLocal: true, Table: not null } && local.Meta.Path == Path.GetFullPath(brokenPath) && problems.Count > 0,
+ $"a local file is read in place with its problems listed ({problems.Count})");
+ yield return (local is not null && !LanguageCatalog.UpdateAvailable(local, again with { Version = 99 }), "a local file is never offered an update");
+ Loc.ResetForTests();
+ Loc.Install(local?.Table, "xx");
+ yield return (Loc.English.TryGet("common.cancel", out var cancel) && Loc.T("common.cancel") == cancel.Other,
+ "entries a local file lacks or breaks show English");
+ Loc.ResetForTests();
+ Loc.Install(null, "en");
+
+ var missingLocal = Path.Combine(dir, "gone.json");
+ File.WriteAllBytes(missingLocal, xx);
+ installed.InstallLocal(missingLocal, "xx");
+ File.Delete(missingLocal);
+ yield return (installed.Read("xx") is { Table: null, Error: not null }, "a local file that is gone at start is reported, not thrown");
+ yield return (!InstalledLanguages.IsSafeCode("../x") && !InstalledLanguages.IsSafeCode("") && InstalledLanguages.IsSafeCode("pt-br"),
+ "a language code is checked before it becomes a file name");
+ }
+
+ private static string? RepoRoot()
+ {
+ for (var d = new DirectoryInfo(AppContext.BaseDirectory); d is not null; d = d.Parent)
+ if (Directory.Exists(Path.Combine(d.FullName, "src/managed")) && Directory.Exists(Path.Combine(d.FullName, "tests"))) return d.FullName;
+ return null;
+ }
+}
diff --git a/tests/Nota.SmokeTest/LanguageProjectTests.cs b/tests/Nota.SmokeTest/LanguageProjectTests.cs
index a7c3652e..627e1325 100644
--- a/tests/Nota.SmokeTest/LanguageProjectTests.cs
+++ b/tests/Nota.SmokeTest/LanguageProjectTests.cs
@@ -17,8 +17,9 @@ internal static class LanguageProjectTests
{
var root = RepoRootOrNull();
if (root is null) { yield return (false, "repo root located"); yield break; }
- var fr = TranslationTable.Parse(File.ReadAllText(Path.Combine(root, "src/managed/Nota.App/Languages/fr.json")), out var error);
- if (fr is null) { yield return (false, "fr.json parsed: " + error); yield break; }
+ // Nota ships English only (spec 077): the other language is the test fixture.
+ var fr = TranslationTable.Parse(File.ReadAllText(Path.Combine(root, "tests/Nota.SmokeTest/Fixtures/Languages/xx.json")), out var error);
+ if (fr is null) { yield return (false, "xx.json parsed: " + error); yield break; }
string tmp = Path.GetTempPath();
string wav = Path.Combine(tmp, "nota_smoke_lang_sine.wav");
diff --git a/tests/Nota.SmokeTest/Program.cs b/tests/Nota.SmokeTest/Program.cs
index 97e18f30..6f62b6dc 100644
--- a/tests/Nota.SmokeTest/Program.cs
+++ b/tests/Nota.SmokeTest/Program.cs
@@ -89,6 +89,8 @@ Console.WriteLine($"engine v{NotaEngine.Version}");
foreach (var (ok, label) in Nota.SmokeTest.DesignTokenCheck.RunLanguage()) Check(ok, label);
Console.WriteLine("-- localization: source --");
foreach (var (ok, label) in Nota.SmokeTest.DesignTokenCheck.RunLocalization()) Check(ok, label);
+ Console.WriteLine("-- localization: downloadable languages --");
+ foreach (var (ok, label) in Nota.SmokeTest.LanguageCatalogTests.Run()) Check(ok, label);
Console.WriteLine("-- design: labels --");
foreach (var (ok, label) in Nota.SmokeTest.DesignTokenCheck.RunLabels()) Check(ok, label);
Console.WriteLine("-- design: icons --");