diff --git a/wiki/de/de-Adminstration.md b/wiki/de/de-Adminstration.md
deleted file mode 100644
index e5a4b2527..000000000
--- a/wiki/de/de-Adminstration.md
+++ /dev/null
@@ -1,6 +0,0 @@
----
-layout: wiki
-title: "Adminstration"
-lang: "de"
-permalink: "/wiki/Adminstration"
----
diff --git a/wiki/de/de-Central-Servers.md b/wiki/de/de-Central-Servers.md
deleted file mode 100644
index ccdd94c92..000000000
--- a/wiki/de/de-Central-Servers.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-layout: wiki
-title: "Zentrale Server"
-lang: "de"
-permalink: "/wiki/Central-Servers"
----
-
-{% include breadcrumb.html root="Mehr" branch1="Server einrichten" branch1-url="Running-a-Server" %}
-
-# Öffentliche Zentrale Server
-
-Da jeder Zentralserver ein Limit von 150 Servern hat, musst du einen Zentralserver aussuchen, auf dem du deinen Server registrieren willst. Suche dir ein Genre aus, wenn du möchtest, dass eher Musiker eines bestimmten Genres auf deinem Server spielen (Musiker können deinen Server in ihrer Genre Liste sehen).
-
-Wenn du deinen Server im öffentlichen Modus startest, wird dir angezeigt, ob dein Server erfolgreich registriert werden konnte, oder nicht. Sollte das nicht der Fall sein du aber deinen Server nicht stoppst, wird er immer wieder versuchen sich zu registrieren, bis ein freier Slot verfügbar ist.
-
-## Headless Server
-
-Setze den zentralen (Genre-)Server in der Kommandozeile mit der Option `--centralserver` (`-e`) wie folgt:
-
-| Genre | Server address |
-|-----------|------------------|
-|**Alle Genres 1** |`anygenre1.jamulus.io:22124` |
-|**Alle Genres 2** |`anygenre2.jamulus.io:22224`|
-|**Alle Genres 3** |`anygenre3.jamulus.io:22624`|
-|**Genre Rock** |`rock.jamulus.io:22424`|
-|**Genre Jazz** |`jazz.jamulus.io:22324`|
-|**Genre Klassik/Folk** |`classical.jamulus.io:22524`|
-|**Genre Chor/Barbershop** |`choral.jamulus.io:22724`|
diff --git a/wiki/de/de-Choosing-a-Server-Type.md b/wiki/de/de-Choosing-a-Server-Type.md
deleted file mode 100644
index 121de69a3..000000000
--- a/wiki/de/de-Choosing-a-Server-Type.md
+++ /dev/null
@@ -1,63 +0,0 @@
----
-layout: wiki
-title: "Auswählen einer Serverart"
-lang: "de"
-permalink: "/wiki/Choosing-a-Server-Type"
----
-
-
-{% include breadcrumb.html root="Mehr" branch1="Server einrichten" branch1-url="Running-a-Server" %}
-
-# Serverarten
-
-Du kannst einen Server in einem von drei „Modi“ betreiben (entweder bei dir zu Hause oder auf einem externen Server):
-
-### 1. Öffentlich
-Dein Server wird auf einer [Zentralserver](Central-Servers) Liste, die alle Clients standardmäßig verwenden, gelistet. Musiker können dann deinen Server finden und sich mit ihm verbinden. Du musst keinen öffentlicher Server mehr aufsetzen, da viele andere Leute schon solche Server betreiben. Verbinde dich einfach mit einem Server mit geringer Latenz und beginne zu jammen.
-
-
-
-Diesen Modus kannst du aktivieren, indem du das Kontrollkästchen „Meinen Server registrieren...“ markierst und (optional) deine Serverinformationen eingibst.
-
-Beim Betrieb ohne Oberfläche („headless“) kannst du einen öffentlichen Server wie folgt konfigurieren:
-
-~~~
-Jamulus --nogui --server \
- --centralserver genreServer:port \
- --serverinfo "deinServerName;deineStadt;[country ID]"
-~~~
-
-**Achtung**: Du musst **keine** Portweiterleitung in deinem Router einrichten, wenn du einen öffentlichen Server betreibst.
-
-Siehe auch [Befehlszeilenoptionen](Command-Line-Options) für weitere Parameter, die du einstellen kannst.
-
-
-### 2. Privat
-Diese Serverart wird nicht in einer öffentlichen Serverliste aufgeführt. Du musst den Musikern deine Serveradresse geben, damit sie sich mit deinem Server verbinden können. Auf der Seite zum [Ausführen eines privaten Servers](Running-a-Private-Server) findest du Informationen darüber, was du tun musst, damit andere sich mit diesem Servertyp verbinden können.
-
-
-
-Dieser Modus wird aktiviert, indem du den Haken bei „Meinen Server registrieren...“ entfernst.
-
-Beim Betrieb ohne die Oberfläche („headless“) kannst du einen privaten Server wie folgt konfigurieren:
-
-```shell
-Jamulus --nogui --server
-```
-
-Siehe auch [Befehlszeilenoptionen](Command-Line-Options) für weitere Parameter, die du einstellen kannst.
-
-### 3. Zentral
-Die Konfiguration eines Servers als Zentralserver muss nur unter besonderen Umständen (z.B. für Onlineveranstaltungen oder Musikvereine) vorgenommen werden. Normalerweise kannst du diesen Typ ignorieren.
-
-Um einen Server, der an einem benutzerdefinierten, zentralen Server registriert ist zu finden, müssen Musiker die Adresse dieses Zentralservers im Einstellungsfeld „Benutzerdefinierte Zentralserveradresse“ ihres Clients eingeben. Sie sehen dann eine Liste der an diesem zentralen Server registrierten Server.
-
-Jeder Server kann sich an deinem zentralen Server registrieren, um in deiner Liste angezeigt zu werden. Dazu muss dann der anzumeldende Server mit dem Flag `--centralserver` und deiner IP/Domain gestartet werden.
-
-Der Server, der als zentraler Server konfiguriert werden soll, muss mit `--centralserver localhost` gestartet werden (d.h. der zentrale Server, an dem sich dieser Server anmeldet ist er selbst).
-
-#### Konfigurationsoptionen
-
-Wenn du steuern möchtest, welche Server sich an deinem zentralen Server registrieren können, kannst du eine Whitelist mit der Option `--listfilter` aktivieren. Weitere Informationen zu dieser und anderer Funktionen findest du auf der Seite [Kommandozeilen-Optionen](Command-Line-Options).
-
-Wenn du einen öffentlichen Zentralserver hinter einer NAT/Firewall in einem privaten Netzwerk betreibst, nutze die `--serverpublicip` Option um die öffentliche IP der Server, die auf dem Zentralserver aufgelistet werden. Du musst dieses Argument setzen, damit sich Clients aus dem öffentlichen Internet mit den Servern hinter der NAT verbinden können. Server die diese Funktion nutzen benötigen trotzdem Port Forwarding in deinem Router/Firewall.
diff --git a/wiki/de/de-Command-Line-Options.md b/wiki/de/de-Command-Line-Options.md
deleted file mode 100644
index 469465ff3..000000000
--- a/wiki/de/de-Command-Line-Options.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-layout: wiki
-title: "Kommandozeile"
-lang: "de"
-permalink: "/wiki/Command-Line-Options"
----
-
-# Kommandozeile
-
-Obwohl die gebräuchlichsten Funktionen in Jamulus über die GUI eingestellt werden können, lässt sich Jamulus auch über die Kommandozeile steuern. Wie das genau funktioniert, hängt von deinem Betriebssystem ab.
-
-Unter Windows kannst du die Aufnahmefunktion `-R` z.B. wie folgt aktivieren: Klicke mit der rechten Maustaste auf die Jamulus Verknüpfung, dann auf „Eigenschaften“ und füge die entsprechende Option (in diesem Beispiel `-R`) nach Jamulus.exe hinzu:
-
-```shell
-"C:\Program Files (x86)\Jamulus\Jamulus.exe" -s -R "C:\Pfad\zu\deinen\Aufnahmen"
-```
-
-Unter macOS, starte das Terminal und führe Jamulus mit den gewünschten Optionen wie folgt aus:
-
-```shell
-/Applications/Jamulus.app/Contents/MacOS/Jamulus -s -R "/Pfad/zu/deinen/Aufnahmen"
-```
-
-***
-
-Du kannst dir alle verfügbaren Optionen der aktuellen Jamulus Version über den Parameter `-h` anzeigen lassen.
-
-
-| Short | Long name | `[...]` bedeutet optionale Parameter | |
-|-------|-----------|----------------------------------|-|
-| `-c` |`--connect` | Automatische Verbindung zum angegebenen Server beim Start des Clients. Format `Adresse[:Port]` | (nur Client) |
-| `-d` |`--discononquit` | Trenne alle Verbindungen mit allen Clients beim Beenden des Servers | (nur Server) |
-| `-e` |`--centralserver` | Mache diesen Server öffentlich verfügbar und setzt sein Genre. Schau dir auch die Option `-o` an | (nur Server) [Siehe hier](Choosing-a-Server-Type#1-öffentlich). |
-| `-f` |`--listfilter` | Setze Server auf die Whitelist, Format `IP Adresse 1[;IP Adresse 2]` | (nur Zentralserver) [Siehe hier](Choosing-a-Server-Type#3-zentral). |
-| `-F` |`--fastupdate` | 64 samples frame size Modus. Reduziert Latenz wenn Clients mit der "Aktiviere kleine Netzwerkpuffer" Option verbunden sind. Benötigt schnelle CPU um Dropouts zu vermeiden, und mehr Bandbreite. | (nur Server) |
-| `-h,-?` |`--help` | Dieser Hilfetext | (Client und Server) |
-| `-i` |`--inifile` | Setze Pfad zur Einstellungsdatei (überschreibt den Standard) | (Client (immer) und Server (mit GUI)) |
-| `-j` |`--nojackconnect` | Deaktiviert automatische JACK Verbindung | (nur Client) |
-| `-l` |`--log` | Aktiviere Logging, gebe Pfad und Dateinamen an | (nur Server) |
-| `-m` |`--htmlstatus` | Aktiviere HTML Status Datei, gebe Pfad und Dateinamen an | (nur Server) |
-| `-M` |`--mutestream` | Starte Jamulus im stumm-geschalteten Modus | (nur Client) |
-| `-n` |`--nogui` | Deaktiviere GUI | (Client und Server) |
-| `-o` |`--serverinfo` | Serverstandort im Format:
`[Name];[Stadt];[Lokaler Wert]` (Siehe [Werte](https://doc.qt.io/qt-5/qlocale.html#Country-enum))| (nur öffentliche Server) |
-| `-p` |`--port` | Lokaler UDP Port. Standard ist 22124 | (nur Server) |
-| `-R` |`--recording` | Pfad zu einem beschreibbaren Pfad wo die aufgenommenen Dateien gespeichert werden (in Anführungszeichen wenn nötig). | (nur Server) Siehe Beschreibung im [Server Setup](Server-Win-Mac#recording). |
-| | `--norecord` | Starte mit deaktivierten Recorder | (nur Server) |
-| `-s` |`--server` | Starte in Server Modus | (nur Server) [Siehe Notiz](Choosing-a-Server-Type) |
-| `-t` |`--notranslation` | Keine Übersetzungen | (Client und Server) |
-| `-T` |`--multithreading` | Aktiviere Multithreading | (nur Server) |
-| `-u` |`--numchannels` | Maximale Anzahl an Nutzern. Standard ist 10, Maximum ist 150 | (nur Server) |
-| `-w` |`--welcomemessage` | Begrüßungsnachricht. Unterstützt HTML und inline CSS (in Anführungszeichen), oder Pfad zu einer Textdatei. | (nur Server) |
-| `-z` |`--startminimized` | Starte minimiert | (nur Server) |
-| |`--ctrlmidich` | MIDI Controller Kanal, Offset und fortlaufende CC Zahlen (Kanäle). Format `channel[;f*][;p*][;s*][;m*]` | (nur Client) Siehe [Tipps & Tricks](Tips-Tricks-More#Using-ctrlmidich-for-MIDI-controllers) |
-| |`--clientname` | Fenster Titel und JACK Client Name | (nur Client) |
-| |`--serverpublicip` | Setze die öffentliche IP des Servers | (nur Server) [Mehr Informationen](Choosing-a-Server-Type) |
diff --git a/wiki/de/de-Compiling.md b/wiki/de/de-Compiling.md
deleted file mode 100644
index 263b83f37..000000000
--- a/wiki/de/de-Compiling.md
+++ /dev/null
@@ -1,106 +0,0 @@
----
-layout: wiki
-title: "Kompilieren"
-lang: "de"
-permalink: "/wiki/Compiling"
----
-
-# Jamulus kompilieren
-
-## Linux
-
-Lies bitte die [Client Installationsseite](Installation-for-Linux) oder die Anleitung zum kompilieren eines [Headless-Servers](Server-Linux#running-a-headless-server) durch.
-
-## macOS
-Du musst Jamulus nicht für MacOS kompilieren, da wir offizielle Binärdateien zur Verfügung stellen. Aber wenn du es aber trotzdem machen willst, folge den unten stehenden Anweisungen.
-
-### Anforderungen
-
-1. Installiere XCode
-1. Installiere Qt wie folgt
-
-```shell
-brew install qt5
-brew link qt5 --force
-```
-
-### Projekt erstellen
-
-#### XCode-Projektdatei erzeugen
-```shell
-qmake -spec macx-xcode Jamulus.pro
-```
-
-#### Anzeigen von Build-Targets und Konfiguration in der Konsole
-```shell
-xcodebuild -list -project Jamulus.xcodeproj
-```
-sollte folgendes zeigen
-```shell
-Targets:
- Jamulus
- Qt Preprocess
-
-Build Configurations:
- Debug
- Release
-
-If no build configuration is specified and -scheme is not passed then "Release" is used.
-
-Schemes:
- Jamulus
-```
-
-#### Projekt kompilieren
-
-```shell
-xcodebuild build
-```
-
-Erstellt die Binärdatei in `./Release/Jamulus.app`
-
-
-## Windows
-Du brauchst Jamulus für Windows nicht zu kompilieren, da wir offizielle Binärdateien zur Verfügung stellen. Aber wenn du es aber trotzdem machen willst, folge den unten stehenden Anweisungen.
-
-### Benötigte Software
-* Ein Compiler wie [Visual Studio](https://visualstudio.microsoft.com) (Du brauchst nur [Build Tools 2017 oder 2019](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools&rel=16), aber du kannst auch die komplette IDE herunterladen und installieren [Visual Studio Download Seite](https://visualstudio.microsoft.com/downloads/))
-* [Qt](https://www.qt.io/download)
- * Nutze die kostenlose Open Source Version (Lizenziert unter der GPLv2-Lizenz für Open Source Entwicklung
- * Um herauszufinden, welche Qt-Version du brauchst, schau in der [qt-installer-windows.qs](https://github.com/jamulussoftware/jamulus/blob/master/windows/qt-installer-windows.qs) Datei nach: unter INSTALL_COMPONENTS siehst du z.B. `qt.qt5.[version]`, 5123 wäre Version 5.12.3.
- * Wähle die Komponenten während der Installation aus: Öffne den Qt-Abschnitt, suche nach der passenden Version, z.B., **Qt 5.12.3**, und wähle die Compiler components für deinen Compiler, z.B., `MSVC 2017 32-bit/64-bit` für Visual Studio 2019, aus
-* [ASIO SDK Dateien](https://new.steinberg.net/de/developers/)
-
-
-### Downloade den Jamulus Quellcode
-Lade den Quellcode z.B. mit git oder per [zip Download](https://github.com/jamulussoftware/jamulus/archive/master.zip) aus der [Jamulus Repo](https://github.com/jamulussoftware/jamulus) herunter.
-
-### Mit Installer kompilieren
-
-Die meisten Nutzer werden diese Methode nutzen wollen.
-
-1. Öffne PowerShell
-1. Navigiere in den `jamulus` Ordner
-1. Um unsignierte Scripts ausführen zu können, klicke mit der rechten Maustaste auf das `windows\deploy_windows.ps1` Skript, wähle Eigenschaften aus und erlaube dem Script, dass es ausgeführt werden darf. Du kannst auch `Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser` in PowerShell ausführen. (Du kannst das nach dem Ausführen des Scripts auch rückgängig machen. Mehr Informationen findest du auf der [Microsoft PowerShell Dokumentationsseite](https://docs.microsoft.com/de-de/powershell/module/microsoft.powershell.security/set-executionpolicy?view=powershell-7.1)).
-1. Setze die $QtCompile32 und $QtCompile64 Variablen.
-1. Führe das Script in PowerShell aus `.\windows\deploy_windows.ps1 C:\Qt\QtVersion`.
-1. Jetzt kannst du den Jamulus-Installer im `.\deploy` Ordner finden.
-
-### Nur kompilieren
-
-1. Erstelle einen Ordner im `\windows` Ordner mit dem Namen ASIOSDK2.
-1. Lade die [ASIOSDK](https://www.steinberg.net/asiosdk) herunter, öffne den Ordner auf der ersten Ebene in der .zip Datei und kopiere den Inhalt nach `[\pfad\zum\jamulus\code]\windows\ASIOSDK2`, sodass z.B. `[\pfad\zum\jamulus\code]\windows\ASIOSDK2\common` existiert.
-1. Öffne Jamulus.pro im Qt Creator, konfiguriere das Projekt mit dem Default kit, dann klicke auf Compile & run
-
-
-## Allgemeine Anmerkungen
-
-### Der "headless" build Flag
-
-Kompilieren mit dem `headless` Flag kann unter folgenden Umständen die Installation einiger abhängiger Pakete vermeiden, was etwas Speicherplatz spart und eventuell die Kompilierzeit beschleunigt:
-
-1. Wenn du Jamulus unter Gentoo Linux ausführen willst, sind die einzigen Pakete, die du für einen headless build brauchst, `qtcore`, `qtnetwork`, `qtconcurrent` und `qtxml` (sowohl für das Kompilieren als auch für den Betrieb des Servers).
-
-1. Wenn du Jamulus unter Ubuntu/Debian nutzt, benötigst du zwar alle Pakete um die Binärdatei zu **kompilieren**; um den fertigen headless Jamulus-Server **auszuführen**, brauchst du aber nur `libqt5core5a`, `libqt5network5`, `libqt5xml5` und eventuell `libqt5concurrent5`. Wenn du das Jamulus Binary auf eine andere Maschine (wie z.B. einen Raspberry Pi) kopierst, brauchst du auch nur diese Pakete.
-
-1. Wenn du einen GUI Client erstellen möchtest um ihn auf einem anderen Rechner auszuführen (z.B. einem Raspberry Pi), dann brauchst du nur die Abhängigkeiten des [headless Servers](Server-Linux#running-a-headless-server) (siehe Punkt oben) und zusätzlich die JACK-Soundbibliotheken.
diff --git a/wiki/de/de-Contribution.md b/wiki/de/de-Contribution.md
deleted file mode 100644
index eb185fc85..000000000
--- a/wiki/de/de-Contribution.md
+++ /dev/null
@@ -1,36 +0,0 @@
----
-layout: wiki
-title: "Mithelfen"
-lang: "de"
-permalink: "/wiki/Contribution"
----
-
-# Bei Jamulus mithelfen
-
-## Jamulus Software
-* Wenn du Code beisteuern willst oder einen Feature Request hast, [eröffne ein Issue auf GitHub](https://github.com/jamulussoftware/jamulus/issues/) (bevorzugt) oder [poste deine Idee im Forum](https://github.com/jamulussoftware/jamulus/discussions), damit wir deine Idee erst diskutieren können. Danach kannst du einen Pull Request eröffnen. Lies dir am Besten erst einmal das [manifesto for contributions](https://github.com/jamulussoftware/jamulus/discussions/915) von Volker Fischer (Hauptentwickler) und die [CONTRIBUTING Datei](https://github.com/jamulussoftware/jamulus/blob/master/CONTRIBUTING.md) durch.
-
-Mehr (englische) Informationen findest du im [Jamulus GitHub repo](https://github.com/corrados/jamulus).
-
-## Jamulus Website
-* Wenn du einen Fehler, oder eine veraltete Information (egal in welcher Sprache) findest, bitte öffne einen [GitHub Issue auf Englisch hier](https://github.com/jamulussoftware/jamuluswebsite/issues).
-* Wenn dir irgendeine Information fehlt oder ein Eintrag verbessert werden sollte, poste deine Idee (auf Englisch) [im Forum](https://github.com/jamulussoftware/jamulus/discussions), damit wir es mit dir diskutieren können.
-
-Schau dir die [CONTRIBUTING-Datei](https://github.com/jamulussoftware/jamuluswebsite/blob/changes/CONTRIBUTING.md) für die Website und das [Website GitHub repo](https://github.com/jamulussoftware/jamuluswebsite) für weitere Informationen an.
-
-
-### Ich kenne GitHub nicht. Was muss ich wissen?
-
-**Der folgende Inhalt bezieht sich nur auf die Dokumentation auf jamulus.io, nicht auf die Jamulus Software!**
-
-Wenn du dich mit Pull Requests, Commits, etc. nicht auskennst, eröffne einfach ein „Issue“. Wir werden uns dann um deine Änderungen kümmern. Wenn du die Änderungen selbst durchführen willst und einen Pull Request öffnest, folge dieser Anleitung:
-
-1. Forke das Repo (es gibt einen Fork-Button oben rechts auf der GitHub-Seite)
-2. Entscheide, in welchen Zweig („Branch“) du deine Änderungen commitest, also wo du deine Änderung anwenden willst. (Faustregel: alles, was eventuell übersetzt werden muss, sollte in den `changes` Branch gehen, Tippfehler sollten in den `release` Branch gehen; mehr Informationen findest du in der [CONTRIBUTING Datei](https://github.com/jamulussoftware/jamuluswebsite/blob/changes/CONTRIBUTING.md)). Erstelle auf deinem Fork einen neuen Branch aus dem Branch, den du gewählt hast
-3. Verändere was du verändern möchtest
-4. Wenn du die Änderungen lokal gemacht hast, pushe den neuen Branch in dein Repository
-5. Eröffne einen Pull Request, beschreibe kurz was du geändert hast und verlinke den Issue, das du geöffnet hast
-6. Warte auf ein Review und ein Merge
-
-**Hinweis (für git):** *Merge deine Veränderungen nicht in deinen lokalen `changes` Branch*, sondern halte ihn nur durch einen Pull vom entfernten Jamulus Website Repository synchron. Erstelle einen neuen Branch für deine vorgeschlagenen Änderungen.
-Wenn der `changes` Branch geändert wird, bevor du deine Veränderungen einreichst, halte den lokalen `changes` Branch durch Pull vom offiziellen Zweig synchron, führe den lokalen `changes` Zweig in deinen Arbeitszweig zusammen (merge), löse Konflikte auf, pushe deine Änderungen und erstelle den Pull Request.
diff --git a/wiki/de/de-Demos.md b/wiki/de/de-Demos.md
deleted file mode 100644
index c425ea515..000000000
--- a/wiki/de/de-Demos.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-layout: wiki
-title: "Jamulus Demos"
-lang: "de"
-permalink: "/wiki/Demos"
----
-
-
-# Jamulus Demos
-
-
-* [Dieses Video](https://youtu.be/c8838jS2g3U) dokumentiert eine Online Jam Session von [Volker Fischer](https://sourceforge.net/u/corrados/profile/) mit seiner Band _Jitterbuffer_
-
-* [Jamulus der Film - 28. März 2020](https://www.youtube.com/watch?v=2x-gwMmVK-s)
-
-* [Live-Konzert mit 8 Jazzmusikern](https://www.youtube.com/watch?v=MpSIYxZMHw8&t=3307s) zum Internationalen Jazz-Tag, 30. April 2020 ([mehr Details hier](https://sourceforge.net/p/llcon/discussion/533517/thread/070485619d/#6b71))
-
-* [Die IP Rockers LIVE on Jamulus](https://soundcloud.com/dematteoss/sets/the-ip-rockers-live-on-jamulus)
-
-* [Einführungsvideo, das den Aufbau mit akustischen Instrumenten zeigt](https://www.youtube.com/watch?v=lB4ZxDb9vnU) (nicht wirklich ein Beispiel)
-
-* [WorldJam](https://worldjam.vip/homepage.php): Jeden Samstagabend wird ein weltweiter Online-Jam über das Netz gestreamt
-
-
diff --git a/wiki/de/de-Running-a-Server.md b/wiki/de/de-Running-a-Server.md
deleted file mode 100644
index 6774c8119..000000000
--- a/wiki/de/de-Running-a-Server.md
+++ /dev/null
@@ -1,70 +0,0 @@
----
-layout: wiki
-title: "Einen Server betreiben"
-lang: "de"
-permalink: "/wiki/Running-a-Server"
----
-
-# Einen Jamulus Server betreiben
-
-## Muss ich einen Server betreiben, um Jamulus nutzen zu können?
-
-NEIN.
-{: .doubletextsize .red }
-
-
-Du kannst einfach einen Server von jemand anderem aus der Serverliste auswählen und dann loslegen.
-
-**Willst du nicht von anderen gestört werden?** Sobald du und deine Freunde mit einem öffentlichen Server verbunden sind, kannst du andere Musiker stummschalten, indem du nur die Musiker, mit denen du spielen willst mit der Solo Taste in deinem Mix aktivierst. Jeder Musiker, den du nicht auf „Solo” stellst, wird für dich stummgeschaltet und sieht in seinem Mix an deinem Regler, dass du ihn stummgeschaltet hast.
-
-## Das klingt zu einfach.
-
-Wenn du wirklich einen Server betreiben willst, ist es **sehr wichtig**, dass du verstehst, welchen Art von Server du betreiben willst.
-
-
-
-... dann komm hierher zurück.
-
-### Geschwindigkeit und Latenz
-
-**_Die Leistungsfähigkeit des Servers selbst (und des Netzwerks, in dem er sich befindet) ist NICHT der wichtigste Faktor für die Qualität einer Jamulus-Sitzung!_**
-
-Viele Leute denken, dass der Server Probleme macht, obwohl es eigentlich Probleme an den Clients sind. Vieles hängt von der [Hardware](Hardware-Setup), dem Netzwerk der Clients und davon, ob die Musiker sich an [Regel Nummer Eins](Getting-Started#schwierigkeiten-probleme-kannst-du-den-rhythmus-nicht-einhalten) halten ab. Es gibt daher keine Garantie dafür, dass ein eigener Server eine geringere Latenz oder eine bessere Gesamtleistung erzielt.
-
-Wenn du planst, regelmäßig mit den gleichen Leuten zu spielen, solltest du zunächst sicherzustellen, dass jedes Mitglied der Gruppe für die korrekte Verwendung von Jamulus eingerichtet ist. Finde dazu einen öffentlichen Server mit einer geringen Ping-Zeit für alle (20 ms oder weniger), lasse jeden eine Verbindung zu diesem Server herstellen und arbeite daran, alle individuellen Probleme zu beheben (stelle sicher, dass sie [Regel Nr. 1](Getting-Started#schwierigkeiten-probleme-kannst-du-den-rhythmus-nicht-einhalten) befolgen). Verwende die oben genannte Solotechnik, um zu verhindern, dass du unterbrochen wirst.
-
-Sobald alle Probleme mit den Musikern auf diese Weise gelöst sind, kannst du testen, ob du deinen eigenen Server entweder zu Hause oder auf einem Cloud-Host wie Amazon hosten willst, der evtl. besseren Latenzzeiten hat. Schau dir [diesen Leitfaden](https://www.facebook.com/notes/jamulus-worldjam/howto-idiots-guide-to-installing-or-upgrading-a-jamulus-server-on-amazon-aws-lig/818091045662521/) von [Simon Tomlinson](https://www.facebook.com/simon.james.tomlinson?eid=ARBQoY3KcZAtS3pGdLJuqvQTeRSOo4gHdQZT7nNzOt1oPMGgZ4_3GERe-rOyH5PxsSHVYYXjWwcqd71a) (_Facebook_) zur Verwendung von AWS Lightsail an.
-
-### Bandbreite – hast du genug?
-
-Ein typischer Jam mit 4 Personen könnte grob 200Kbit/s * 4 = 800Kbit/s (0,8 Mbit/s) Upload und Download benötigen. Eine typische Breitbandverbindung mit 10 Mbit/s Download und 1 Mbit/s Upload, **wird sehr wahrscheinlich ab dem fünften Musiker zu gering sein**, insbesondere wenn andere Musiker Einstellungen wählen, die viel Bandbreite benötigen. Hier kannst du testen, [wie viel Bandbreite dein Anschluss bietet](https://fast.com). [Mehr über die benötigte Bandbreite](Network-Requirements) bei verschiedenen Qualitätseinstellungen.
-
-### Allgemein
-
-- Nutze einen Cloud-Host für gute Pingzeiten, wenn du Probleme hast
-
-- Jeder Server sollte mindestens 1,6 GHz CPU-Frequenz und 1 GB RAM haben.
-
-- Wenn du einen Server betreibst, musst du möglicherweise alle Firewalls anpassen, die auf oder außerhalb deines Rechners oder Cloud Hosts laufen.
-
-- Wenn du einen **privaten Server von zu Hause** (aber keinen öffentlichen) betreiben willst, musst du [Port-Forwarding](Running-a-Private-Server) in deinem Router einrichten.
-
-- Jamulus unterstützt derzeit kein IPv6.
-
-
-## Alles Ok? Los geht's!
-
-
-
-Wenn du den Jamulus Server auf einem Raspberry Pi einrichten möchtest, sieh dir die [Anleitung für Raspberry Pi](/kb/2020/03/28/Server-Rpi.html) von fredsiva an.
-
-Serverbetreiber könnten [diese nützlichen Tools](https://github.com/jamulussoftware/jamulus/tree/master/tools) aus dem Jamulus-Repository hilfreich finden. Klone dazu das Git-Repo und rufe `git submodule update --init` auf).
-
-## Probleme?
-
-Auf in die [Server-FAQ zur Fehlerbehebung](Server-Troubleshooting)!
diff --git a/wiki/fr/fr-Central-Servers.md b/wiki/fr/fr-Central-Servers.md
deleted file mode 100644
index 59c4e9978..000000000
--- a/wiki/fr/fr-Central-Servers.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-layout: wiki
-title: "Serveurs centraux"
-lang: "fr"
-permalink: "/wiki/Central-Servers"
----
-
-# Inscription au serveur public
-
-À partir de mai 2020, afin de minimiser le problème de la saturation du serveur, nous avons créé plusieurs serveurs centraux basés sur le genre musical (chacun avec une limite actuelle de 150 serveurs).
-
-Lorsque vous démarrez un serveur public, vous verrez un message vous indiquant si votre serveur a été listé avec succès ou non. Si vous laissez votre serveur en fonction, il réessaiera de s'inscrire jusqu'à ce qu'un créneau soit libéré.
-
-## Serveurs sans IUG
-
-À partir de la version v3.5.4 de Jamulus, vous devrez définir le serveur central (genre) manuellement en utilisant l'option `--centralserver` (`-e`) comme suit :
-
-| Genre | Adresse du serveur |
-|------------------------------------------|-----------------------------------------|
-|**Tout genre** |`jamulusallgenres.fischvolk.de:22224` |
-|**Rock** |`jamulusrock.fischvolk.de:22424` |
-|**Jazz** |`jamulusjazz.fischvolk.de:22324` |
-|**Classique/Folk/Chœurs** |`jamulusclassical.fischvolk.de:22524` |
-|Default _(obsolète depuis Jamulus v3.5.4)_|`jamulus.fischvolk.de:22124` |
diff --git a/wiki/fr/fr-Choosing-a-Server-Type.md b/wiki/fr/fr-Choosing-a-Server-Type.md
deleted file mode 100644
index a8f8c5d16..000000000
--- a/wiki/fr/fr-Choosing-a-Server-Type.md
+++ /dev/null
@@ -1,60 +0,0 @@
----
-layout: wiki
-title: "Choisir un type de serveur"
-lang: "fr"
-permalink: "/wiki/Choosing-a-Server-Type"
----
-
-# Types de serveur
-
-Vous pouvez administrer votre serveur dans un de ces trois « modes » (soit à domicile, soit chez un hôte tiers) :
-
-### 1. Public
-Votre serveur sera listé dans la liste du [serveur central](Central-Servers) que les clients utilisent par défaut. Les musiciens pourront alors découvrir et se connecter à votre serveur. Il n'est pas forcément nécessaire de le faire fonctionner comme un serveur public puisque beaucoup d'autres personnes en administrent déjà. Il suffit de se connecter à un serveur à faible latence et de commencer à bœuffer.
-
-
-
-Ce mode est activé en cochant l'option "Rendre mon serveur public" et (éventuellement) en saisissant les informations relatives à votre serveur
-
-Quand vous utilisez un serveur sans IUG, la suite devrait permettre de configurer un serveur public :
-
-~~~
-Jamulus --nogui --server \
- --centralserver genreServer:port \
- --serverinfo "yourServerName;yourCity;[country ID]"
-~~~
-
-**Note** : il n'est **pas** nécéssaire de faire de la redirection de port ou de configurer votre routeur pour administrer un serveur public.
-
-Voir aussi les [options en ligne de commande](Command-Line-Options) pour d'autres paramètres que vous pouvez configurer.
-
-
-### 2. Privé
-
-Ce type de serveur ne sera pas listé sur un serveur central. Vous devez donner l'adresse de votre serveur aux musiciens pour qu'ils y connectent leurs clients. Voir [Administration d'un serveur privé](Running-a-Private-Server) pour savoir ce qu'il faut faire pour permettre à d'autres de s'y connecter.
-
-
-
-Ce mode est activé en décochant l'option « Rendre mon serveur public ».
-
-Lors d'une utilisation sans IUG, la suite devrait permettre de configurer un serveur privé :
-
-```shell
-Jamulus --nogui --server
-```
-
-Voir aussi les [options en ligne de commande](Command-Line-Options) pour d'autres paramètres que vous pouvez configurer.
-
-### 3. Central
-
-La configuration de votre serveur en tant que serveur central ne doit être effectuée que dans des circonstances particulières (par exemple, pour des événements en ligne ou des associations musicales). La plupart des gens peuvent ignorer ce type.
-
-Pour voir les serveurs listés sur un serveur central personnalisé, les musiciens doivent entrer l'adresse dans le champ « Serveur central personnalisé » des paramètres de leur client. Ils verront alors une liste générée par ce serveur central dans les paramètres de connexion.
-
-Les administrateurs de serveurs normaux peuvent également s'inscrire sur votre serveur central personnalisé afin que leurs serveurs apparaissent dans votre liste de serveurs en paramétrant le vôtre avec l'option `--centralserver`.
-
-Pour démarrer le serveur en tant que serveur central, il doit être configuré avec `--centralserver localhost` (c'est-à-dire, se spécifier comme le serveur central à interroger).
-
-Si vous voulez contrôler les serveurs qui peuvent s'inscrire sur votre serveur central, vous pouvez activer une liste blanche avec l'option en ligne de commande `--listfilter`. Voir les [options en ligne de commande](Command-Line-Options) pour davantage d'informations sur cette fonctionnalité.
-
-Voir aussi [les options en ligne de commande](Command-Line-Options) pour les autres paramètres que vous pouvez configurer.
diff --git a/wiki/fr/fr-Client-Troubleshooting.md b/wiki/fr/fr-Client-Troubleshooting.md
deleted file mode 100644
index ad0f2f33b..000000000
--- a/wiki/fr/fr-Client-Troubleshooting.md
+++ /dev/null
@@ -1,75 +0,0 @@
----
-layout: wiki
-title: "Dépannage du client"
-lang: "fr"
-permalink: "/wiki/Client-Troubleshooting"
----
-
-# Dépannage
-
-### Vous n'entendez aucun son ou les autres ne vous entendent pas ?
-Commencez par les choses simples : assurez-vous que votre instrument ou micro et votre casque soient branchés sur les bonnes prises. Assurez-vous qu'aucune autre application comme votre navigateur, votre logiciel de vidéoconférence, etc. n'utilise votre carte son. Vous devriez les éteindre lorsque vous utilisez Jamulus. Si tout semble correct et que le problème persiste, il est probable qu'il y ait un problème avec les paramètres de votre périphérique son. Cela dépendra de votre configuration particulière (plate-forme, matériel, logiciel et pilotes), il est donc préférable de demander conseil sur [les forums (en anglais)](https://github.com/jamulussoftware/jamulus/discussions/).
-
-**Utilisateurs de Windows (ASIO4All)** : si vous utilisez le pilote ASIO4All, consultez la [section de configuration ASIO4All](Installation-for-Windows#configuration-de-asio4all).
-
-### Tout sonne correctement, mais c'est difficile de rester en rythme
-
-**Dans la mesure du possible, N'ÉCOUTEZ PAS votre signal direct.** Assurez-vous que vous écoutez autant que possible le son de votre propre instrument/voix _revenant du serveur_. Ce signal vous permet de vous synchroniser avec vos partenaires de jeu, et sera le signal que les membres du groupe entendront également. Ainsi, en écoutant ce signal, vous serez synchronisés les uns avec les autres (en supposant que vous avez tous une latence raisonnablement faible). Notez que si un ou plusieurs musiciens ne suivent pas cette règle, ils ralentiront lorsqu'ils joueront ou chanteront.
-
-Vous pouvez testez si vous entendez correctement votre signal en procédant comme suit :
-
-1. Faites entrer votre signal audio dans votre ordinateur.
-1. Utilisez une application d'enregistrement audio (telle que [Audacity (en anglais)](https://www.audacityteam.org/)) sur votre ordinateur pour enregistrer cette entrée et vérifier qu'elle est correcte.
-1. Assurez-vous que si vous mettez en silence votre entrée audio dans l'application d'enregistrement, vous ne pouvez pas vous entendre.
-1. Fermez l'application d'enregistrement et lancez Jamulus. Vous ne devriez toujours pas vous entendre.
-1. Connectez-vous à un serveur et jouez quelque chose. Maintenant, vous devriez vous entendre avec le délai du serveur.
-
-**Si vous avez encore des problèmes**, essayez de demander sur le [forum du matériel (en anglais)](https://github.com/jamulussoftware/jamulus/discussions/). La manière exacte dont vous éviterez d'écouter votre signal direct dépendra de votre configuration individuelle : votre interface son, votre console de mixage, l'endroit où est branché votre casque, etc… Par exemple, certaines interfaces audio ont des boutons « monitor » (désactivez-les), ou des options similaires.
-
-Sachez que si l'écoute du signal du serveur vous assure d'être synchronisé avec les autres musiciens, vous pourriez également rencontrer des problèmes si votre latence globale (indiquée par le voyant lumineux « Délai » dans Jamulus) n'est pas verte ou au moins jaune la plupart du temps. Consultez le [manuel du logiciel](Software-Manual) pour comprendre comment ajuster votre configuration afin de vous aider dans cette tâche.
-
-### Vous n'arrivez pas à régler votre micro ?
-
-Lorsque vous utilisez un micro tout en jouant de votre instrument, vous pouvez utiliser un signal d'entrée audio stéréo dans vos réglages où un canal est connecté à l'instrument et l'autre canal est connecté au signal du micro. Sur le canal du micro, un effet de réverbération optionnel peut être appliqué.
-
-### Les LEDs de la mémoire tampon deviennent soudainement rouges, des pannes, des sautillements, des sons bizarres ?
-
-Le processeur de votre ordinateur peut avoir des problèmes. Essayez de ne rien avoir en concurrence avec Jamulus (comme Zoom Meetings ou les flux en direct de Facebook) sur votre machine. Ou au moins, quittez-les pendant que vous jouez. Empêchez les anti-virus d'effectuer des analyses ou les mises à jour logicielles, etc… Sachez que plus vous utilisez de réverbération dans Jamulus, plus le processeur sera utilisé.
-
-### Les temps de ping et de latence commencent bien, puis s'aggravent, causant des problèmes
-
-Cela peut indiquer que quelque chose d'autre entre en concurrence avec Jamulus sur votre réseau, alors assurez-vous que personne ne regarde de films en HD sur Netflix ou ne participe à des vidéoconférences Zoom pendant que vous jouez. Une solution plus permanente pour les utilisateurs à vocation technique, peut être trouvée en examinant [le problème du gonflement de la mémoire tampon (en anglais)](https://www.bufferbloat.net/projects/bloat/wiki/) sur leur routeur, et en vérifiant si vous pouvez mettre en œuvre la gestion intelligente des files d'attente (Smart Queue Management - SQM). [Plus de détails ici (en anglais)](https://www.bufferbloat.net/projects/bloat/wiki/What_can_I_do_about_Bufferbloat/).
-
-### Vous n'êtes pas à l'aise avec les canaux du logiciel, le routage audio, les taux d'échantillonnage, et autres ?
-
-Il est généralement beaucoup plus facile et plus fiable de disposer d'une [console de mixage](https://www.thomann.de/pics/bdb/191244/7355025_800.jpg) pour connecter votre matériel (instruments, micros, enregistreur, etc…) et d'envoyer ensuite un simple signal stéréo à votre interface son (assurez-vous cependant d'écouter le son résultant du serveur Jamulus via votre ordinateur !). La grande variété de combinaisons possibles de matériels, de logiciels et d'instruments signifie que la configuration de votre carte son pour qu'elle fonctionne avec votre configuration particulière peut se compliquer très rapidement.
-
-### Vous vous faites exploser les oreilles par quelqu'un qui se joint à votre bœuf avec du larsen ou du bruit ?
-
-Vous pouvez régler votre « Niveau de nouveau client » sur une valeur faible (par exemple 10), ou mettre les musiciens avec lesquels vous jouez en état « Solo » (dans le panneau de mixage sur le côté droit). De cette façon, soit les nouveaux venus seront très silencieux, soit vous ne les entendrez pas du tout.
-
-### Vous ne voyez pas le serveur que vous voulez rejoindre ?
-
-Vérifiez d'abord que vous avez le bon serveur de genre musical sélectionné dans votre fenêtre des paramètres de connexion. Mais il arrive parfois que des problèmes de réseau empêchent votre client d'afficher la liste de tous les serveurs disponibles. Si vous connaissez le nom du serveur que vous souhaitez rejoindre, vous pouvez [rechercher son adresse IP ici (en anglais)](https://explorer.jamulus.io/). Saisissez l'adresse IP dans le champ « Adresse du serveur » de la fenêtre « Paramètres de connexion » pour vous y connecter.
-
-### Vous ne voyez pas du tout la liste des serveurs ?
-
-Au Royaume-Uni (et éventuellement dans d'autres régions/routeurs), le réglage du modem internet par câble de Virgin Media peut poser problème. « Block Fragmented IP Packets » ne doit pas être cochée. Pour les autres routeurs/FAI (fournisseur d'accès internet), essayez également de désactiver le SPI (Stateful Packet Inspection) et si cela résout le problème, vous pouvez décider de le laisser désactivé ou non.
-
-Dans certains cas, il se peut que ce soit votre FAI qui bloque votre utilisation pour Jamulus. Voir la note sur la [page de dépannage du serveur](Server-Troubleshooting#personne-ne-peut-se-connecter-à-mon-serveur-mais-je-peux-my-connecter-localement) à propos de « Personne ne peut se connecter à mon serveur ».
-
-### Des problèmes pour utiliser Garageband (ou autre STAN) avec Jamulus ?
-
-Voir [ce forum de discussion (en anglais)](https://sourceforge.net/p/llcon/discussion/533517/thread/d3dd58eedc/#b994).
-
-### Vous utilisez un Mac et votre signal d'entrée n'est pas entendu ?
-
-(Avec nos remerciements à [Mark Anthony De Souza (en anglais)](https://www.facebook.com/groups/619274602254947/permalink/765122847670121/?comment_id=765525034296569) (_Facebook_))
-
-Peut-être n'avez-vous pas répondu « oui » à la question `« Jamulus souhaite accéder à votre micro »`. Pour y remédier :
-* Allez dans `Préférences Système` > `Sécurité et confidentialité` > onglet `Confidentialité`
-* Recherchez `Microphone` sur la gauche et assurez-vous que `Jamulus` soit activé dans la liste de droite.
-
-***
-
-Pour toute autre question, veuillez rechercher ou poster sur les [forums de discussion (en anglais)](https://github.com/jamulussoftware/jamulus/discussions/).
diff --git a/wiki/fr/fr-Command-Line-Options.md b/wiki/fr/fr-Command-Line-Options.md
deleted file mode 100644
index 371e3b962..000000000
--- a/wiki/fr/fr-Command-Line-Options.md
+++ /dev/null
@@ -1,54 +0,0 @@
----
-layout: wiki
-title: "Options en ligne de commande"
-lang: "fr"
-permalink: "/wiki/Command-Line-Options"
----
-
-# Options en ligne de commande
-
-Si les fonctions les plus courantes de Jamulus peuvent être configurées à l'aide de l'interface graphique, Jamulus peut également être contrôlé à l'aide de ces options lorsqu'il est démarré en ligne de commande. La manière exacte de procéder dépendra de votre système d'exploitation.
-
-Par exemple, sous Windows pour activer l'enregistrement avec l'option `-R` : cliquez-droit sur le raccourci Jamulus et choisissez `Propriétés` > `Cible`. Ajoutez les arguments nécessaires au fichier `Jamulus.exe` :
-
-```shell
-"C:\Program Files (x86)\Jamulus\Jamulus.exe" -s -R "C:\chemin\vers\vos\enregistrements de bœufs"
-```
-
-Pour macOS, lancez une fenêtre de terminal et exécutez Jamulus avec les options souhaitées comme ceci:
-
-```shell
-/Applications/Jamulus.app/Contents/MacOS/Jamulus -s -R "/chemin/vers/vos/enregistrements de bœufs"
-```
-
-***
-
-Vous pouvez voir toutes les options possibles prises en charge par votre version en démarrant Jamulus avec l'option `-h`.
-
-
-| Courte | Nom long | `[...]` signifie paramètre optionnel | |
-|--------|-----------|----------------------------------|-----------|
-| `-c` |`--connect` | Se connecter à une adresse de serveur donnée au démarrage, format `adresse[:port]`. | (client uniquement) |
-| `-d` |`--discononquit` | Déconnecter tous les clients à fermeture | (serveur uniquement) |
-| `-e` |`--centralserver` | Rend le serveur public et fixe son genre. Voir aussi `-o`| [Voir la liste](Central-Servers) |
-| `-f` |`--listfilter` | Serveurs de la liste blanche s'inscrivant sur la liste de serveur, format `adresse IP 1[;adresse IP 2]` | (serveur central uniquement) [Voir la note note](Choosing-a-Server-Type#3-central). |
-| `-F` |`--fastupdate` | Mode taille de trame de 64 échantillons. Réduit la latence si les clients se connectent avec l'option "Activer les petits tampons de réseau". Nécessite un processeur plus rapide pour éviter les décrochages, et plus de bande passante pour les clients actifs. | (serveur uniquement) |
-| `-h,-?` |`--help` | Ce texte d'aide | (client et serveur) |
-| `-i` |`--inifile` | Définir l'emplacement du fichier d'initialisation (écrase la valeur par défaut) | (client (toujours) et serveur (avec IUG)) |
-| `-j` |`--nojackconnect` | Désactiver les connexions JACK automatiques | (client uniquement) |
-| `-l` |`--log` | Activer la journalisation, définir le chemin et le nom du fichier | (serveur uniquement) |
-| `-m` |`--htmlstatus` | Activer le fichier de statut HTML, définir le chemin et le nom du fichier | (serveur uniquement) |
-| `-M` |`--mutestream` | Démarrer Jamulus en mode silence | (client uniquement) |
-| `-n` |`--nogui` | Désactiver l'IUG | (client et serveur) |
-| `-o` |`--serverinfo` | Détails sur l'emplacement du serveur dans le format :
`[nom];[ville];[valeur de la locale]` (voir [valeurs](https://doc.qt.io/qt-5/qlocale.html#Country-enum))| (serveurs publics uniquement) |
-| `-p` |`--port` | Numéro de port UDP local. 22124 par défaut | (serveur uniquement) |
-| `-R` |`--recording` | Inclure un chemin d'accès en écriture où les fichiers doivent être stockés (entre guillemets si nécessaire). | (serveur uniquement) Voir la description dans [paramétrage du serveur](Server-Win-Mac##enregistrement). |
-| | `--norecord` | Démarrer l'enregistreur avec l'enregistrement désactivé | (serveur uniquement) |
-| `-s` |`--server` | Démarrer en mode serveur | (serveur uniquement) [Voir note](Choosing-a-Server-Type) |
-| `-t` |`--notranslation` | Désactiver les traductions | (client et serveur) |
-| `-T` |`--multithreading` | Activer le multithreading | (serveur uniquement) |
-| `-u` |`--numchannels` | Nombre maximum d'utilisateurs. 10 par défaut, 150 au maximum | (serveur uniquement) |
-| `-w` |`--welcomemessage` | Accepte le formatage HTML et CSS en ligne (entre guillemets), ou définit le chemin d'accès vers un fichier texte. | (serveur uniquement) |
-| `-z` |`--startminimized` | Démarrage minimisé | (serveur uniquement) |
-| |`--ctrlmidich` | Canal de contrôle MIDI à écouter et décalage de numéro de contrôle, format : `channel[;offset]` | (client uniquement) voir [Trucs et astuces](Tips-Tricks-More#utilisation-de-ctrlmidich-pour-les-contrôleurs-midi) |
-| |`--clientname` | Titre de la fenêtre et nom du client JACK | (client uniquement) |
diff --git a/wiki/fr/fr-Compiling.md b/wiki/fr/fr-Compiling.md
deleted file mode 100644
index 85df800b0..000000000
--- a/wiki/fr/fr-Compiling.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-layout: wiki
-title: "Compilation"
-lang: "fr"
-permalink: "/wiki/Compiling"
----
-
-# Compiler Jamulus depuis le code source
-
-## Linux
-
-Veuillez vous référer à la [page d'installation du client](Installation-for-Linux) ou ces instructions si vous souhaitez [compiler un serveur sans IUG](Server-Linux#exécuter-un-serveur-sans-iug).
-
-## macOS
-Vous n'avez pas besoin de compiler Jamulus sous macOS puisque nous fournissons des binaires officiels, mais si vous souhaitez vraiment le faire, suivez les instructions ci-dessous.
-
-### Pré-requis
-
-1. Installez XCode
-1. Installez Qt comme suit
-
-```shell
-brew install qt5
-brew link qt5 --force
-```
-
-### Construire le projet
-
-#### Générer le fichier de projet XCode
-```shell
-qmake -spec macx-xcode Jamulus.pro
-```
-
-#### Afficher les cibles de construction et la configuration dans la console
-```shell
-xcodebuild -list -project Jamulus.xcodeproj
-```
-affichera
-```shell
-Targets:
- Jamulus
- Qt Preprocess
-
-Build Configurations:
- Debug
- Release
-
-If no build configuration is specified and -scheme is not passed then "Release" is used.
-
-Schemes:
- Jamulus
-```
-
-#### Construire le projet
-
-```shell
-xcodebuild build
-```
-
-Construira l'application et la rendra disponible dans `./Release/Jamulus.app`.
-
-
-## Windows
-Vous n'avez pas besoin de compiler Jamulus sous Windows puisque nous fournissons des binaires officiels, mais si vous souhaitez vraiment le faire, suivez les instructions ci-dessous.
-
-**Logiciels pré-requis** : [QT (en anglais)](https://www.qt.io/download), un compilateur comme Visual Studio, les fichiers de développement ASIO
-
-- Obtenez le code source de Jamulus, par ex. via git ou en téléchargeant l'archive zip depuis le dépôt de Jamulus.
-- Obtenez et copiez les fichiers de développement [ASIOSDK](https://www.steinberg.net/en/company/developers.html) dans le répertoire `[\chemin\vers\les\sources\jamulus]\windows` afin que, par ex., le répertoire `[\chemin\vers\les\sources\jamulus]\ASIOSDK2\common` existe.
-- ouvrez Jamulus.pro dans Qt Creator puis compilez et exécutez.
-
-
-## Notes générales
-
-### Le fanion de compilation "headless"
-
-La compilation avec le fanion `headless` signifie que vous pouvez éviter d'installer certains des paquets dépendants, économiser de l'espace disque et/ou accélérer votre temps de construction dans les circonstances suivantes :
-
-1. Si vous prévoyez d'utiliser Jamulus sous Gentoo Linux, les seuls paquets dont vous devriez avoir besoin pour une compilation headless sont `qtcore`, `qtnetwork`, `qtconcurrent` et `qtxml` (à la fois pour compiler et exécuter le serveur).
-
-1. Si vous utilisez Jamulus sur Ubuntu/Debian, vous aurez besoin de tous les paquets dépendants pour **compiler** le binaire, mais pour **executer** le serveur Jamulus sans IUG résultant, vous ne devriez avoir besoin que de `libqt5core5a`, `libqt5network5`, `libqt5xml5` et probablement `libqt5concurrent5`. Ceci peut être utile pour compiler/mettre à jour sur une machine pour exécuter le binaire sur une autre (un Raspberry Pi, par exemple).
-
-1. Notez que si vous voulez compiler un client avec IUG sur une machine et l'exécuter sur une autre (par ex. un Raspberry Pi), vous n'avez besoin que des dépendances listées pour un [serveur sans IUG](Server-Linux#exécuter-un-serveur-sans-iug) (voir le point ci-dessus), seulement _avec_ les bibliothèques JACK.
diff --git a/wiki/fr/fr-Contribution.md b/wiki/fr/fr-Contribution.md
deleted file mode 100644
index 0ab0e642c..000000000
--- a/wiki/fr/fr-Contribution.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-layout: wiki
-title: "Contribution"
-lang: "fr"
-permalink: "/wiki/Contribution"
----
-
-# Contribuer au projet Jamulus
-
-## Logiciel Jamulus
-* Si vous voulez contribuer au code, postez d'abord votre idée sur [le forum (en anglais)](https://github.com/jamulussoftware/jamulus/discussions) afin qu'elle puisse être discutée avant de faire un « pull request » (assurez-vous de lire le [manifeste de Volker pour les contributions](https://github.com/corrados/jamulus/issues/596 (en anglais)), du développeur principal)
-
-Voir le [dépôt de Jamulus GitHub (en anglais)](https://github.com/corrados/jamulus) pour plus d'informations.
-
-## Site web Jamulus
-
-* Si vous trouvez une erreur, une faute de frappe ou quelque chose de dépassé (dans n'importe quelle langue) sur le site web, vous pouvez [le signaler comme un problème ici (en anglais)](https://github.com/jamulussoftware/jamuluswebsite/issues).
-
-* Si vous pensez que certaines documentations ou informations manquent ou peuvent être améliorées, postez à ce propos sur le [forum de discussion pertinent (en anglais)](https://sourceforge.net/p/llcon/discussion/) afin que ça puisse d'abord être discuté.
-
-Les « pull request » pour le site web devraient ressembler à ceci :
-
-`[code de langue (par exemple fr)] {brève description de vos modifications}`
-
-Voir le [dépôt github du site web (en anglais)](https://github.com/jamulussoftware/jamuluswebsite) pour plus d'informations.
diff --git a/wiki/fr/fr-Demos.md b/wiki/fr/fr-Demos.md
deleted file mode 100644
index 3d33338dd..000000000
--- a/wiki/fr/fr-Demos.md
+++ /dev/null
@@ -1,25 +0,0 @@
----
-layout: wiki
-title: "Démos de Jamulus"
-lang: "fr"
-permalink: "/wiki/Demos"
----
-
-
-# Exemples d'utilisations de Jamulus
-
-**Sentez-vous libre d'ajouter les vôtres !**
-
-
-* [Cette vidéo (en anglais)](https://youtube.com/watch?v=c8838jS2g3U) documentée par [Volker Fischer (en anglais)](https://sourceforge.net/u/corrados/profile/) montre une séance d'improvisation en ligne avec son groupe _Jitterbuffer_
-
-* [Jamulus The Movie - 28th March 2020 (en anglais)](https://www.youtube.com/watch?v=2x-gwMmVK-s)
-
-* [Concert en direct sur Youtube avec 8 musiciens de jazz (en anglais)](https://www.youtube.com/watch?v=MpSIYxZMHw8&t=3307s) pour la Journée internationale du jazz, le 30 Avril 2020 ([plus de détails ici (en anglais)](https://sourceforge.net/p/llcon/discussion/533517/thread/070485619d/#6b71))
-
-* [Les IP Rockers en live sur Jamulus (en anglais)](https://soundcloud.com/dematteoss/sets/the-ip-rockers-live-on-jamulus)
-
-* [Vidéo d'introduction montrant l'installation avec des instruments acoustiques (en anglais)](https://www.youtube.com/watch?v=lB4ZxDb9vnU) (pas vraiment une démo)
-* [WorldJam (en anglais)](https://worldjam.vip/) Chaque samedi soir il y a une session « Jam » mondiale en ligne à travers internet.
-
-
diff --git a/wiki/fr/fr-Hardware-Setup.md b/wiki/fr/fr-Hardware-Setup.md
deleted file mode 100644
index 8b44d7183..000000000
--- a/wiki/fr/fr-Hardware-Setup.md
+++ /dev/null
@@ -1,79 +0,0 @@
----
-layout: wiki
-title: "Configuration du matériel"
-lang: "fr"
-permalink: "/wiki/Hardware-Setup"
----
-
-
-# Configuration du matériel
-
-## Infos générales
-
-**Pour que Jamulus soit stable, il est recommandé d'utiliser un PC avec une fréquence processeur d'au moins 1,5 GHz**
-
-**Utilisateurs de Windows :** vous devez installer un pilote ASIO. Une carte son avec un pilote ASIO natif est recommandée. Consultez la page [Installation sous Windows](Installation-for-Windows) pour plus d'informations.
-
-## Exemple de configuration
-
-L'installation du matériel se résume généralement en quatre points, bien que chaque configuration soit différente.
-
-1. Brancher l'interface audio à un port USB de votre ordinateur
-2. Fermer tous les programmes et démarrer Jamulus (n'oubliez pas de choisir les bonnes entrées dans les paramètres de Jamulus)
-3. Brancher votre instrument/microphone et votre casque
-4. Se connecter à un serveur Jamulus et s'amuser !
-
-
-## Windows : connexion de l'interface audio - ASIO4All
-
-Voici un exemple d'installation de client Windows avec un périphérique audio [Behringer U-CONTROL UCA202 (en anglais)](https://www.amazon.com/Behringer-U-Phono-UFO202-Audiophile-Interface/dp/B002GHBYZ0){: target="_blank" rel="noopener noreferrer"}.
-Les instructions suivantes devraient être similaires à celles pour d'autres périphériques audio.
-
-_**La méthode exacte pour connecter vos instruments différera évidement en fonction de votre matériel**_
-
-#### 1. Brancher l'interface audio à un port USB de votre ordinateur
-
-Par la suite, utilisez toujours le même port USB pour le périphérique audio.
-
-**Utilisateurs de Windows** : si ce n'est pas encore fait, téléchargez et installez le [pilote audio ASIO (ASIO4ALL) gratuit (en anglais)](https://www.asio4all.org){: target="_blank" rel="noopener noreferrer"}. Certaines personnes ont également indiqué avoir utilisé avec succès [ce pilote ASIO natif](http://www.behringerdownload.de/_software/BEHRINGER_2902_X64_2.8.40.zip){: target="_blank" rel="noopener noreferrer"} __actuellement non disponible__, bien qu'il ne figure plus sur les pages produits Behringer en avril 2020.
-
-#### 2. Démarrez Jamulus
-
-Configurez Jamulus pour qu'il utilise la configuration sonore correcte (voir [cet excellent guide (en anglais)](https://www.facebook.com/notes/jamulus-online-musicianssingers-jamming/idiots-guide-to-jamulus-app/510044532903831/) par [Simon Tomlinson](https://www.facebook.com/simon.james.tomlinson?eid=ARBQoY3KcZAtS3pGdLJuqvQTeRSOo4gHdQZT7nNzOt1oPMGgZ4_3GERe-rOyH5PxsSHVYYXjWwcqd71a) sur Facebook).
-
-Assurez vous d'avoir bien éteint le bouton de monitoring de votre Behringer U-CONTROL UCA202 (sinon vous entendrez à la fois le son original que vous envoyez au serveur Jamulus ainsi que le son revenant, et vous risquez d'avoir un retour).
-
-#### 3. Branchez votre instrument et votre casque
-
-Branchez votre instrument sur les fiches d'entrée du Behringer U-CONTROL UCA202. Branchez votre casque sur le Behringer U-CONTROL UCA202.
-
-#### 4. Connectez vous a un serveur Jamulus.
-
-Vous y êtes ! Amusez-vous !
-
-## Linux : connexion de l'interface audio avec QjackCtl
-
-Consultez la page du [guide d'installation du client](Installation-for-Linux#configurer-jack-avec-qjackctl).
-
-## Linux : noyaux à faible latence pour Jamulus
-Vous voudrez peut-être installer [Ubuntu Studio (en anglais)](https://ubuntustudio.org/){: target="_blank" rel="noopener noreferrer"}, elle propose une seconde option à votre menu de démarrage avec un noyau à faible latence. La clef d'un bœuf résussi est la « faible latence » entre les serveurs et les clients Jamulus connectés. Si le système Linux sous-jacent est démarré avec une faible latence, cela a un impact positif sur vos sessions Jamulus.
-
-## Points à noter à propos des entrées
-
-- Si vous voulez connecter deux sources ou plus (par exemple, voix + synthé + guitare), il est important de noter que Jamulus ne supporte pour le moment que deux canaux d'entrée (G/D). Donc le matériel utilisé doit produire un mixage stéréo en sortie vers Jamulus.
-- Les interfaces audio ressortent généralement un signal mixé sur leurs sorties analogiques, mais des signaux séparés (un par source) sur leurs sorties numériques (USB/Firewire/Thunderbolt).
-- Les consoles de mixage ne ressortent généralement qu'un signal mixé sur leur sorties analogiques.
-- Les consoles de mixage avec USB/Firewire/Thunderbolt ne ressortent généralement qu'un signal mixé sur leurs sorties **analogiques** ET uniquement des signaux séparés (pas de signal mixé) sur leurs sorties **numériques**.
-- Quelques consoles de mixage avec USB/Firewire/Thunderbolt ressortiront soit **seulement** un signal mixé sur la sortie **numérique** (consoles d'entrée de bas de gamme), soit AJOUTERONT aussi un signal mixé aux signaux séparés sur la sorties numériques.
-
-_(Merci à [pcar75 (en anglais)](https://github.com/pcar75) pour cette information)_
-
-## Autres exemples
-
-**Cette vidéo documente une [session de bœuf live (en anglais)](https://youtu.be/c8838jS2g3U).** J'utilise une carte audio Lexicon Omega USB sur un Mac Mini de 2009. Les membres de mon groupe utilisent tous sous Windows 10 et ont des cartes audio Behringer, par exemple la Behringer Xenyx 1204USB. Ma connexion internet a 10 Mb/s en descendant et 1 Mb/s en montant via DSL.
-
-**Un utilisateur de Jamulus [Andrew Evans (en anglais)](https://sourceforge.net/u/belvario/profile/)**: les membres du groupe sont tous dans la même ville (mais connectés avec deux FAI) et atteignent un temps de ping de 20 ms, le serveur fonctionnant sur une machine Windows dédiée séparée et un client sur un Macbook Pro. Les joueurs distants avec un Macbook Air. Tous en connexions filaires ethernet sur leurs routeurs/passerelles personnels. Nous avons utilisé la vidéo WhatsApp pour nous voir (avec l'audio en sourdine - c'est drôle de constater à quel point l'audio de Whatsapp est en retard par rapport à Jamulus !)
-
-## Des problèmes ?
-
-Veuillez consulter la [FAQ sur le dépannage client](Client-Troubleshooting).
diff --git a/wiki/fr/fr-Network-Requirements.md b/wiki/fr/fr-Network-Requirements.md
deleted file mode 100644
index b8534ebe3..000000000
--- a/wiki/fr/fr-Network-Requirements.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-layout: wiki
-title: "Qualité, délais et bande passante réseau"
-lang: "fr"
-permalink: "/wiki/Network-Requirements"
----
-
-# Pré-requis réseau
-
-## Bande passante audio
-
-Les paramètres audio ont un impact sur la bande passante requise du réseau. Le tableau ci-dessous résume les pré-requis réseau en ce qui concerne la configuration de :
-* canaux : stéréo/mono
-* qualité : haute/moyenne/basse
-* durée du tampon audio : 2,67ms, 5,33ms, 10,67ms, 21,33ms
-
-Avec les unités suivantes
-* ms : millisecondes
-* Kbps : Kilo-bits par seconde (rappel : 1Mbps = 1024Kbps, 1KByte = 8Kbits)
-* Mbps : Méga-bits par seconde
-
-| Canaux | Qualité | Bande passante (pour un tampon : 2,67ms) | Bande passante (pour un tampon : 5,33ms) | Bande passante (pour un tampon : 10,67ms) | Bande passante (pour un tampon : 21,33ms) |
-| --------- | ------- | -------- | -------- | -------- | -------- |
-| Stéréo | Haute | 894 Kbps | 657 Kbps | 541 Kbps | 483 Kbps |
-| Stéréo | Moyenne | 672 Kbps | 444 Kbps | 328 Kbps | 270 Kbps |
-| Stéréo | Basse | 606 Kbps | 372 Kbps | 256 Kbps | 198 Kbps |
-| Mono | Haute | 672 Kbps | 444 Kbps | 328 Kbps | 270 Kbps |
-| Mono | Moyenne | 594 Kbps | 366 Kbps | 250 Kbps | 192 Kbps |
-| Mono | Basse | 534 Kbps | 306 Kbps | 190 Kbps | 132 Kbps |
-
-## Bande passante réseau
-
-Il y a un débit montant (le musicien envoie au serveur) et un débit descendant (le serveur renvoie le mixage au musicien) 
-
-Notez également que le taux de transfert ADSL2 moyen est de 10 Mbits/seconde pour le débit descendant et de 1 Mbit/seconde pour le débit montant. Les performances réelles dépendent de la distance par rapport au fournisseur, qui peut [théoriquement varier de 24 Mb/s à 0,3 km à 1,5 Mb/s à 5,2 km](https://fr.wikipedia.org/wiki/ADSL#Estimation_du_d%C3%A9bit_maximal_r%C3%A9el_en_fonction_de_la_longueur_de_la_ligne) pour le taux de téléchargement.
diff --git a/wiki/fr/fr-Onboarding.md b/wiki/fr/fr-Onboarding.md
deleted file mode 100644
index 6b8377ad7..000000000
--- a/wiki/fr/fr-Onboarding.md
+++ /dev/null
@@ -1,68 +0,0 @@
----
-layout: wiki
-title: "Embarquement Jamulus"
-lang: "fr"
-permalink: "/wiki/Onboarding"
----
-# Embarquement Jamulus
-Voyons à quoi Jamulus ressemble et ce que vous devriez faire après avoir installé le logiciel.
-## Premier démarrage
-Avant de démarrer Jamulus
-1. Pour l'instant, **fermez toutes les autres applications**. Il est préférable de commencer avec aucune au début.
-2. **Branchez tout** (câble Ethernet, matériel audio, etc.)
-
-… pour *minimiser la charge* sur votre ordinateur et vous assurez qu'*aucune autre application* n'essaie d'utiliser votre carte son.
-
-### Configuration de votre matériel audio
-Si vous ne l'avez pas encore fait, branchez votre matériel (si nécessaire), ouvrez la fenetre de réglages des paramètres de Jamulus et en sélectionnez vos périphériques d'entrée/sortie.
-
-* Si vous avez besoin d'aide pour configurer ASIO4All sur Windows, consultez le [guide de configuration ASIO4All sur la page installation sous Windows](Installation-for-Windows#configuration-de-asio4all).
-* les utilisateurs macOS n'ont qu'à sélectionner leurs périphériques d'entrée/sortie dans la fenêtre de réglages des paramètres de Jamulus.
-
-Vous pouvez jeter un coup d'œil à la [configuration matérielle](Hardware-Setup) pour plus d'informations sur ce que vous devez faire avec votre équipement.
-
-### Fenêtre principale de Jamulus
-Lorsque vous lancerez Jamulus, vous verrez une fenêtre qui ressemble à ceci :
-
-
-
-### 1. Configurez un profil
-Pour que les autres sachent qui vous êtes, vous devriez configurer votre *profil*. Pour ce faire, cliquez sur « Vue » (barre du menu) > « Mon profil… ».
-Maintenant vous allez voir ceci :
-
-
-
-Remplissez au minimum votre « Pseudo/nom » pour renseigner votre nom et fermez la fenêtre.
-
-### 2. Connexion à un serveur
-Maintenant que vous avez configuré matériel et logiciel, vous pouvez utiliser le bouton « Se connecter » dans la fenêtre principale de Jamulus pour rejoindre un serveur. Une fenêtre s'ouvre alors :
-
-
-
-Cette fenêtre montre les *serveurs regroupés par genre*. Pour choisir un autre genre, sélectionnez-en un dans la liste en haut à gauche. Après avoir sélectionné un genre et un serveur, rejoignez le serveur en cliquant sur « Se connecter ». Si vous rencontrez des problèmes ici, ils sont très probablement dus à un équipement audio mal configuré ou à des problèmes de réseau. Consultez la [page de dépannage du client](Client-Troubleshooting).
-
-### Le premier bœuf
-Félicitations ! Vous pouvez maintenant commencer à bœuffer avec Jamulus. Les chariots que vous voyez sur la droite sont votre propre mixage personnel. Tout ce que vous modifiez ici agit sur ce que vous entendez, mais n'affectera pas les autres utilisateurs. Si vous déplacez un chariot vers le bas, cet utilisateur sera moins fort, si vous le déplacez vers le haut, cet utilisateur sera plus fort pour vous.
-
-
-
-Si vous ne voulez pas que les autres entendent votre audio, cliquez sur « Me silencer » (à gauche de votre mixage personnel) ce qui empêchera l'envoi de votre audio aux autres musiciens.
-
-Pendant que nous y sommes : « Paramètres » ouvre, évidement, la fenêtre des paramètres avec tous les paramètres audio que vous voudrez probablement modifier pour vos besoins.
-
-De plus amples informations sur l'utilisation de Jamulus peuvent être trouvées dans le [manuel du logiciel](Software-Manual).
-
-## Avancé
-
-
-## Aide et communauté
-Si vous avez besoin d'aide ou voulez contribuer au projet Jamulus, vous pouvez consulter les liens suivants :
-
-### Forums de discussion
-Pour de l'aide, du tchate, et des discussions générales à propos de Jamulus : jetez un œil aux [forums sur GitHub (en anglais)](https://github.com/jamulussoftware/jamulus/discussions).
-
-### Développement et contribution
-
-Si vous voulez contribuer au logiciel Jamulus, jetez un œil au [dépôt Github de Jamulus (en anglais)](https://github.com/jamulussoftware/jamulus/) et y lire le fichier de contribution.
-
-
diff --git a/wiki/fr/fr-Privacy-Statement.md b/wiki/fr/fr-Privacy-Statement.md
deleted file mode 100644
index f1986499a..000000000
--- a/wiki/fr/fr-Privacy-Statement.md
+++ /dev/null
@@ -1,35 +0,0 @@
----
-layout: wiki
-title: "Jamulus – Déclaration de confidentialité"
-lang: "fr"
-permalink: "/wiki/Privacy-Statement"
----
-
-# Déclaration de confidentialité
-
-## Page d'accueil
-
-Cette page d'accueil de jamulus.io s'efforce de ne pas collecter vos données personnelles. Si vous consultez le site jamulus.io, votre adresse IP est envoyée à GitHub Pages. De plus, comme nous avons placé un lien vers le logo de SourceForge dans le pied de chaque page, SourceForge peut également avoir votre adresse IP.
-Nous ne plaçons pas de cookies de suivi, cependant SourceForge pourrait le faire. Si vous ne le souhaitez pas, veuillez désactiver les cookies dans votre navigateur.
-
-## Logiciel Jamulus
-
-### Utilisation des informations de profil
-
-Lorsque vous vous connectez à un serveur Jamulus public ou privé, tout ce que vous mettez dans Mon profil (dans les Paramètres) sera visible par les autres personnes sur ce serveur pendant que vous y serez connecté. Le serveur ne stocke ni ne sauvegarde par ailleurs les informations relatives à votre profil et l'administrateur du serveur n'y a pas accès sauf s'il y est également connecté en tant que client.
-
-Lorsque vous vous connectez à un serveur public, votre profil est également accessible aux tiers à partir du serveur central auquel ce serveur est inscrit. Ceci peut être à des fins d'information sur l'état du réseau public Jamulus (par exemple, [ici (en anglais)](https://explorer.jamulus.io/)), mais ne se limite pas à ça. Les informations relatives au profil ne sont pas journalisées ou stockées par le serveur Jamulus auquel vous êtes connecté, ou par le serveur central Jamulus, mais peuvent être stockées ou traitées par des tiers.
-
-### Utilisation des adresses IP
-
-Lorsque vous vous connectez à un serveur public ou privé, l'administrateur du serveur peut voir votre adresse IP pendant que vous y êtes connecté. Si l'administrateur du serveur a activé la journalisation (qui est désactivée par défaut), votre adresse IP sera également journalisée et stockée dans le fichier journal du serveur.
-
-Les adresses IP de tous les serveurs publics enregistrés auprès du serveur central peuvent également être consultées par des tiers à des fins d'information ou autres (par exemple [ici (en anglais)](https://explorer.jamulus.io/)). Votre adresse IP publique n'est par ailleurs pas journalisée ou stockée par Jamulus, mais peut être stockée ou traitée par des tiers.
-
-### Enregistrements audio
-
-Vous verrez un avertissement si vous êtes connecté à un serveur Jamulus pendant que l'enregistrement du serveur est activé. Les enregistrements de chaque musicien sont stockés par le serveur séparément sous forme de fichiers .WAV et seul l'administrateur du serveur y a accès.
-
-### Tchate textuel
-
-Lorsque vous tapez un message dans la fenêtre de Tchate, les autres musiciens connectés peuvent le voir, mais les tchates ne sont pas stockés sur le serveur et ni l'administrateur du serveur ni un tiers n'y a accès.
diff --git a/wiki/fr/fr-Running-a-Private-Server.md b/wiki/fr/fr-Running-a-Private-Server.md
deleted file mode 100644
index 05eb0c32c..000000000
--- a/wiki/fr/fr-Running-a-Private-Server.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-layout: wiki
-title: "Administrer un serveur privé"
-lang: "fr"
-permalink: "/wiki/Running-a-Private-Server"
----
-
-# Administrer un serveur privé
-
-**_Assurez-vous d'avoir lu [Administration d’un serveur](Running-a-Server)_**
-
-Ce guide suppose que vous utiliserez un serveur privé sur votre réseau domestique, mais certains des points évoqués ici pourraient également s'appliquer à ceux qui fonctionnent sur des hôtes dans le nuage (par exemple Amazon EC2).
-
-Il est fortement recommandé de tester votre serveur en **mode public d'abord** afin de limiter les éventuels problèmes ultérieurs en mode privé.
-
-## Administration d'un serveur privé derrière un routeur de réseau domestique
-
-### Redirection de port
-
-Pour faire fonctionner un serveur privé, vous devez configurer la redirection de port sur votre routeur. _(Si vous êtes curieux de savoir pourquoi vous devez faire cela pour les serveurs privés mais pas pour les serveurs publics, voir [cette note de base de page](#notes-de-bas-de-page-pour-les-geeks))_.
-
-Normalement, les personnes extérieures à votre réseau domestique ne peuvent pas voir les choses à l'intérieur de celui-ci. Donc si vous voulez faire fonctionner un serveur Jamulus chez vous, vous devez ouvrir un trou dans votre routeur pour permettre aux clients Jamulus de s'y connecter.
-
-**Le port par défaut de la version actuelle de Jamulus est le port UDP (et non TCP) 22124.**
-
-La configuration exacte de la redirection de port diffère pour chaque routeur. Voici un exemple de paramètres de redirection de port dans un routeur Linksys :
-
-
-
-Pour obtenir de l'aide, voir : [portforward.com (en anglais)](https://portforward.com).
-
-Une fois votre routeur configuré, vous pouvez obtenir votre adresse IP externe (WAN), par exemple en [utilisant Google](https://www.google.com/search?q=what+is+my+ip). Donnez cette adresse à vos amis pour qu'ils puissent se connecter à votre serveur (_mais voir aussi la note sur le DNS dynamique ci-dessous_). Quant à vous, vous devez vous connecter à votre propre ordinateur à la place, puisque c'est votre ordinateur qui fait tourner le serveur. Par conséquent, **seulement vous** devez vous connecter à `127.0.0.1`.
-
-### Points à noter
-
-* Vous n'avez pas besoin d'ouvrir une plage de ports comme montré dans l'exemple ci-dessus tant que vous ne souhaitez démarrer qu'une seule instance du serveur Jamulus sur la même machine.
-
-* Si vous utilisez un port différent du port par défaut (22124), vous devez entrer le numéro de port après le nom du serveur ou l'adresse IP, séparés par un double-point dans le client Jamulus (par exemple jamulus.dyndns.org:22120).
-
-* Voir aussi cet excellent [guide pour la gestion d'un serveur privé (en anglais)](https://www.facebook.com/notes/jamulus-online-musicianssingers-jamming/how-to-create-a-private-server-for-band-rehearsals/508642543044030/) par [Simon Tomlinson (en anglais)](https://www.facebook.com/simon.james.tomlinson?eid=ARBQoY3KcZAtS3pGdLJuqvQTeRSOo4gHdQZT7nNzOt1oPMGgZ4_3GERe-rOyH5PxsSHVYYXjWwcqd71a) sur Facebook.
-
-## Le DNS dynamique et pourquoi vous en aurez probablement besoin
-
-La plupart des connexions internet domestiques changent d'adresse IP après un certain temps (heures, jours ou semaines). Pour faciliter la connexion, vous pouvez donc également mettre en place une adresse DNS dynamique. Vous pouvez le faire sur [la machine (en anglais)](https://www.online-tech-tips.com/computer-tips/ddns-dynamic-dns-service/) sur laquelle vous faites tourner le serveur Jamulus ou, de préférence, sur votre routeur [s'il le prend en charge (en anglais)](https://www.noip.com/support/knowledgebase/how-to-configure-ddns-in-router/).
-
-Notez aussi que votre routeur domestique peut également modifier l'adresse IP de la machine sur laquelle vous administrez votre serveur. Dans ce cas, vous pourriez devoir donner à cette machine une adresse IP statique dans la configuration DHCP du routeur, ou simplement faire un transfert de port vers toutes les adresses de votre réseau local (LAN).
-
-
-## Notes de bas de page pour les geeks
-
-L'une des nombreuses fonctionnalités de Jamulus qui le rendent orgasmiquement merveilleux est le fait que vous puissiez installer un serveur en quelques secondes. Mais pourquoi les serveurs publics n'ont-ils pas besoin d'une redirection de port pour cela ?
-
-Normalement, les pare-feu de traduction d'adresse réseau (NAT) empêchent les requêtes entrantes initiées depuis l'extérieur du réseau local. Le trafic entrant n'est possible que pour les paquets _reliés à une demande sortante_ (à proprement parler, les paquets « liés » et « établis » à une connexion sortante initiale). En mode public, lorsque votre serveur Jamulus se connecte à un serveur central, il initie bien sûr une connexion sortante. À partir de ce moment, le serveur central envoie des « pings » de connexion (établis/liés) (pas des pings ICMP) à votre serveur à intervalles réguliers pour maintenir le(s) port(s) NAT pertinent(s) ouvert(s) sur votre routeur/pare-feu.
-
-Toutefois, en mode privé, les clients doivent _initier_ des connexions dans le réseau du serveur. Les pare-feu NAT empêchent cela, et vous devez donc leur dire d'autoriser les requêtes de connexion entrantes sur le port Jamulus en utilisant la redirection de port.
diff --git a/wiki/fr/fr-Running-a-Server.md b/wiki/fr/fr-Running-a-Server.md
deleted file mode 100644
index 62a4b0c2c..000000000
--- a/wiki/fr/fr-Running-a-Server.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-layout: wiki
-title: "Administration d'un serveur"
-lang: "fr"
-permalink: "/wiki/Running-a-Server"
----
-
-# Administration d'un serveur
-
-## Ai-je besoin de mon propre serveur pour utiliser Jamulus ?
-
-NON.
-{: .doubletextsize .red }
-
-
-Il suffit juste de choisir le serveur de quelqu'un d'autre dans votre liste et d'y aller.
-
-**Vous ne voulez pas être dérangé par des inconnus ?** Une fois que vous et vos amis êtes connectés à un serveur public, appuyez sur les boutons « solo » des musiciens avec lesquels chacun de vous veut jouer. Chacun de ceux que vous ne mettez pas en solo, verra une icône « muet » sur votre canal. Et vous ne les entendrez pas.
-
-## Ça semble trop facile.
-
-Si vous voulez vraiment administrer votre propre serveur, il est **très important** que vous lisiez et compreniez quel type de serveur vous voulez faire fonctionner :
-
-
-
-… puis, revenez ici.
-
-### Vitesse et latence
-
-**_La capacité du serveur lui-même (et du réseau sur lequel il se trouve) n'est PAS le principal facteur déterminant de la qualité d'une session Jamulus !_**
-
-Beaucoup de gens attribuent au serveur des problèmes qui sont en fait des problèmes avec le _client_. Cela dépend beaucoup du [matériel](Hardware-Setup) des clients, des réseaux sur lesquels _ils_ se trouvent, et de leur respect de la [règle numéro un](Getting-Started#vous-avez-des-problèmes--vous-narrivez-pas-à-être-en-rythme-). Il n'y a donc aucune garantie que vous obtiendrez une latence plus faible ou de meilleures performances globales en ayant votre propre serveur.
-
-Si vous prévoyez de jouer régulièrement avec les mêmes personnes, **il vous est fortement conseillé** de vous assurer d'abord que chaque membre du groupe est configuré pour utiliser Jamulus correctement. Pour ce faire, trouvez un serveur public avec un temps de ping raisonnable pour chacun d'entre vous (20ms ou moins peut-être), connectez-vous tous à ce serveur et essayez de résoudre les problèmes individuels (en vérifiant qu'ils peuvent [suivre la règle numéro un](Getting-Started#vous-avez-des-problèmes--vous-narrivez-pas-à-être-en-rythme-) en particulier). Utilisez la technique solo ci-dessus pour éviter d'être interrompu si nécessaire.
-
-Une fois les problèmes avec les musiciens résolus de cette manière, vous pouvez alors envisager d'héberger votre propre serveur soit chez vous, soit sur un hôte dans le « Cloud » comme Amazon, ce qui pourrait entraîner une meilleure latence qu'un serveur fonctionnant à domicile. Par exemple, [voir ce guide (en anglais)](https://www.facebook.com/notes/jamulus-online-musicianssingers-jamming/howto-idiots-guide-to-installing-jamulus-server-on-amazon-aws-lightsail-ubuntu-i/507719749802976/) (_Facebook_) d'utilisation de AWS Lightsail par l'utilisateur de Jamulus [Simon Tomlinson (en anglais)](https://www.facebook.com/simon.james.tomlinson?eid=ARBQoY3KcZAtS3pGdLJuqvQTeRSOo4gHdQZT7nNzOt1oPMGgZ4_3GERe-rOyH5PxsSHVYYXjWwcqd71a) (_Facebook_).
-
-### Bande passante - en avez-vous suffisamment ?
-
-Un bœuf typique peut compter 4 personnes, pour lesquelles il faut 200Kbps x 4 = 800Kbs (0,8Mbps) en débit montant et descendant. Donc, si vous avez une connexion haut débit de 10Mbits descendant et de 1Mbits montant, **vous risquez de commencer à manquer de bande passante si un cinquième joueur vous rejoint**, surtout si d'autres musiciens choisissent des paramètres qui augmentent leur utilisation. Vous devriez peut-être [vérifier que vous avez un débit suffisant](https://fast.com) pour cela. [En savoir plus sur l'utilisation de la bande passante](Network-Requirements) selon différents paramètres de qualité.
-
-### En général
-
-- Envisagez d'utiliser un hébergeur dans le nuage pour obtenir de meilleurs temps de réponse si vous avez des problèmes
-
-- Tout serveur devrait avoir au minimum une fréquence de processeur d'1,6 GHz et 1 Go de RAM
-
-- Administrer un serveur pourrait nécessiter que vous ajustiez tout pare-feu fonctionnant sur ou en dehors de votre machine ou de l'hôte dans le nuage.
-
-- Administrer un **serveur privé à domicile** (mais pas un serveur public) nécessitera que vous [redirigiez un port](Running-a-Private-Server) sur votre routeur.
-
-- Jamulus ne prend actuellement pas en charge IPv6
-
-## Tout va bien ? Alors, c'est parti !
-
-
-Les administrateurs de serveur pourraient également être intéressés par le téléchargement de [cet ensemble d'outils utiles (en anglais)](https://github.com/corrados/jamulus/tree/master/tools) depuis le dépôt Jamulus (cloner le dépôt Git avec la commande `git submodule update --init`).
-
-## Vous avez des problèmes ? Des difficultés ?
-
-Voir la [FAQ sur le dépannage des serveurs](Server-Troubleshooting).
diff --git a/wiki/fr/fr-Server-Linux.md b/wiki/fr/fr-Server-Linux.md
deleted file mode 100644
index 36dc84a0b..000000000
--- a/wiki/fr/fr-Server-Linux.md
+++ /dev/null
@@ -1,216 +0,0 @@
----
-layout: wiki
-title: "Installation d'un serveur sous Linux"
-lang: "fr"
-permalink: "/wiki/Server-Linux"
----
-
-# Installation d'un serveur sous Linux
-
-**_Veuillez d'abord vous assurez d'avoir lu la [vue générale d'un serveur](Running-a-Server)_**
-
-
-## Exécuter un serveur avec IUG
-
-Si vous prévoyez d'exécuter le serveur sur votre poste de travail (et que vous avez déjà installé le client Jamulus), vous pouvez exécuter le serveur dans le [mode serveur](Choosing-a-Server-Type) choisi en exécutant Jamulus avec l'option `-s` comme suit :
-
-1. Ouvrir une fenêtre de terminal (`CTRL+ALT+t` sur Ubuntu et distributions associées).
-1. Partant du principe que Jamulus est dans `/usr/local/bin`, taper `Jamulus -s`
-
-Appuyez sur entrée et vous devriez voir la fenêtre de contrôle du serveur. Vous pouvez arrêter le serveur en fermant la fenêtre du serveur, ou en tapant CTRL+C dans le terminal.
-
-**Pour configurer le serveur**, veuillez vous référer aux [instructions pour Windows et Macintosh](Server-Win-Mac).
-
-Voir aussi les [options en ligne de commande](Command-Line-Options) pour les autres paramètres que vous pouvez configurer.
-
-## Exécuter un serveur sans IUG
-
-Le guide suivant permet d'utiliser Jamulus comme un serveur "pur" sur du **matériel sans audio** (par exemple sur un hôte tiers ou dans le nuage) et suppose des distributions Ubuntu/Debian utilisant systemd. Nous avons également des instructions pour [Raspberry Pi](Server-Rpi), qui est aussi très bien.
-
-* _L'utilisateur de Jamulus [Grigory (en anglais)](https://sourceforge.net/u/cidnurg/profile/), maintient une **[image Docker pour Jamulus (en anglais)](https://hub.docker.com/r/grundic/jamulus)** que vous pouvez utiliser._
-
-### Compilation des sources, création d'un utilisateur
-
-
-1. [Téléchargez les sources](Installation-for-Linux#obtenir-les-sources-de-jamulus), installez les [paquets dépendants](Installation-for-Linux#installation-des-dépendances) comme indiqué dans le guide d'installation du client Linux. À noter que **vous n'avez pas besoin d'installer le(s) paquet(s) JACK** pour un serveur sans IUG. _Si vous prévoyez d'éxecuter un serveur sans IUG sous Gentoo, ou que vous compilez sous Ubuntu pour une utilisation sur une autre machine Ubuntu, [voir les notes de bas de page](#que-fait-le-drapeau-de-compilation--headless--)._
-1. Compilez les sources en ignorant la bibliothèque audio JACK :
-
-~~~
-qmake "CONFIG+=nosound headless" Jamulus.pro
-make clean
-make
-~~~
-
-3. Déplacez le fichier binaire `Jamulus` résultant vers un emplacement permanent, ou utilisez la commande `sudo make install`. Vous pouvez désormais retirer le répertoire des sources si vous le désirez.
-
-**Le reste de ce guide suppose que vous utilisez `/usr/local/bin/Jamulus`**.
-
-4. Créez un utilisateur système sans privilège pour le fonctionnement du serveur (il s'exécutera en tant qu'utilisateur _jamulus_, groupe _nogroup_.) :
-
-`sudo adduser --system --no-create-home jamulus`
-
-### Création d'un script de démarrage
-
-Après avoir décidé dans quel mode vous souhaitez faire fonctionner votre serveur, utilisez systemd pour le démarrer.
-
-Créez un fichier d'unité systemd qui lancera le serveur au moment du démarrage (merci à [David Harrold (en anglais)](https://sourceforge.net/u/dkxl/profile/) pour cela).
-
-Le fichier d'unité applique une priorité élevée au processeur et à l'ordonnancement des E/S au traitement du serveur. Ceci est optionnel (et peut être ignoré sur certains hôtes).
-
-Notez aussi que les entrées de journalisation du serveur iront dans journalctl (utilisez [journald (en anglais)](https://www.digitalocean.com/community/tutorials/how-to-use-journalctl-to-view-and-manipulate-systemd-logs) pour les consulter).
-
-**Note** : le reste de ce guide suppose que vous êtes en mode "public" en utilisant l'option `-e` (`--centralserver`). Ceci précise dans quelle liste de genres musicaux votre serveur apparaîtra. Voir [la liste des genres disponibles ici](Central-Servers)).
-
-~~~
-[Unit]
-Description=Jamulus-Server
-After=network.target
-
-[Service]
-Type=simple
-User=jamulus
-Group=nogroup
-NoNewPrivileges=true
-ProtectSystem=true
-ProtectHome=true
-Nice=-20
-IOSchedulingClass=realtime
-IOSchedulingPriority=0
-
-#### Change this to set genre, location and other parameters.
-#### See [Command-Line-Options](Command-Line-Options) ####
-ExecStart=/usr/local/bin/Jamulus -s -n -e jamulus.fischvolk.de -o "yourServerName;yourCity;[country ID]"
-
-Restart=on-failure
-RestartSec=30
-StandardOutput=journal
-StandardError=inherit
-SyslogIdentifier=jamulus
-
-[Install]
-WantedBy=multi-user.target
-~~~
-
-Copier le fichier d'unité dans `/etc/systemd/system` et donnez lui les permissions :
-
-`sudo cp jamulus.service /etc/systemd/system/jamulus.service`
-
-`sudo chmod 644 /etc/systemd/system/jamulus.service`
-
-
-Testez que ça démarre bien :
-
-`sudo systemctl start jamulus`
-
-`sudo systemctl status jamulus`
-
-Vous devriez voir quelque chose comme ceci :
-
-~~~
-● jamulus.service
- Loaded: loaded (/lib/systemd/system/jamulus.service; enabled; vendor preset: enabled)
- Active: active (running) since Thu 2020-03-26 11:52:34 GMT; 4s ago
- Main PID: 1308 (Jamulus)
- Tasks: 2 (limit: 4915)
- CGroup: /system.slice/jamulus.service
- └─1308 /usr/local/bin/Jamulus -s -n -e jamulus.fischvolk.de -o yourServerName;yourCity;[country ID]
-
-Mar 26 11:52:34 oddjob systemd[1]: Started jamulus.service.
-Mar 26 11:52:35 oddjob jamulus[1308]: - server mode chosen
-Mar 26 11:52:35 oddjob jamulus[1308]: - no GUI mode chosen
-Mar 26 11:52:35 oddjob jamulus[1308]: - central server: jamulus.fischvolk.de
-Mar 26 11:52:35 oddjob jamulus[1308]: - server info: yourServerName;yourCity;[country ID]
-Mar 26 11:52:35 oddjob jamulus[1308]: - welcome message: Thanks for connecting!
-Mar 26 11:52:35 oddjob jamulus[1308]: *** Jamulus, Version [version]
-Mar 26 11:52:35 oddjob jamulus[1308]: *** Internet Jam Session Software
-Mar 26 11:52:35 oddjob jamulus[1308]: *** Under the GNU General Public License (GPL)
-~~~
-
-Si tout va bien, activez le service de lancement au démarrage avec :
-
-`sudo systemctl enable jamulus`
-
-Vous pouvez aussi contrôler Jamulus avec la commande `service`. Par exemple :
-
-`sudo service jamulus status`
-
-qui indique si Jamulus fonctionne bien, et affiche les quelques dernières lignes du journal (où vous verrez les connexions actives).
-Note : pressez `q` pour quitter le statut de service.
-
-### Mettre à jour votre installation vers une nouvelle version
-
-Téléchargez les nouvelles sources comme indiqué dans les [instructions ci-dessus](#compilation-des-sources-création-dun-utilisateur) et répétez la compilation à l'étape 2 comme pour une nouvelle installation. Arrêtez le serveur, copiez le fichier binaire Jamulus en écrasant l'ancien, et redémarrez le serveur.
-
-***
-
-Voir aussi les [options en ligne de commande](Command-Line-Options) pour les autres paramètres que vous pouvez configurer.
-
-## Notes de bas de page
-
-### Contrôler les enregistrements
-
-Lorsque vous utilisez la [fonction d'enregistrement](Server-Win-Mac#enregistrement) avec [l'option en ligne de commande](Command-Line-Options) `-R`, si le serveur reçoit un signal SIGUSR1 pendant un enregistrement, il commencera un nouvel enregistrement dans un nouveau répertoire. SIGUSR2 activera/désactivera l'enregistrement.
-
-Pour envoyer ces signaux en utilisant systemd, créez les deux fichiers `.service` suivants dans `/etc/systemd/system`, en les appelant par un nom approprié (par exemple `nouvelEnregistrement-Jamulus-server.service`).
-
-Pour activer ou désactiver l'enregistrement (en fonction de l'état courant) :
-
-~~~
-[Unit]
-Description=Toggle recording state of Jamulus server
-Requisite=Jamulus-Server
-
-[Service]
-Type=oneshot
-ExecStart=/bin/systemctl kill -s SIGUSR2 Jamulus-Server
-~~~
-
-Pour démarrer un nouvel enregistrement :
-
-~~~
-[Unit]
-Description=Start a new recording on Jamulus server
-Requisite=Jamulus-Server
-
-[Service]
-Type=oneshot
-ExecStart=/bin/systemctl kill -s SIGUSR1 Jamulus-Server
-~~~
-
-_Note : le nom du service Jamulus dans la ligne `ExecStart` doit être le même que le nom du fichier `.service` que vous avez créé lors de la configuration de systemd pour contrôler votre serveur Jamulus. Ainsi dans cet exemple, ça serait `Jamulus-Server.service`._
-
-Exécutez `sudo systemctl daemon-reload` pour les sauvegarder pour la première utilisation.
-
-Vous pouvez maintenant les exécuter avec la commande `service start`, par exemple :
-
-`sudo service jamulusTogglerec start` (en supposant que vous ayez nommé votre fichier d'unité `jamulusTogglerec.service`)
-
-Vous pouvez voir le résultat de ces commandes di vous lancez `service jamulus status`, ou en consultant les journaux.
-
-### Consulter les journaux
-
-Jamulus journalisera dans le fichier du système si vous avez laissé le paramètre `StandardOutput=journal` dans le fichier d'unité. Il est recommandé de se connecter au journal du système, car le système gère le fichier journal pour vous, sans avoir à revenir pour le purger plus tard ou à vous soucier du remplissement de votre disque.
-
-Pour lire le journal, utilisez `journalctl` (pressez Ctrl-C pour quitter). Par exemple, pour lire le fichier de journalisation du système, filtré sur le service Jamulus :
-
-`journalctl -u jamulus`
-
-Pour les entrées du jour :
-
-`journalctl -u jamulus`
-
-Pour la dernière heure :
-
-`journalctl -u jamulus --since "1 hour ago"`
-
-Filtrez le journal pour voir les messages de connexion de votre serveur Jamulus :
-
-`journalctl -u jamulus | grep connected`
-
-Suivre (affichez à l'écran) les messages du journal Jamulus en temps réel :
-
-`journalctl -f -u jamulus`
-
-### Que fait le drapeau de compilation « headless » ?
-
-Bien que cela ne soit pas strictement nécessaire, nous recommandons d'utiliser le drapeau `headless` pour accélérer le processus de construction. Les utilisateurs de Gentoo devraient également éviter d'installer certaines dépendances en conséquence. [Plus d'informations ici](Compiling#le-fanion-de-compilation-headless).
diff --git a/wiki/fr/fr-Server-Troubleshooting.md b/wiki/fr/fr-Server-Troubleshooting.md
deleted file mode 100644
index cfb0e6499..000000000
--- a/wiki/fr/fr-Server-Troubleshooting.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-layout: wiki
-title: "Dépannage serveur"
-lang: "fr"
-permalink: "/wiki/Server-Troubleshooting"
----
-
-# Troubleshooting
-
-## Serveurs - public
-
-### Pourquoi mon serveur n'apparaît pas dans la liste ? Pourquoi n'y est-il pas inscrit ?
-
-Si votre serveur est bien inscrit (vous pouvez [vérifier ici (en anglais)](http://jamulus.softins.co.uk/)) et que vous ou vos amis ne pouvez pas voir votre serveur, vous pourriez avoir besoin d'attendre, ou démarrer votre client avec l'option `--showallservers` et essayer de vous connecter à partir de là ([voir cette page](Command-Line-Options) à propos de la façon de démarrer votre client avec une option de configuration).
-
-Si vous voyez un message indiquant que le serveur est complet, veuillez [voir cette note](Central-Servers) à propos des serveurs centraux.
-
-Vous pouvez vous assurez que votre serveur est listé dans le genre pertinent en [le vérifiant ici (en anglais)](http://jamulus.softins.co.uk/).
-
-## Serveurs - privés
-
-### J'exécute mon client sur la même machine/réseau que mon serveur, mais je ne peux pas m'y connecter
-
-Connectez votre client à l'adresse `127.0.0.1` (ou `localhost` si cela fonctionne pour vous). Si vous utilisez le client sur une machine différente du serveur mais sur le même réseau, alors connectez-vous à l'adresse du serveur sur le _réseau local_. Ne vous connectez pas via l'adresse publique (WAN) du serveur.
-
-### Quelle adresse dois-je communiquer aux personnes pour qu'elles puissent se connecter à mon serveur ?
-
-Il doit s'agir de votre adresse IP **publique** (à trouver auprès de [Google](https://www.google.com/search?q=whatsmyip)). Connectez votre **propre** client Jamulus à l'adresse IP **locale** de votre serveur (127.0.0.1 s'il est sur la même machine que votre client). Notez que votre adresse IP publique peut changer : voir la note sur le « DNS dynamique » dans [ce guide](Running-a-Private-Server).
-
-### Quels sont les numéros de port que je peux utiliser ?
-
-Conservez les ports UDP par défaut. Le port par défaut réel est documenté dans les [options en ligne de commande](Command-Line-Options). Au moment de la rédaction de cette documentation, le numéro de port est **22124**.
-
-### Un serveur privé est-il un serveur direct sans contact avec le serveur central Jamulus ?
-
-Oui. Veuillez consulter [types de serveur](Choosing-a-Server-Type).
-
-### Puis-je convertir mon serveur privé en serveur public ?
-
-Oui, il suffit de cocher la case « Rendre mon serveur public » dans la fenêtre du serveur et de remplir les détails. Souvenez-vous que vous n'avez pas non plus besoin de faire une redirection de port si vous avez un serveur public.
-
-### **_Serveur sans IUG sou Linux_** : j'ai créé un serveur mais il est en train de rejoindre le serveur central et je ne veux pas qu'il le fasse.
-
-Pour activer un serveur privé, n'utilisez pas l'option `--centralserver` (`-e`) lorsque vous lancez la ligne de commande de votre serveur.
-
-### Personne ne peut se connecter à mon serveur, mais je peux m'y connecter localement
-
-Certains FAI utilisent des techniques telles que « [Address plus Port (A+P) (en anglais)](https://en.wikipedia.org/wiki/Address_plus_Port) » ou [NAT de classe transporteur (CGN)](https://fr.wikipedia.org/wiki/Carrier-grade_NAT) pour conserver l'espace d'adressage. Cela rend impossible l'hébergement de services comme Jamulus à domicile (et peut provoquer le fait que vous ne puissiez pas non plus voir les listes de serveurs sur votre client, ou qu'il vous manque [certains serveurs spécifiques (en anglais)](https://sourceforge.net/p/llcon/discussion/server/thread/f72b293af0/)).
-
-Pour détecter si le CGN est en cause, aller à l'écran de configuration de votre routeur (typiquement, 192.168.X.X) et regardez la page d'état du WAN. Si l'adresse IPv4 listée ne correspond pas à l'adresse que vous voyez [ici (en anglais)](https://ifconfig.me), alors cela signifie que le CGN pourrait être activé. Ou si vous rencontrez des problèmes tels que l'impossibilité de [se connecter à des serveurs ou une liste de serveurs vide (en anglais)](https://sourceforge.net/p/llcon/discussion/533517/thread/b3eea395c4/), cela pourrait également être un indicateur que votre FAI est également à l'origine du problème.
-
-Pour résoudre le problème : si vous utilisez un serveur public, essayez [la redirection de port](Running-a-Private-Server#redirection-de-port). Si vous utilisez un serveur privé et que vous faites déjà de la redirection de port, contactez le support de votre FAI et demandez leur de vous retirer du CGN et de vous attribuer une véritable adresse IP WAN en expliquant que vous voulez héberger un serveur. Si le CGN n'est pas la cause du problème, vous devrez peut-être demander à votre FAI de vous donner une adresse IP WAN (ou une fixe pour éviter d'utiliser DDNS, si possible). Si tout le reste échoue, envisager l'hébergement sur une plate-forme dans le nuage (certains fournisseurs proposent des périodes d'essai gratuites).
diff --git a/wiki/fr/fr-Server-Win-Mac.md b/wiki/fr/fr-Server-Win-Mac.md
deleted file mode 100644
index 8f5bffe52..000000000
--- a/wiki/fr/fr-Server-Win-Mac.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-layout: wiki
-title: "Installation du serveur – Windows et macOS"
-lang: "fr"
-permalink: "/wiki/Server-Win-Mac"
----
-
-# Installation sous Windows et macOS
-_(Note: les copies d'écran ont été faite avec l'interface en anglais, les termes utilisés par la suite dans ce document correspondent aux termes employés dans l'interface graphique du logiciel en français.)_
-
-**_Assurez-vous d'avoir lu la page d'[aperçu d'un serveur](Running-a-Server)_**
-
-* **Utilisateurs de Windows** : démarrez le serveur en utilisant l'entrée « Jamulus Server » du menu démarrer de Windows.
-
-* **Utilisateurs de macOS** : double-cliquez sur l'icône « Jamulus server » dans Applications (en supposant que vous y avez placé les fichiers de l'installation conformément conformément à [ces instructions](Installation-for-Macintosh)).
-
-* **Utilisateurs de Linux** : veuillez vous référer aux [instructions serveur avec IUG](Server-Linux#exécuter-un-serveur-avec-iug).
-
-
-
-### Configuration d'un serveur public
-
-1. En cochant l'option « Rendre mon serveur public », vous devriez voir un message de confirmation indiquant si votre serveur s'est inscrit avec succès.
-
-1. Renseignez le nom, la ville et le pays, pour que les autres utilisateurs puissent vous identifier facilement.
-
-1. Spécifiez un genre musical si vous le souhaitez. Votre serveur apparaitra alors dans la liste des serveurs pertinents pour les clients (voir davantage de [détails à propos des serveurs centraux](Central-Servers))
-
-_Le message de bienvenue du tchate apparaît pour tous les utilisateurs lorsqu'ils rejoignent le serveur (la fenêtre de tchate s'ouvrira automatiquement pour eux)._
-
-### Configuration d'un serveur privé
-
-Si vous ne cochez pas « Rendre mon serveur public », vous obtiendrez un serveur privé et vous devrez [lire ces instructions](Running-a-Private-Server).
-
-_Si vous souhaitez **exécuter un client sur la même machine**, vous devriez **connecter le client à l'adresse `127.0.0.1`** pour une meilleure performance. (De même, si vous souhaitez connecter un client sur une autre machine de votre réseau local, utilisez l'adresse IP du réseau local du serveur)._
-
-### Enregistrement
-
-Activez l'enregistrement du serveur en paramétrant d'abord le répertoire d'enregistrement dans l'onglet Options. L'enregistrement commence dès que la première personne se connecte au serveur et s'arrête lorsque la dernière personne le quitte. Utilisez le bouton « Nouvel enregistrement » pour créer un nouveau sous-répertoire dans lequel les enregistrements seront stockés. Notez que les enregistrements sont sauvegardés par piste au format `.lof` d'[Audacity] (en anglais)(https://www.audacityteam.org/) et `.rpp` de [REAPER](https://fr.wikipedia.org/wiki/Reaper_(logiciel)). Ouvrez les fichiers respectifs pour les écouter dans ces applications.
-
-_Note : lorsque votre serveur enregistre, les clients afficheront un message indiquant que l'enregistrement est en cours._
-
-Pour les serveurs sans IUG : vous pouvez contrôler la fonction d'enregistrement en [suivant ces instructions](Server-Linux#contrôler-les-enregistrements).
-
-### Autres options
-
-
-
-**Utilisateurs Windows** : si vous souhaitez que le serveur se lance automatiquement au démarrage du système, cochez l'option correspondante.
-
-(Laissez le champ « Adresse personnalisée du serveur central » vide, sauf si vous devez inscrire votre serveur sur un [serveur central privé](Choosing-a-Server-Type#3-central))
-
-***
-
-Consulter également les [options en ligne de commande](Command-Line-Options) pour d'autres paramètres que vous pouvez configurer.
diff --git a/wiki/fr/fr-Software-Manual.md b/wiki/fr/fr-Software-Manual.md
deleted file mode 100644
index 8f2308991..000000000
--- a/wiki/fr/fr-Software-Manual.md
+++ /dev/null
@@ -1,226 +0,0 @@
----
-layout: wiki
-title: "Manuel du logiciel"
-lang: "fr"
-permalink: "/wiki/Software-Manual"
----
-Aide Jamulus (manuel du logiciel)
-=================================
-
-Fenêtre principale
-------------------
-
-
-
-### LEDs d'état
-
-La LED du status de **délai** indique l'état actuel du délai audio :
-
-
-
-* **Vert** - Le délai est parfait pour une session de bœuf
-
-
-
-* **Jaune** - Une session est toujours possible mais elle peut être plus difficile à jouer
-
-
-
-* **Rouge** - Le délai est trop important pour bœuffer
-
-La LED d'état de **Tampons** indique l'état actuel de l'audio/du streaming. Si le voyant est **rouge**, le flux audio est interrompu. Cela peut être dû à l'un des problèmes suivants :
-
-- Le tampon de gigue[^1] réseau n'est pas assez grand pour la gigue actuelle de l'interface réseau/audio.
-- Le délai du tampon de la carte son (taille du tampon) est trop faible (voir la fenêtre des paramètres).
-- Le débit montant ou descendant est trop élevé pour votre bande passante internet.
-- Le processeur du client ou du serveur est à 100 %.
-
-### Niveau d'entrée
-
-
-
-Ceci indique le niveau des deux canaux stéréo pour votre entrée audio.
-Veillez à ne pas écrêter le signal d'entrée pour éviter une distorsion du signal audio (les LEDs indiquent l'écrêtage lorsqu'il se produit).
-
-### Bouton Tchate
-
-
-
-Le texte de tchate saisi dans cette fenêtre est envoyé à tous les clients connectés.
-Si un nouveau message de tchate arrive et que la fenêtre du tchate n'est pas encore ouverte, elle sera ouverte automatiquement pour tous les clients.
-
-### Fenêtre de profil
-
-
-
-Dans le menu Vue, sélectionnez Mon profil… pour définir votre pseudo/nom qui s'affiche sous votre chariot dans la console de mixage audio du serveur. Si un instrument et/ou un pays est défini, les icônes correspondant à ces choix seront également affichées sous votre chariot. Le paramètre de compétence modifie la couleur de fond de l'étiquette du chariot et l'entrée de la ville apparaît dans l'info-bulle à son survol (voir la capture d'écran ci-dessous).
-
-
-
-
-### Bouton de connexion/déconnexion
-
-Ouvre une boîte de dialogue dans laquelle vous pouvez sélectionner un serveur auquel vous connecter. Si vous êtes connecté, appuyer sur ce bouton mettra fin à la session.
-
-
-
-La fenêtre de configuration de la connexion affiche une liste des serveurs disponibles avec le nombre d'occupants et le nombre maximum possible. Les administrateurs de serveur peuvent optionellement référencer leurs serveurs par genre musical. Utilisez le menu déroulant Liste pour sélectionner un genre, cliquez sur le serveur que vous souhaitez rejoindre et appuyez sur le bouton Se connecter pour vous y connecter. Vous pouvez également double-cliquer sur le nom du serveur. Les serveurs permanents (ceux qui ont été listés pendant plus de 24 heures) sont indiqués en gras.
-
-Vous pouvez filtrer la liste par nom de serveur ou par emplacement. Pour ne répertorier que les serveurs occupés, entrez un caractère « # ».
-
-Si vous connaissez l'adresse IP ou l'URL d'un serveur, vous pouvez vous y connecter en utilisant le champ Adresse du serveur. Un numéro de port optionnel peut être ajouté après l'adresse IP ou l'URL en utilisant le deux-points comme séparateur, par ex. jamulus.example.com:22124. Le champ affichera également une liste des adresses de serveur les plus utilisées récemment.
-
-### Bouton Me silencer
-
-Coupe votre flux audio vers le serveur afin que vous puissiez vous entendre et voir vos propres niveaux d'entrée, mais pas les autres musiciens. Sachez que les autres musiciens ne sauront pas si vous vous êtes mis en silence.
-
-### L'effet de réverbération
-
-
-
-La réverbération peut être appliquée à un canal audio mono local ou aux deux canaux en mode stéréo.
-La sélection du canal mono et le niveau de réverbération peuvent être modifiés. Par exemple, si le signal d'un micro est envoyé sur le canal audio de droite de la carte son et qu'un effet de réverbération doit y être appliqué, réglez le sélecteur de canal sur le canal de droite et déplacez le chariot vers le haut jusqu'à ce que le niveau de réverbération souhaité soit atteint.
-
-### Contrôle local du panoramique/de la balance audio
-
-
-
-Contrôle les niveaux relatifs des canaux audio locaux gauche et droite. Pour un signal mono, il agit comme un panoramique entre les deux canaux. Par exemple, si un micro est connecté au canal d'entrée de droite et qu'un instrument est connecté au canal d'entrée de gauche qui est beaucoup plus fort que le micro, déplacez le chariot audio dans une direction où l'étiquette au-dessus du chariot indique G -x, où x est l'indicateur d'atténuation actuelle.
-
-### Console de mixage audio du serveur
-
-
-
-L'écran du mixeur audio affiche chaque utilisateur connecté au serveur (y compris vous-même).
-Les chariots vous permettent d'ajuster le niveau de ce que vous entendez sans affecter ce que les autres entendent.
-
-Le VU-mètre indique le niveau d'entrée au serveur, c'est-à-dire le son envoyé.
-
-Si vous avez réglé votre canal audio sur Stéréo ou Sortie Stéréo dans vos paramètres, vous verrez alors un contrôle de balance audio (Maj-clic pour réinitialiser).
-
-Si vous voyez une icône « muet » au-dessus d'un utilisateur, cela signifie que cette personne ne peut pas vous entendre. Soit il vous a mis en silence, soit il a mis en solo un ou plusieurs utilisateurs sans vous y inclure, soit il a réglé votre chariot dans son mixage à zéro.
-
-L'utilisation du bouton **Muet** empêche les utilisateurs d'être entendus dans votre mix local. Sachez que lorsque vous mettez quelqu'un en silence, il verra une icône « muet » au-dessus de votre chariot pour indiquer que vous ne l'entendez pas. Notez également que vous continuerez à voir son VU-mètre bouger si le son de l'utilisateur mis en sourdine atteint le serveur. La position de votre chariot pour eux n'est pas affectée non plus.
-
-Le **bouton Solo** vous permet d'entendre un ou plusieurs utilisateurs seuls. Ceux qui ne sont pas en solo seront mis en silence. Notez également que ces personnes qui ne sont pas en solo verront une icône « muet » au-dessus de votre chariot.
-
-Les canaux sont listés de gauche à droite dans l'ordre dans lequel les clients se connectent jusqu'à ce qu'ils partent, leur « créneau » sera alors occupé par le nouvel arrivant suivant. Vous pouvez modifier l'ordre de tri en utilisant l'option Éditer dans le menu de l'application.
-
-Vous pouvez regrouper les utilisateurs en utilisant le commutateur « groupe ». Déplacer le chariot de n'importe quel membre du groupe déplacera les autres chariots de ce groupe de la même proportion. Vous pouvez temporairement isoler un canal du groupe avec Maj-clic-glisser.
-
-Si l'administrateur du serveur a activé l'enregistrement, vous verrez un message au-dessus de la console de mixage indiquant que vous êtes en train d'être enregistré.
-
-
-
-Fenêtre des paramètres
-----------------------
-
-
-
-### Périphérique de carte son
-
-
-
-
-Le pilote ASIO (Périphérique) peut être sélectionné en utilisant Jamulus sous le système d'exploitation Windows. Si le pilote ASIO sélectionné n'est pas valide, un message d'erreur s'affiche et le pilote valide précédent est sélectionné. Sous macOS, le matériel d'entrée et de sortie peut être sélectionné.
-
-### Assignation de canal d'entrée/sortie
-
-
-
-Si le périphérique de carte son sélectionnée fournit plus d'un canal d'entrée ou de sortie, les _cartographie des canaux d'entrée_ et _cartographie des canaux de sortie_ sont visibles. Pour chaque canal d'entrée/sortie Jamulus (canal gauche et droite), un canal différent de la carte son actuelle peut être sélectionné.
-
-### Activer les petits tampons de réseau
-
-Permet la prise en charge des très petits paquets audio réseau. Ils ne sont utilisés que si le délai du tampon de la carte son est inférieur à 128 échantillons. Plus les tampons réseau sont petits, plus la latence audio est faible. Mais en même temps, la charge réseau augmente et la probabilité de décrochage audio augmente également.
-
-### Délai de tampon
-
-
-
-Le réglage du délai de tampon est un réglage fondamental pour le logiciel Jamulus. Ce réglage a une influence sur de nombreuses propriétés de la connexion. Trois tailles de tampon sont prises en charge :
-
-- 64 échantillons : le paramètre à choisir de préférence, fournit la latence la plus faible mais ne fonctionne pas avec toutes les cartes son.
-- 128 échantillons : devrait fonctionner pour la plupart des cartes son disponibles.
-- 256 échantillons : ne devrait être utilisé que sur des ordinateurs très lents, ou avec une connexion internet lente.
-
-Certains pilotes de carte son ne permettent pas de modifier le délai de tampon à partir du logiciel Jamulus.
-Dans ce cas, le réglage du délai de tampon est désactivé et doit être modifié à l'aide du pilote de la carte son. Sous Windows, appuyez sur le bouton Configuration ASIO pour ouvrir le panneau des paramètres du pilote.
-
-
-
-Sous Linux, utilisez l'outil de configuration JACK pour modifier la taille du tampon.
-
-Le délai actuel du tampon a une influence sur l'état de la connexion, le taux de transfert courant et le délai global.
-Plus la taille du tampon est faible, plus la probabilité d'un voyant rouge dans l'indicateur d'état (décrochages) est élevée et plus le taux de transfert est élevé et le délai global est faible.
-
-
-
-Le réglage du tampon est donc un compromis entre la qualité audio et le délai global.
-
-### Tampon de gigue avec indicateur de statut du tampon
-
-
-
-Le tampon de gigue compense les gigues de synchronisation du réseau et de la carte son. La taille du tampon influence donc la qualité du flux audio (le nombre de décrochages) et le délai global (plus le tampon est long, plus le délai est important).
-
-Vous pouvez définir manuellement la taille du tampon de gigue pour votre client local et le serveur distant. Pour le tampon de gigue local, les décrochages dans le flux audio sont indiqués par le voyant lumineux situé sous les chariots de taille de tampon de gigue.
-Si le voyant devient rouge, un dépassement ou une sous-utilisation du tampon a eu lieu et le flux audio est interrompu.
-
-Le réglage du tampon de gigue est donc aussi un compromis entre la qualité audio et le délai global.
-
-Si le paramètre Auto est activé, les tampons de gigue de votre client local et du serveur distant sont automatiquement réglés en fonction des mesures de la gigue de synchronisation du réseau et de la carte son. Si la vérification automatique est activée, les chariots de la taille de tampon de gigue sont désactivés (ils ne peuvent pas être déplacés avec la souris).
-
-### Canaux audio
-
-
-
-Sélectionne le nombre de canaux audio à utiliser pour la communication entre le client et le serveur. Trois modes sont disponibles :
-
-Les modes mono et stéréo utilisent respectivement un et deux canaux audio.
-
-Mono-entrée/stéréo-sortie : le signal audio envoyé au serveur est mono mais le signal de retour est stéréo. C'est utile si la carte son a l'instrument sur un canal d'entrée et le micro sur l'autre. Dans ce cas, les deux signaux d'entrée peuvent être mélangés sur un canal mono mais le mixage du serveur est entendu en stéréo.
-
-L'activation du mode stéréo augmentera le débit de données de votre flux. Assurez-vous que votre débit montant ne dépasse pas la vitesse montante disponible pour votre connexion internet.
-
-En mode de flux stéréo, aucune sélection de canal audio pour l'effet de réverb ne sera disponible dans la fenêtre principale puisque l'effet est appliqué aux deux canaux dans ce cas.
-
-### Qualité audio
-
-
-
-Plus la qualité audio est élevée, plus le débit de données de votre flux audio est élevé. Assurez-vous que votre débit montant ne dépasse pas la vitesse montante disponible pour votre connexion internet.
-
-### Niveau de nouveau client
-
-
-
-Ce paramètre définit le niveau du chariot d'un client nouvellement connecté, en pourcentage. Si un nouveau utilisateur se connecte au serveur courant, il obtiendra le niveau de chariot initial spécifié si aucun autre niveau de canal provenant d'une connexion précédente de ce même utilisateur n'a déjà été stocké. Vous pouvez configurer tous les utilisateurs d'un serveur occupé à ce niveau en utilisant Éditer > « Régler tous les chariots sur niveau d'un nouveau client ».
-
-### Thème fantaisie
-
-
-
-Ceci applique un thème fantaisie à la fenêtre principale.
-
-### Adresse personnalisée du serveur central
-
-
-
-Laissez ce champ vide, sauf si vous devez entrer l'adresse d'un serveur central autre que celui par défaut.
-
-### Paramètre de l'état actuel de la connexion
-
-
-
-Le temps de « ping » est le temps nécessaire au flux audio pour faire l'aller-retour entre le client et le serveur.
-Ce délai est introduit par le réseau et devrait être d'environ 20 à 30 ms. Si le délai est supérieur à environ 50 ms, la distance qui vous sépare du serveur est trop importante ou votre connexion internet n'est pas suffisante.
-
-Le délai global est calculé à partir du « ping » actuel et du délai introduit par les paramètres actuel du tampon.
-
-Le débit montant de l'audio dépend de la taille actuelle des paquets audio et du réglage de compression. Assurez-vous que le débit montant n'est pas supérieur à votre vitesse montante internet disponible (vérifiez ça avec un service tel que [librespeed.org (en anglais)](https://librespeed.org/)).
-
-----
-## Notes
-
-[^1]: dans le domaine des réseaux informatiques, la **gigue** (en anglais **jitter**) est la variation de la latence au fil du temps. _(Source : [Wikipédia FR](https://fr.wikipedia.org/wiki/Gigue_(informatique)){: target="_blank" rel="noopener noreferrer"})_
diff --git a/wiki/fr/fr-Tips-Tricks-More.md b/wiki/fr/fr-Tips-Tricks-More.md
deleted file mode 100644
index ddcf5555a..000000000
--- a/wiki/fr/fr-Tips-Tricks-More.md
+++ /dev/null
@@ -1,101 +0,0 @@
----
-layout: wiki
-title: "Trucs, astuces et autres"
-lang: "fr"
-permalink: "/wiki/Tips-Tricks-More"
----
-
-# Trucs et astuces
-
-## S'informer sur les répétitions de groupe à distance
-
-L'utilisateur de Jamulus [Chris Rimple (en anglais)](https://sourceforge.net/u/chrisrimple/profile/), a compilé un grand nombre d'informations relatives [aux répétitions de groupe à distance (en anglais)](https://docs.google.com/document/d/1smcvsxdaaViPQvGMQHmah_6BQeqowhmGSFMHfnlY2FI/) (Google doc) qui couvre des sujets comme la configuration matérielle et logicielle incluant des exemples et conseils pour les nouveaux arrivants sur ce terrain. Il inclut aussi une section comparant de Jamulus à d'autres solutions.
-
-## Utilisation de l'audio de Jamulus dans des applications de visio-conférences Zoom (ou autres)
-
-Plusieurs utilisateurs ont rapporté avoir permis à un « public virtuel » de suivre une session Jamulus en utilisant [JACK audio (en anglais)](https://jackaudio.org) pour router le signal de Jamulus à travers de JackRouter vers l'application cible (dans ce cas, Zoom meetings).
-
-Vous pouvez également utiliser [VoiceMeeter (en anglais)](https://www.vb-audio.com/Voicemeeter/banana.htm) (Banana) pour Windows ou [BlackHole (en anglais)](https://github.com/ExistentialAudio/BlackHole) pour macOS afin de router la sortie de Jamulus vers de multiples destinations, par exemple vers votre casque et l'application de visio-conférence en même temps.
-
-## Enregistrer Jamulus sous Windows avec Reaper
-
-L'utilisateur de Jamulus [Rob Durkin (en anglais)](https://sourceforge.net/u/bentwrench/profile/), a écrit un [guide pour enregistrer la sortie de Jamulus (en anglais)](https://docs.google.com/document/d/1tENfNKTWHasuTg33OdLLEo4-OOhWJolOo42ffSARxhY/edit) (Google Doc) en utilisant composant additionnel ReaRoute pour [Reaper (en anglais)](https://www.reaper.fm/).
-
-## Partager les partitions de voix et d'accords
-
-L'utilisateur de Jamulus [BTDT (en anglais)](https://sourceforge.net/u/btdt/profile/), a écrit un système appelé [305keepers (en anglais)](https://github.com/keepers305/Song-Sheet-Sharing-Web-Pages), une application web qui permet à un « chef de bœuf » d'envoyer des partitions (au format PDF) aux « bœuffeurs » en temps réel en utilisant des navigateurs web standard.
-
-## Faire une page de statut du serveur
-
-Avec l'argument en ligne de commande `-m`, une information statistique à propos du serveur peut être générée pour être incluse dans une page web.
-
-Voici un exemple de script php utilisant le fichier de statut du serveur pour afficher le statut actuel du serveur dans une page html (en supposant que l'argument de ligne de commande suivant soit utilisé : `-m /var/www/stat1.dat`)
-
-~~~
-
-
-~~~
-
-## Sauvegarde et chargement des états du mix client
-
-Vous pouvez sauvegarder et restaurer le mix que vous utilisez pour les répétitions avec votre groupe (chariots, muet, panoramique, solo, etc.) et les recharger à tout moment (même si vous êtes en train de jouer). Faites ça en utilisant « Fichier > Sauvegarder la configuration des canaux du mixeur… » dans votre client et rechargez-les en utilisant « Charger la configuration des canaux du mixeur… » (ou en les glissant/déposant dans la fenêtre de la console de mixage).
-
-## Convertir un serveur public en un serveur privé à la volée
-
-Vous pouver faire fonctionner un serveur public le temps nécessaire pour que votre groupe s'y connecte,puis devenir privé en décochant simplement la case « Rendre mon serveur public » dans l'IUG du serveur. Les membres de votre groupe resteront connectés au serveur jusqu'à ce qu'ils se déconnectent. (Merci à [David Savinkoff (en anglais)](https://github.com/DavidSavinkoff) pour le tuyau !)
-
-## Script de démarrage du client pour Linux
-
-Voici un script de démarrage Linux pour Jamulus utilisant une vieille carte son Audigy4, dont le grand nombre de chariots audio disponibles rend compliqué l'obtention de réglages corrects.
-
-Ce script inclut donc les principaux réglages des chariots audio. La deuxième partie du script traite des connexions JACK. J'utilise Guitarix comme processeur d'effets pour ma guitare que je branche dans le cheminement audio jack.
-
-Finalement, je lance Jamulus en le connectant automatiquement au serveur central.
-
-Voici le script :
-
-~~~
-amixer sset 'Mic' capture 30% cap
-amixer sset 'Mic' playback 0%
-amixer sset 'Line' playback 60% unmute
-amixer sset 'Audigy Analog/Digital Output Jack' unmute
-amixer sset 'Analog Mix' capture 100%
-amixer sset 'Analog Mix' playback 0%
-amixer sset 'Wave' 100%
-amixer sset 'Master' capture 100% cap
-amixer sset 'Master' playback 100%
-amixer sset 'Master' playback 100%
-amixer sset 'PCM' playback 100%
-amixer sset 'PCM' capture 0%
-guitarix &
-/home/corrados/llcon/Jamulus -c myJamulusServer.domain.com &
-sleep 3
-jack_disconnect system:capture_1 Jamulus:'input left'
-jack_disconnect system:capture_2 Jamulus:'input right'
-jack_connect system:capture_1 gx_head_amp:in_0
-jack_connect gx_head_amp:out_0 gx_head_fx:in_0
-jack_connect gx_head_fx:out_0 Jamulus:'input left'
-jack_connect gx_head_fx:out_1 Jamulus:'input right'
-jack_connect Jamulus:'output left' system:playback_1
-jack_connect Jamulus:'output right' system:playback_2
-~~~
-
-
-## Utilisation de ctrlmidich pour les contrôleurs MIDI
-
-Les chariots de volume dans la fenêtre de mixage du client peuvent être contrôlés par un contrôleur MIDI en utilisant le paramètre `--ctrlmidich` (note : uniquement disponible pour une utilisation avec macOS et Linux). Pour activer cette fonctionnalité, Jamulus doit être lancé avec `--ctrlmidich`. Il y a deux paramètres que vous pouvez définir : `Canal` et `Décalage`. Réglez le premier paramètre sur le canal que vous voulez que Jamulus écoute (0 pour tous les canaux) et le second paramètre sur le numéro de contrôle auquel vous voulez que le premier chariot réagisse. Par défaut, le décalage est de 70 (pour le Behringer X-Touch), ce qui signifie que le premier chariot réagit au numéro de contrôle 70, le second au 71, et ainsi de suite.
-
-Ainsi, par exemple, si vous utilisez un Behringer X-Touch, que vous envoyez du MIDI sur le canal 1 et que vous laissez le décalage par défaut, la commande ressemblera à ceci : `--ctrlmidich 1`. Si vous avez un contrôleur différent, par exemple envoyant du MIDI sur le canal 2 et commençant par le numéro de contrôle 30, la commande sera la suivante `--ctrlmidich "2;30"`
-
-Assurez-vous de connecter le port de sortie de votre périphérique MIDI au port d'entrée MIDI de Jamulus (Qjackctl (Linux), MIDI Studio (macOS) ou tout autre port que vous utilisez pour gérer les connexions). Sous Linux, vous devrez installer et lancer a2jmidid pour que votre péripérique apparaisse dans l'onglet MIDI de Qjackctl.
diff --git a/wiki/fr/fr-index.md b/wiki/fr/fr-index.md
deleted file mode 100644
index 594b2c03b..000000000
--- a/wiki/fr/fr-index.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-layout: wikioverview
-title: "Vue d'ensemble"
-lang: "fr"
-permalink: "/wiki/"
----
-# Vue d'ensemble des pages
diff --git a/wiki/it/it-Central-Servers.md b/wiki/it/it-Central-Servers.md
deleted file mode 100644
index d9cc9f0dc..000000000
--- a/wiki/it/it-Central-Servers.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-layout: wiki
-title: "Central Servers"
-lang: "it"
-permalink: "/wiki/Central-Servers"
----
-
-# Registrare un Server Pubblico
-
-A partire da maggio 2020, per ridurre al minimo il rischio di sovraccaricare il server centrale, abbiamo creato diversi server basati sul genere musicale (ciascuno con un limite attuale di 150 server).
-
-Quando avvii un server pubblico, vedrai un messaggio che ti conferma se il tuo server è stato inserito nell'elenco correttamente o meno. Se lasci il tuo server in esecuzione, tenterà di registrarsi finché non sarà disponibile uno slot libero.
-
-## Headless servers (Senza GUI)
-
-A partire da Jamulus v3.5.4, sarà necessario impostare manualmente l'indirizzo del server centrale (con le informazioni sul genere) utilizzando l'opzione `--centralserver` (`-e`) come riportato di seguito:
-
-| Genre | Server address |
-|-----------|------------------|
-|**All/Any** |`jamulusallgenres.fischvolk.de:22224` |
-|**Rock**|`jamulusrock.fischvolk.de:22424`|
-|**Jazz**|`jamulusjazz.fischvolk.de:22324`|
-|**Classical/Folk/Choir**|`jamulusclassical.fischvolk.de:22524`|
-|Default _(in disuso a partire da Jamulus v3.5.4)_|`jamulus.fischvolk.de:22124`|
diff --git a/wiki/it/it-Choosing-a-Server-Type.md b/wiki/it/it-Choosing-a-Server-Type.md
deleted file mode 100644
index b77d13f11..000000000
--- a/wiki/it/it-Choosing-a-Server-Type.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-layout: wiki
-title: "Scegliere come avviare il Server"
-lang: "it"
-permalink: "/wiki/Choosing-a-Server-Type"
----
-
-# Tipi di Server
-
-Puoi eseguire il tuo server in una delle tre "modalità" (a casa o su un host di terze parti):
-
-### 1. Pubblico
-
-Il tuo server sarà registrato su di un [server centralizzato](Central-Servers) e visibile in una lista di default. I Musicisti vedranno, e quindi potrranno connettersi, al tuo server. Non è necessario creare un server pubblico per suonare ne esistono già tanti. Per divertirsi, cerca un server della lista con latenza bassa e suona.
-
-
-
-Questa modalità viene attivata quando la voce "Rendi il server Pubblico" è selezionata, puoi inserire informazioni aggiuntive al tuo server compilando i campi correlati.
-
-Quando avvii il server senza interfaccia ("headless"), bisogna configurare il server come segue per renderlo pubblico:
-
-~~~
-Jamulus --nogui --server \
- --centralserver genreServer:port \
- --serverinfo "yourServerName;yourCity;[country ID]"
-~~~
-
-**Nota**: **Non è** necessario configurare il "port-forwarding" o altri parametri del router per rendere visibile un server pubblico.
-
-Consultare la pagina [opzioni da linea di comando](Command-Line-Options) per vedere quali parametri è possibile usare per i settaggi.
-
-
-### 2. Privato
-
-Questi server non vengono registrati nelle liste di server centrali. Dovrai comunicare ai musicisti l'indirizzo del tuo server. Leggi [Avviare un server privato](Running-a-Private-Server) per sapere cosa è necessario fare per consentire agli altri di connettersi ad esso.
-
-
-
-Questa modalità viene attivata quando la voce "Rendi il server Pubblico" non è selezionata.
-
-Quando avvii il server senza interfaccia ("headless"), bisogna configurare il server come segue per renderlo privato:
-
-```shell
-Jamulus --nogui --server
-```
-
-Consultare la pagina [opzioni da linea di comando](Command-Line-Options) per vedere quali parametri è possibile usare per i settaggi.
-
-
-### 3. Centrale
-
-La configurazione del server come server centrale deve essere eseguita solo in circostanze speciali (es. eventi online o associazioni musicali). La maggior parte delle persone può ignorare questa modalità.
-
-Per visualizzare i server elencati da un server centrale personalizzato, i musicisti devono inserire l'indirizzo nell'apposito campo delle impostazioni "Server centrale alternativo" del client. I musicist vedranno quindi un elenco generato da quel server centrale.
-
-Chi gestisce i server può registrarsi al tuo server centrale per essere visibile nell'elenco tramite l'opzione `--centralserver`.
-
-Per eseguire un server come server centrale, è necessario configurarlo con il comando `--centralserver localhost` (ovvero, si imposta come server centrale da interrogare).
-
-Se desideri controllare quali server possono registrarsi con il tuo server centrale, puoi abilitare una whitelist con l'estensione `--listfilter`. Leggere la pagina [opzioni da linea di comando](Command-Line-Options) per maggiori informazioni su questa funzione.
-
-Consultare la pagina [opzioni da linea di comando](Command-Line-Options) per vedere quali parametri è possibile usare per i settaggi.