diff --git a/.vuepress/config.js b/.vuepress/config.js
index 32c53cb1474..6fd22b9ef70 100755
--- a/.vuepress/config.js
+++ b/.vuepress/config.js
@@ -223,6 +223,8 @@ module.exports = {
                 'thinking_in_nushell',
                 'moving_around',
                 'types_of_data',
+                'loading_data',
+                'working_with_strings',
                 'konfiguration',
                 'environment',
                 '3rdpartyprompts',
diff --git a/de/book/loading_data.md b/de/book/loading_data.md
new file mode 100644
index 00000000000..3bac62c4073
--- /dev/null
+++ b/de/book/loading_data.md
@@ -0,0 +1,234 @@
+# Laden von Daten
+
+Im letzten Kapitel wurden Befehle wie [`ls`](/book/commands/ls.md), [`ps`](/book/commands/ps.md),
+[`date`](/book/commands/date.md), and [`sys`](/book/commands/sys.md) vorgestellt um Informationen
+über Dateien, Prozesse, Zeiten und die Systemumgebung selber zu laden.
+Jeder Befehl ergibt eine Tabelle aus, mit der gearbeitet werden kann.
+Es gibt jedoch noch andere Möglichkeiten Tabellen aus Daten zu erhalten.
+
+## Dateien öffnen
+
+Einer der mächtigsten Befehle in Nu um mir Daten zu arbeite ist der [`open`](/book/commands/open.md) Befehl.
+Er ist ein Multi-Werkzeug, welcher mit verschiedensten Datenformaten umgehen kann.
+Hier zum Beispiel was passiert, wenn eine json Datei geöffnet wird:
+
+```
+> open editors/vscode/package.json
+──────────────────┬───────────────────────────────────────────────────────────────────────────────
+ name             │ lark
+ description      │ Lark support for VS Code
+ author           │ Lark developers
+ license          │ MIT
+ version          │ 1.0.0
+ repository       │ [row type url]
+ publisher        │ vscode
+ categories       │ [table 0 rows]
+ keywords         │ [table 1 rows]
+ engines          │ [row vscode]
+ activationEvents │ [table 1 rows]
+ main             │ ./out/extension
+ contributes      │ [row configuration grammars languages]
+ scripts          │ [row compile postinstall test vscode:prepublish watch]
+ devDependencies  │ [row @types/mocha @types/node tslint typescript vscode vscode-languageclient]
+──────────────────┴───────────────────────────────────────────────────────────────────────────────
+```
+
+Ähnlich wie beim [`ls`](/book/commands/ls.md) Befehl, bekommen wir mehr als nur Text 
+(oder einen Stream von bytes) zurück, wenn wir einen Dateityp öffnen, den Nu versteht.
+Hier wurde ein "package.json" von einem JavaScript Projekt geöffnet. Nu erkennt den json text
+und parst die Daten in eine Tabelle.
+
+Soll nur die Version aus dem Projekt angezeigt werden, kann mit dem [`get`](/book/commands/get.md)
+direkt diese Information herausgelesen werden.
+
+```
+> open editors/vscode/package.json | get version
+1.0.0
+```
+
+Nu unterstützt aktuell die folgenden Formate um Daten direkt als Tabelle zu öffnen:
+
+- csv
+- eml
+- ics
+- ini
+- json
+- nuon
+- ods
+- ssv
+- toml
+- tsv
+- url
+- vcf
+- xlsx / xls
+- xml
+- yaml / yml
+
+Was aber passiert, wenn eine Text Datei geladen wird, die keinem der angegebenen Formate entspricht?
+
+```
+> open README.md
+```
+
+Die Datei wird wie gewohnt als Text ausgegeben.
+
+Im Hintergrund sieht Nu eine reine Text Datei als einen grossen String.
+Wie man mit einem String umgeht und die benötigten Daten herauszieht, steht im nächsten Kapitel.
+
+## Mit Strings umgehen
+
+Ein wichtiger Teil der Arbeit mit Nu ist es, mit externen Daten um zu gehen, die Nu nicht versteht.
+Oft werden diese Daten als String repräsentiert.
+
+Zum Beispiel wie in dieser Datei:
+
+```
+> open people.txt
+Octavia | Butler | Writer
+Bob | Ross | Painter
+Antonio | Vivaldi | Composer
+```
+
+Jeder Datenpunkt ist durch ein pipe ('|') Symbol getrennt. Und jede Person steht auf einer
+eigenen Zeile. Nu kennt standardmässig kein Dateiformat, welches pipe-getrennt ist,
+weshalb diese Datei von Hand geparst werden muss.
+
+Zuerst wird die Datei so geladen, dass jede Zeile für sich verarbeitet werden kann:
+
+```
+> open people.txt | lines
+───┬──────────────────────────────
+ 0 │ Octavia | Butler | Writer
+ 1 │ Bob | Ross | Painter
+ 2 │ Antonio | Vivaldi | Composer
+───┴──────────────────────────────
+```
+Dadurch wird bereits wieder eine Tabelle ausgegeben. Im nächsten Schritt sollen die Spalten 
+in etwas brauchbares aufgeteilt werden.
+Dafür verwenden wir den [`split`](/book/commands/split.md) Befehl. Wie der Name schon verräht,
+kann damit ein String durch ein Trennzeichen aufgesplittet oder aufgetrennt werden.
+Mit dem `column` Unterbefehl wird der Inhalt über mehrere Spalten aufgeteilt.
+Als Parameter reicht das Trennzeichen, der Rest ist automatisch:
+
+```
+> open people.txt | lines | split column "|"
+───┬──────────┬───────────┬───────────
+ # │ column1  │ column2   │ column3
+───┼──────────┼───────────┼───────────
+ 0 │ Octavia  │  Butler   │  Writer
+ 1 │ Bob      │  Ross     │  Painter
+ 2 │ Antonio  │  Vivaldi  │  Composer
+───┴──────────┴───────────┴───────────
+```
+
+Das sieht _fast_ korrekt aus.Es sieht so aus, als ob sich noch eine zusätzliche Lücke eingeschlichen hat.
+Mit dem [`trim`](/book/commands/str_trim.md) Befehl wird dieser beseitigt:
+
+```
+> open people.txt | lines | split column "|" | str trim
+───┬─────────┬─────────┬──────────
+ # │ column1 │ column2 │ column3
+───┼─────────┼─────────┼──────────
+ 0 │ Octavia │ Butler  │ Writer
+ 1 │ Bob     │ Ross    │ Painter
+ 2 │ Antonio │ Vivaldi │ Composer
+───┴─────────┴─────────┴──────────
+```
+
+
+Nicht schlecht. Der [`split`](/book/commands/split.md) Befehl gibt nicht nur brauchbare Daten zurück, 
+sondern bezeichnet auch noch standardmässig die Spaltennamen:
+
+```
+> open people.txt | lines | split column "|" | str trim | get column1
+───┬─────────
+ 0 │ Octavia
+ 1 │ Bob
+ 2 │ Antonio
+───┴─────────
+```
+
+Die Spalten können jedoch auch benannt werden:
+
+```
+> open people.txt | lines | split column "|" first_name last_name job | str trim
+───┬────────────┬───────────┬──────────
+ # │ first_name │ last_name │ job
+───┼────────────┼───────────┼──────────
+ 0 │ Octavia    │ Butler    │ Writer
+ 1 │ Bob        │ Ross      │ Painter
+ 2 │ Antonio    │ Vivaldi   │ Composer
+───┴────────────┴───────────┴──────────
+```
+
+Jetzt da die Daten in einer Tabelle sind, können alle Befehle, die wir davor schon auf Tabellen
+angewendet haben wiederverwenden:
+
+```
+> open people.txt | lines | split column "|" first_name last_name job | str trim | sort-by first_name
+───┬────────────┬───────────┬──────────
+ # │ first_name │ last_name │ job
+───┼────────────┼───────────┼──────────
+ 0 │ Antonio    │ Vivaldi   │ Composer
+ 1 │ Bob        │ Ross      │ Painter
+ 2 │ Octavia    │ Butler    │ Writer
+───┴────────────┴───────────┴──────────
+```
+
+Weitere Befehle, mit denen Texte aus Strings bearbeitet werden können sind:
+
+- `str`
+- [`lines`](/book/commands/lines.md)
+- [`size`](/book/commands/size.md)
+
+Es gibt ausserdem einige Hilfsbefehle, die verwendet werden können um mit Daten umzugehen,
+die Nu eigentlich verstehen sollte. Zum Beispiel wenn eine Rust lock Datei geöffnet wird:
+
+```
+> open Cargo.lock
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "adhoc_derive"
+version = "0.1.2"
+```
+
+Eine "Cargo.lock" Datei ist eigentlich eine .toml Datei, aber die Dateiendung ist nicht .toml.
+Das ist ok, denn mit dem `from` und seinem Unterbefehl `toml` können wir dies explizit angeben:
+
+```
+> open Cargo.lock | from toml
+──────────┬───────────────────
+ metadata │ [row 107 columns]
+ package  │ [table 130 rows]
+──────────┴───────────────────
+```
+Der `from` Befehl kann für jedes strukturierte Datenformat, welches Nu versteht, verwendet werden,
+indem das Format als entsprechender Unterbefehl verwendet wird.
+
+## Öffnen im raw Modus
+
+Auch wenn es hilfreich ist, beim Öffnen einer Datei direkt eine Tabelle zu erhalten,
+ist dies nicht immer gewünscht. Um den darunter liegenden Text zu erhalten, kann dem 
+[`open`](/book/commands/open.md) Befehl das Flag `--raw` mitgegeben werden:
+
+```
+> open Cargo.toml --raw
+[package]                                                                                        name = "nu"
+version = "0.1.3"
+authors = ["Yehuda Katz <wycats@gmail.com>", "Jonathan Turner <jonathan.d.turner@gmail.com>"]
+description = "A shell for the GitHub era"
+license = "MIT"
+```
+
+## URLs abrufen
+
+Zusätzlich zum Laden von Dateien vom Dateisystem, können auch URLs mit dem [`fetch`](/book/commands/fetch.md) 
+Befehl geladen werden. Dies wird den Inhalt der URL aus dem Netz abrufen und zurückgeben:
+
+```
+> fetch https://blog.rust-lang.org/feed.xml
+──────┬───────────────────
+ feed │ {record 2 fields}
+──────┴───────────────────
+```
diff --git a/de/book/working_with_strings.md b/de/book/working_with_strings.md
new file mode 100644
index 00000000000..e5ed97d29bc
--- /dev/null
+++ b/de/book/working_with_strings.md
@@ -0,0 +1,225 @@
+# Mit Text (strings) arbeiten
+
+Texte können ganz verschiedene Formen von Daten annehmen.
+Es können Dateinamen, Verzeichniss-Pfade, Spaltennamen und vieles mehr sein.
+Texte kommen so oft vor, dass Nushell diverse Wege bereitstellt um mit 
+ihnen zu arbeiten. Der Anwendungsfall entscheidet, welches am besten passt.
+
+## Texte in einfachen Anführungszeichen
+
+Der einfachste Text in Nushell ist der in einfachen Anführungszeichen.
+Er wird mit dem `'` Zeichen umgeben. Hier der Text als Hallo Welt.
+
+```sh
+> 'Hallo Welt'
+Hallo Welt
+```
+
+Text in einfachen Anführungszeichen belassen den Text wie er ist,
+womit sie ideal sind, um diverse Formen von Text zu enthalten.
+
+## Texte in doppelten Anführungszeichen
+
+Für komplexere Formen, werdne in Nushell Texte in doppelte 
+Anführungszeichen gesetzt. Diese werden mit dem `'` Zeichen umgeben.
+Sie unterstützen die Verwendung von Escape-Zeichen mit der Verwendung 
+eines `\`.
+
+Zum Beispiel kann das Hallo Welt von vorhin geschrieben werden als,
+Hallo gefolgt von einen `\n` um eine neue Linie zu erzeugen, dann Welt.
+Das ganze in doppelten Anführungszeichen.
+
+```sh
+> "Hallo\nWelt"
+Hallo
+Welt
+```
+
+Escape Zeichen werden verwendet um Zeichen einzugeben, die ansonsten
+schwer zu tippen wären.
+
+Nushell unterstützt aktuell folgende Escape Zeichen:
+
+- `\"` - Doppeltes Anführungszeichen
+- `\'` - Einfaches Anführungszeichen
+- `\\` - Gegenstrich
+- `\/` - Vorwärtsstrich
+- `\b` - Rücktaste
+- `\f` - Vorschub
+- `\r` - Zeilenumschalt
+- `\n` - Neue Zeile (line feed)
+- `\t` - Tabulator
+- `\uXXXX` - Ein Unicode Zeichen (Tausche XXXX mit der Nummer des Unicode Zeichens)
+
+## Text Interpolation
+
+Anwendungsfälle von komplexeren Text-Operationen benötigen eine neue Form von Text:
+Text Interpolation. Ein Weg um Texte zusammenzustellen, die sowohl aus rohem Text,
+als auch aus dem Ergebnis von laufenden Ausdrücken bestehen. Text Interpolation kombiniert
+diese Texte zusammen zu einem neuen Text-Ergebnis.
+
+Die Text Interpolation wird mit `$" "` und `$" "` gebildet.
+ 
+Soll zum Beispiel eine Person per Namen gegrüsst werden, deren Namen in einer Variablen steht,
+dann sieht das so aus:
+
+```sh
+> let name = "Alice"
+> $"greetings, ($name)"
+greetings, Alice
+```
+
+Ein Ausdruck in `()` wird zuerst fertig ausgeführt. Das Ergebnis wird zur Bildung 
+des finalen Textes verwendet.
+
+Text Interpolationen funktionieren mit einfachen Anführungszeichen, `$' '`,
+sowie mit doppelten Anführungszeichen `$" "`. Analog unterstützen doppelte Anführungszeichen
+auch bei der Text Interpolation Escape Zeichen, was einfache Anführungszeichen nicht tun.
+
+Seit Version 0.61 unterstützt Nushell Escape Zeichen für Klammern.
+So können die Zeichen `(` und `)` in einem Text verwendet werden, ohne dass Nushell
+auswerten will, was sich dazwischen befindet.
+
+```sh
+> $"2 + 2 is (2 + 2) \(you guessed it!)"
+2 + 2 is 4 (you guessed it!)
+```
+
+## Texte aufsplitten
+
+Der [`split row`](/book/commands/split_row.md) Befehl erstellt eine Liste aus einem Text,
+getrennt durch das angegebene Trennzeichen.
+Zum Beispiel `let colors = ("red,green,blue" | split row ",")`
+erstellt die Liste `[red green blue]`.
+
+Der [`split column`](/book/commands/split_column.md) Befehl erstellt eine Tabelle aus einem Text,
+getrennt durch ein angegebenes Trennzeichen.
+Zum Beispiel `let colors = ("red,green,blue" | split column ",")`
+erstellt eine Tabelle mit den Elementen als Spalte.
+
+Schliesslich trennt der [`split chars`](/book/commands/split_chars.md) Befehl
+einen Text in seine Zeichen auf.
+
+
+## Der `str` Befehl
+
+Viele Text Befehle sind Sub-Befehle des `str` Befehls.
+Mit `help str` wirden alle Sub-Befehle ausgegeben.
+
+Zum Beispiel kann geprüft werden, ob sich ein Zeichen in einem Text befindet mit `str contains`:
+
+```sh
+> "Hallo Welt" | str contains "W"
+true
+```
+
+### Texte schneiden
+
+Die Seiten eines Textes werden mit dem [`str trim`](/book/commands/str_trim.md) Befehl
+geschnitten. Standardmässig schneidet der [`str trim`](/book/commands/str_trim.md) Befehl
+Leerraum von beiden Seiten des Textes. Zum Beispiel:
+
+```sh
+> '       My   string   ' | str trim
+My   string
+```
+
+Mit den Optionen `--right` und `--left` kann die Seite angegeben werden,
+auf der geschnitten werden soll.
+
+Um ein spezifisches Zeichen weg zu schneiden, wird `--char <Character>` verwendet.
+Hier ein Beispiel mit dieser Option:
+
+```sh
+> '=== Nu shell ===' | str trim -r -c '='
+=== Nu shell
+```
+
+### Subtexte
+
+Subtexte sind Stücke von Texten. Sie haben einen Start- und einen Endpunkt.
+Hier ein Beispiel eines Substrings:
+
+```sh
+> 'Hallo Welt!' | str index-of 'o'
+4
+> 'Hallo Welt!' | str index-of 'l'
+8
+> 'Hallo Welt!' | str substring '4,8'
+o We
+```
+
+### Texte ausrichten (padding)
+
+Mit den Befehlen `[str lpad`](/book/commands/str_lpad.md) und [`str rpad`](/book/commands/str_rpad.md)
+können Texte der angegeben Ausrichtung nach erweitert werden.
+Dieses Padding erweitert den Text bis zur angegebenen Länge, zum Beispiel:
+
+```sh
+> '1234' | str lpad -l 10 -c '0'
+0000001234
+> '1234' | str rpad -l 10 -c '0' | str length
+10
+```
+
+### Texte umkehren
+
+Dies kann mit dem [`str reverse`](/book/commands/str_reverse.md) Befehl ganz einfach erreicht werden.
+
+```sh
+> 'Nushell' | str reverse
+llehsuN
+> ['Nushell' 'is' 'cool'] | str reverse
+╭───┬─────────╮
+│ 0 │ llehsuN │
+│ 1 │ si      │
+│ 2 │ looc    │
+╰───┴─────────╯
+```
+
+## Texte parsen
+
+Mit dem [`parse`](/book/commands/parse.md) Befehl können Texte in Spalten geparst werden.
+Zum Beispiel:
+
+```sh
+> 'Nushell is the best' | parse '{shell} is {type}'
+╭───┬─────────┬──────────╮
+│ # │  shell  │   type   │
+├───┼─────────┼──────────┤
+│ 0 │ Nushell │ the best │
+╰───┴─────────┴──────────╯
+> 'Bash is kinda cringe' | parse --regex '(?P<shell>\w+) is (?P<type>[\w\s]+)'
+╭───┬───────┬──────────────╮
+│ # │ shell │     type     │
+├───┼───────┼──────────────┤
+│ 0 │ Bash  │ kinda cringe │
+╰───┴───────┴──────────────╯
+```
+
+## Texte konvertieren
+
+Es gibt verschiedenste Wege Texte in und von anderen Typen zu konvertieren.
+
+### In einen Text
+
+1. Mit [`into string`](/book/commands/into_string.md). e.g. `123 | into string`
+2. Mit Text Interpolation. e.g. `$'(123)'`
+3. Mit [`build-string`](/book/commands/build-string.md). e.g. `build-string (123)`
+
+### Von einem Text
+
+1. Mit [`into <type>`](/book/commands/into.md). e.g. `'123' | into int`
+
+## Texte einfärben
+
+Texte können eingefärbt werden mit dem [`ansi`](/book/commands/ansi.md) Befehl
+Zum Beispiel:
+
+```sh
+> $'(ansi purple_bold)This text is a bold purple!(ansi reset)'
+```
+
+`ansi purple_bold` färbt den Text purpur.
+`ansi reset` stellt die Farbe wieder auf stadard.
+(Tipp: Ein Zurückstellen der Farben mit `ansi reset` sollte nach jeder Farbänderung stehen)
diff --git a/i18n-meta.json b/i18n-meta.json
index a24d66260eb..b60af389856 100644
--- a/i18n-meta.json
+++ b/i18n-meta.json
@@ -163,7 +163,7 @@
     "name": "loading_data.md",
     "en": "Completed",
     "zh-CN": "fa90895307@hustcer",
-    "de": "-",
+    "de": "0c788acfec@petrisch",
     "tr": "-",
     "ja": "-",
     "es": "-",
@@ -383,7 +383,7 @@
     "name": "working_with_strings.md",
     "en": "Completed",
     "zh-CN": "b6c91cabfa@hustcer",
-    "de": "-",
+    "de": "0c788acfec@petrisch",
     "tr": "-",
     "ja": "-",
     "es": "-",