diff --git a/gui/theme/common/languages/de.xml b/gui/theme/common/languages/de.xml
new file mode 100755
index 0000000..b09852c
--- /dev/null
+++ b/gui/theme/common/languages/de.xml
@@ -0,0 +1,670 @@
+<?xml version="1.0"?>
+
+<language>
+	<display>Deutsch</display>
+
+	<resources>
+		<!-- Font overrides - only change these if your language requires special characters -->
+		<resource name="font_l" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
+		<resource name="font_m" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
+		<resource name="font_s" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
+		<resource name="fixed" type="fontoverride" filename="DroidSansMono.ttf" scale="100" />
+
+		<!-- Partition display names -->
+		<string name="system">System</string>
+		<string name="system_image">System-Image</string>
+		<string name="vendor">Anbieter</string>
+		<string name="vendor_image">Anbieter-Image</string>
+		<string name="boot">Boot</string>
+		<string name="recovery">Recovery</string>
+		<string name="cache">Cache</string>
+		<string name="data">Daten</string>
+		<string name="sdcard">SD-Karte</string>
+		<string name="internal">Interner Speicher</string>
+		<string name="microsd">Micro SD-Karte</string>
+		<string name="usbotg">USB-OTG</string>
+		<string name="android_secure">Android Secure</string>
+		<string name="dalvik">Dalvik / ART Cache</string>
+		<!-- This is a rarely used partition on a Micro SD card for a very old app2sd system -->
+		<string name="sdext">SD-EXT</string>
+		<string name="adopted_data">Eingegliederte Daten-Partition</string>
+		<string name="adopted_storage">Eingegliederte Storage-Partition</string>
+
+		<!-- GUI XML strings -->
+		<string name="twrp_header">Team Win Recovery Project</string>
+		<string name="twrp_watch_header">TWRP %tw_version%</string>
+		<string name="cpu_temp">CPU: %tw_cpu_temp% &#xB0;C</string>
+		<string name="battery_pct">Akku: %tw_battery%</string>
+		<string name="sort_by_name">Nach Namen sortieren</string>
+		<string name="sort_by_date">Nach Datum sortieren</string>
+		<string name="sort_by_size">Nach Größe sortieren</string>
+		<string name="sort_by_name_only">Name</string>
+		<string name="sort_by_date_only">Datum</string>
+		<string name="sort_by_size_only">Größe</string>
+		<string name="tab_general">ALLGEMEIN</string>
+		<string name="tab_options">OPTIONEN</string>
+		<string name="tab_backup">SICHERUNG</string>
+		<string name="tab_time_zone">ZEITZONE</string>
+		<string name="tab_screen">BILDSCHIRM</string>
+		<string name="tab_vibration">VIBRATION</string>
+		<string name="tab_language">SPRACHE</string>
+
+		<string name="install_btn">Installieren</string>
+		<string name="wipe_btn">Löschen</string>
+		<string name="backup_btn">Sichern</string>
+		<string name="restore_btn">Wiederherstellen</string>
+		<string name="mount_btn">Einhängen</string>
+		<string name="settings_btn">Einstellungen</string>
+		<string name="advanced_btn">Erweitert</string>
+		<string name="reboot_btn">Neustart</string>
+		<string name="files_btn">Dateien</string>
+		<string name="copy_log_btn">Log kopieren</string>
+		<string name="select_type_hdr">Typ wählen</string>
+		<string name="install_zip_hdr">ZIP installieren</string>
+		<string name="install_zip_btn">ZIP installieren</string>
+		<string name="install_image_hdr">Image installieren</string>
+		<string name="install_image_btn">Image installieren</string>
+		<string name="install_select_file_hdr">Datei auswählen</string>
+		<string name="file_selector_folders_hdr">Ordner</string>
+		<string name="select_file_from_storage">Speicher: %tw_storage_display_name% (%tw_storage_free_size% MB)</string>
+		<string name="adb_sideload_btn">ADB Sideload</string>
+		<string name="install_hdr">Installieren</string>
+		<string name="select_storage_hdr">Speicher auswählen</string>
+		<string name="select_storage_btn">Speicher auswählen</string>
+		<string name="queue_hdr">Einreihen</string>
+		<string name="zip_queue_count">%tw_zip_queue_count% von 10 Dateien eingereiht</string>
+		<string name="zip_queue_count_s">File %tw_zip_queue_count% von 10:</string>
+		<string name="zip_warn1">Dieser Vorgang kann möglicherweise inkompatible</string>
+		<string name="zip_warn2">Software installieren und das Gerät unbrauchbar machen.</string>
+		<string name="zip_back_cancel">Zurück-Taste drücken, um den Vorgang abzubrechen.</string>
+		<string name="zip_back_clear">Zurück-Taste drücken, um Warteschlange zu löschen.</string>
+		<string name="folder">Ordner:</string>
+		<string name="file">Datei:</string>
+		<string name="zip_sig_chk">ZIP-Signaturprüfung</string>
+		<string name="inject_twrp_chk">TWRP nach der Installation injizieren</string>
+		<string name="options_hdr">Einstellungen</string>
+		<string name="confirm_flash_hdr">Flashvorgang bestätigen</string>
+		<string name="zip_queue">Warteschlange:</string>
+		<string name="options">Einstellungen:</string>
+		<string name="swipe_confirm">Bestätigen</string>
+		<string name="zip_add_btn">Mehr ZIPs hinzufügen</string>
+		<string name="zip_clear_btn">ZIP-Stapel löschen</string>
+		<string name="install_zip_count_hdr">Installiere ZIP %tw_zip_index% von %tw_zip_queue_count%</string>
+		<string name="installing_zip_xml">Installiere ZIP: %tw_file%</string>
+		<string name="failed">Fehlgeschlagen</string>
+		<string name="successful">Erfolgreich</string>
+		<string name="install_failed">Installation fehlgeschlagen</string>
+		<string name="install_successful">Installation erfolgreich</string>
+		<string name="wipe_cache_dalvik_btn">Cache/Dalvik löschen</string>
+		<string name="reboot_system_btn">System neustarten</string>
+		<string name="install_sel_target">Ziel-Partition auswählen</string>
+		<string name="flash_image_select">Partition wählen, um das Image zu einzuspielen:</string>
+		<string name="target_partition">Ziel-Partition:</string>
+		<string name="flashing_image">Spiele Image ein...</string>
+		<string name="image_flashed">Image eingespielt</string>
+		<string name="wipe_cache_dalvik_confirm">Cache &amp; Dalvik löschen?</string>
+		<string name="wiping_cache_dalvik">Lösche Cache &amp; Dalvik...</string>
+		<string name="wipe_cache_dalvik_complete">Cache &amp; Dalvik gelöscht</string>
+		<string name="swipe_wipe">Löschen bestätigen</string>
+		<string name="swipe_wipe_s">Löschen</string>
+		<string name="no_os1">Kein OS installiert! Sind Sie</string>
+		<string name="no_osrb">sicher, dass Sie neu starten möchten?</string>
+		<string name="no_ospo">sicher, dass Sie ausschalten möchten?</string>
+		<string name="rebooting">Neustart...</string>
+		<string name="swipe_reboot">Neustart bestätigen</string>
+		<string name="swipe_reboot_s">Neustart</string>
+		<string name="swipe_flash">Installation bestätigen</string>
+		<string name="confirm_action">Aktion bestätigen</string>
+		<string name="back_cancel">Zurück-Taste drücken, um den Vorgang abzubrechen.</string>
+		<string name="cancel_btn">Abbruch</string>
+		<string name="wipe_hdr">Löschen</string>
+		<string name="factory_reset_hdr">Werkseinstellungen herstellen</string>
+		<string name="factory_reset_btn">Werkseinstellungen</string>
+		<string name="factory_reset1">Löscht Daten, Cache und Dalvik</string>
+		<string name="factory_reset2">(ohne internen Speicher)</string>
+		<string name="factory_reset3">Diese Lösch-Aktion ist in der Regel</string>
+		<string name="factory_reset4">die einzige die benötigt wird.</string>
+		<string name="factory_resetting">Werkseinstellungen herstellen...</string>
+		<string name="advanced_wipe_hdr">Erweitertes Löschen</string>
+		<string name="advanced_wipe_btn">Erweitertes Löschen</string>
+		<string name="wipe_enc_confirm">Verschlüsselung der Daten-Partition enfernen?</string>
+		<string name="formatting_data">Data wird formatiert...</string>
+		<string name="swipe_format_data">Daten-Partition formatieren</string>
+		<string name="swipe_format_data_s">Formatieren </string>
+		<string name="factory_reset_complete">Werkseinstellungen wiederhergestellt</string>
+		<string name="sel_part_hdr">Partitionen auswählen</string>
+		<string name="wipe_sel_confirm">Ausgewählte Partition(en) löschen?</string>
+		<string name="wiping_part">Lösche Partition(en)...</string>
+		<string name="wipe_complete">Löschen abgeschlossen </string>
+		<string name="sel_part_wipe">Partitionen zum Löschen auswählen:</string>
+		<string name="invalid_part_sel">Ungültige Partitionsauswahl</string>
+		<string name="format_data_hdr">Daten-Partition formatieren</string>
+		<string name="format_data_btn">Daten formatieren</string>
+		<string name="format_data_ptr1">Formatieren der Daten-Partition löscht alle Apps,</string>
+		<string name="format_data_ptr2">Sicherungen, Bilder, Videos, sowie Medien und</string>
+		<string name="format_data_ptr3">entfernt die Verschlüsselung des internen Speichers.</string>
+		<string name="format_data_adopted">Betrifft auch die eingegliederte Storage-Partition.</string>
+		<string name="format_data_lcp1">Formatieren der Daten-Partition löscht alle Apps, Backups, Bilder, Videos, sowie Medien und</string>
+		<string name="format_data_lcp2">entfernt die Verschlüsselung des internen Speichers.</string>
+		<string name="format_data_wtc1">Formatieren der Daten-Partition löscht alle Apps,</string>
+		<string name="format_data_wtc2">Sicherungen und Medien. Dies kann nicht rückgängig gemacht werden.</string>
+		<string name="format_data_undo">Dies kann nicht rückgängig gemacht werden.</string>
+		<string name="format_data_complete">Formatieren der Daten-Partition abgeschlossen</string>
+		<!-- Translator note: the word "yes" must remain English! -->
+		<string name="yes_continue">"yes" eingeben um fortzufahren. Zurück drücken um abzubrechen.</string>
+		<string name="part_opt_hdr">Optionen für %tw_partition_name%-Partition</string>
+		<string name="sel_act_hdr">Aktion auswählen</string>
+		<string name="file_sys_opt">Dateisystem-Optionen</string>
+		<string name="partition">Partition: %tw_partition_name%</string>
+		<string name="part_mount_point">Einhängepunkt: %tw_partition_mount_point%</string>
+		<string name="part_curr_fs">Dateisystem: %tw_partition_file_system%</string>
+		<string name="part_present_yes">Vorhanden: Ja</string>
+		<string name="part_present_no">Vorhanden: Nein</string>
+		<string name="part_removable_yes">Wechselbar: Ja</string>
+		<string name="part_removable_no">Wechselbar: Nein</string>
+		<string name="part_size">Größe: %tw_partition_size%MB</string>
+		<string name="part_used">Verwendet: %tw_partition_used%MB</string>
+		<string name="part_free">Frei: %tw_partition_free%MB</string>
+		<string name="part_backup_size">Backup-Größe: %tw_partition_backup_size%MB</string>
+		<string name="resize_btn">Größe ändern</string>
+		<string name="resize_btn_s">Größe ändern</string>
+		<string name="resize_confirm">Größe von %tw_partition_name% ändern?</string>
+		<string name="resizing">Ändere Größe...</string>
+		<string name="resize_complete">Größenänderung abgeschlossen</string>
+		<string name="swipe_resize">Größenänderung bestätigen</string>
+		<string name="swipe_resize_s">Größe ändern</string>
+		<string name="repair_btn">Dateisystem reparieren</string>
+		<string name="repair_btn_s">Reparatur</string>
+		<string name="repair_confirm">Repariere %tw_partition_name%?</string>
+		<string name="repairing">Reparieren...</string>
+		<string name="repair_complete">Reparatur abgeschlossen</string>
+		<string name="swipe_repair">Partition reparieren</string>
+		<string name="swipe_repair_s">Reparieren</string>
+		<string name="change_fs_btn">Dateisystem ändern</string>
+		<string name="change_fs_btn_s">Ändern</string>
+		<string name="change_fs_for_hdr">Dateisystem für %tw_partition_name% ändern</string>
+		<string name="change_fs_for_hdr_s">Partition: %tw_partition_name% &gt; Dateisystem auswählen</string>
+		<string name="change_fs_warn1">Einige ROMs oder Kernel unterstützen möglicherweise manche</string>
+		<string name="change_fs_warn2">Dateisysteme nicht. Überlegt handeln!</string>
+		<string name="change_fs_confirm">%tw_partition_name% ändern?</string>
+		<string name="formatting">Formatierung...</string>
+		<string name="format_complete">Formatieren abgeschlossen</string>
+		<string name="swipe_change_fs">Dateisystem ändern</string>
+		<string name="swipe_change_s">Ändern</string>
+		<string name="back_btn">Zurück</string>
+		<string name="wipe_enc_btn">Verschlüsselung entfernen</string>
+		<string name="swipe_factory_reset">Werkseinstellungen herstellen</string>
+		<string name="repair_change_btn">Dateisystem reparieren oder ändern</string>
+		<string name="storage_hdr">Speicher: %tw_storage_display_name% (%tw_storage_free_size% MB)</string>
+		<string name="backup_hdr">Sicherung</string>
+		<string name="backup_confirm_hdr">Sicherung bestätigen</string>
+		<string name="encryption_tab">VERSCHLÜSSELUNG</string>
+		<string name="encryption">Verschlüsselung:</string>
+		<string name="name">Name:</string>
+		<string name="sel_part_backup">Zu sichernde Partitionen auswählen:</string>
+		<string name="storage">Speicherort:</string>
+		<string name="enc_disabled">deaktiviert - Passwort festlegen um zu aktivieren</string>
+		<string name="enc_enabled">aktiviert</string>
+		<string name="enable_backup_comp_chk">Komprimierung aktivieren</string>
+		<string name="skip_md5_backup_chk">MD5-Erstellung für die Sicherung überspringen</string>
+		<string name="disable_backup_space_chk">Prüfung auf freien Speicher deaktivieren</string>
+		<string name="refresh_sizes_btn">Größen aktualisieren</string>
+		<string name="swipe_backup">Sicherung erstellen</string>
+		<string name="append_date_btn">Datum anhängen</string>
+		<string name="backup_name_exists">Eine Sicherung mit diesem Namen existiert bereits!</string>
+		<string name="encrypt_backup">Sicherung verschlüsseln?</string>
+		<string name="enter_pass">Passwort eingeben:</string>
+		<string name="enter_pass2">Passwort erneut eingeben:</string>
+		<string name="pass_not_match">Die Passwörter stimmen nicht überein!</string>
+		<string name="partitions">Partitionen:</string>
+		<string name="disabled">Deaktiviert</string>
+		<string name="enabled">Aktiviert</string>
+		<string name="backup_name_hdr">Sicherung benennen</string>
+		<string name="progress">Fortschritt:</string>
+		<string name="backup_complete">Sicherung abgeschlossen</string>
+		<string name="restore_hdr">Wiederherstellen</string>
+		<string name="sel_backup_hdr">Sicherung auswählen</string>
+		<string name="restore_sel_store_hdr">Speicher: %tw_storage_display_name% (%tw_storage_free_size% MB)</string>
+		<string name="restore_sel_pack_fs">Wiederherzustellende Sicherung:</string>
+		<string name="restore_enc_backup_hdr">Verschlüsselte Sicherung</string>
+		<string name="restore_dec_fail">Passwort falsch, bitte erneut versuchen!</string>
+		<string name="del_backup_btn">Sicherung löschen</string>
+		<string name="del_backup_confirm">Sicherung löschen?</string>
+		<string name="del_backup_confirm2">Dies kann nicht rückgängig gemacht werden!</string>
+		<string name="deleting_backup">Sicherung wird gelöscht...</string>
+		<string name="backup_deleted">Sicherung gelöscht</string>
+		<string name="swipe_delete">Löschen bestätigen</string>
+		<string name="swipe_delete_s">Löschen</string>
+		<string name="restore_try_decrypt">Verschlüsselte Sicherung - Versuche Entschlüsselung</string>
+		<string name="restore_try_decrypt_s">Versuche Entschlüsselung</string>
+		<string name="restore_backup_date">Sicherung am %tw_restore_file_date% erstellt</string>
+		<string name="restore_sel_part">Wiederherzustellende Partitionen:</string>
+		<string name="restore_enable_md5_chk">MD5-Prüfung von Sicherungs-Dateien aktivieren</string>
+		<string name="restore_complete">Wiederherstellen abgeschlossen</string>
+		<string name="swipe_restore">Sicherung wiederherstellen</string>
+		<string name="swipe_restore_s">Wiederherstellen</string>
+		<string name="rename_backup_hdr">Sicherung umbenennen</string>
+		<string name="rename_backup_confirm">Sicherung umbenennen?</string>
+		<string name="rename_backup_confirm2">Dies kann nicht rückgängig gemacht werden!</string>
+		<string name="renaming_backup">Sicherung wird umbenannt...</string>
+		<string name="rename_backup_complete">Sicherung umbenannt</string>
+		<string name="swipe_to_rename">Name ändern</string>
+		<string name="swipe_rename">Umbenennen</string>
+		<string name="confirm_hdr">Bestätigen</string>
+		<string name="mount_hdr">Einhängen</string>
+		<string name="mount_sel_part">Einzuhängende Partitionen:</string>
+		<string name="mount_sys_ro_chk">System-Partition schreibgeschützt einhängen</string>
+		<string name="mount_sys_ro_s_chk">System nur lesend</string>
+		<string name="decrypt_data_btn">Daten-Partition entschlüsseln</string>
+		<string name="disable_mtp_btn">MTP deaktivieren</string>
+		<string name="enable_mtp_btn">MTP aktivieren</string>
+		<string name="mount_usb_storage_btn">USB-Speicher einhängen</string>
+		<string name="usb_storage_hdr">USB-Speicher</string>
+		<string name="usb_stor_mnt1">USB-Speicher eingehängt</string>
+		<string name="usb_stor_mnt2">Funktion "USB-Speicher auswerfen" auf Computer</string>
+		<string name="usb_stor_mnt3">ausführen, bevor die Verbindung getrennt wird!</string>
+		<string name="unmount_btn">Auswerfen</string>
+		<string name="rb_system_btn">System</string>
+		<string name="rb_poweroff_btn">Ausschalten</string>
+		<string name="rb_recovery_btn">Recovery</string>
+		<string name="rb_bootloader_btn">Bootloader</string>
+		<string name="rb_download_btn">Download</string>
+		<string name="turning_off">Ausschalten...</string>
+		<string name="swipe_power_off">Gerät ausschalten</string>
+		<string name="swipe_power_off_s">Ausschalten</string>
+		<string name="sys_ro_hdr">Unveränderte Systempartition</string>
+		<string name="sys_ro_keep">System-Partition schreibgeschützt einhängen?</string>
+		<string name="sys_rop1">TWRP kann die System Partition unverändert lassen,</string>
+		<string name="sys_rop2">um das Aufspielen offizieller Updates zu erleichtern.</string>
+		<string name="sys_rop3">Jedoch kann dann das Hersteller-ROM TWRP wieder</string>
+		<string name="sys_rop4">überschreiben und TWRP kann keinen Root-Zugriff einrichten.</string>
+		<string name="sys_rop5">Das Installieren von ZIPs oder ADB-Vorgänge könnten jedoch</string>
+		<string name="sys_rop6">trotzdem die System-Partition verändern.</string>
+		<string name="sys_rol1">TWRP kann die System-Partition unverändert lassen, um das Aufspielen offizieller Updates zu erleichtern.</string>
+		<string name="sys_rol2">Jedoch kann dann das Hersteller-ROM TWRP wieder überschreiben und TWRP kann keinen Root-Zugriff einrichten.</string>
+		<string name="sys_rol3">Das Installieren von ZIPs oder ADB-Vorgänge könnten jedoch trotzdem die System-Partition verändern.</string>
+		<string name="sys_ro_never_show_chk">Diesen Bildschirm nicht mehr anzeigen</string>
+		<string name="sys_ro_keep_ro_btn">Nur-Lesend belassen</string>
+		<string name="swipe_allow_mod">Veränderungen zulassen</string>
+		<string name="swipe_allow_mod_s">Zulassen</string>
+		<string name="settings_hdr">Einstellungen</string>
+		<string name="settings_gen_hdr">Allgemein</string>
+		<string name="settings_gen_s_hdr">Allgemein</string>
+		<string name="settings_gen_btn">Allgemein</string>
+		<string name="use_rmrf_chk">rm -rf anstatt formatieren verwenden</string>
+		<string name="use24clock_chk">24-Stunden-Format</string>
+		<string name="rev_navbar_chk">Navigationsleiste umkehren</string>
+		<string name="simact_chk">Benutzeraktionen für Design-Test simulieren</string>
+		<string name="simfail_chk">Fehlschlag von Benutzeraktionen simulieren</string>
+		<string name="ctr_navbar_rdo">Navigationsleisten-Schaltflächen zentrieren</string>
+		<string name="lft_navbar_rdo">Navigationsleisten-Schaltflächen linksbündig</string>
+		<string name="rht_navbar_rdo">Navigationsleisten-Schaltflächen rechtsbündig</string>
+		<string name="restore_defaults_btn">Standard herstellen</string>
+		<string name="settings_tz_btn">Zeitzone</string>
+		<string name="settings_screen_btn">Bildschirm</string>
+		<string name="settings_screen_bright_btn">Helligkeit</string>
+		<string name="settings_vibration_btn">Vibration</string>
+		<string name="settings_language_btn">Sprache</string>
+		<string name="time_zone_hdr">Zeitzone</string>
+		<string name="sel_tz_list">Zeitzone auswählen:</string>
+		<!-- Translator note: if it does not make sense to translate the locations or if it makes more sense,
+				feel free to change the location listed or drop the location entirely and just call it UTC -6 -->
+		<string name="utcm11">(UTC -11) Samoa, Midwayinseln</string>
+		<string name="utcm10">(UTC -10) Hawaii</string>
+		<string name="utcm9">(UTC -9) Alaska</string>
+		<string name="utcm8">(UTC -8) Pacific Time</string>
+		<string name="utcm7">(UTC -7) Mountain Time (USA)</string>
+		<string name="utcm6">(UTC -6) Central Time (USA)</string>
+		<string name="utcm5">(UTC -5) Eastern Time (USA)</string>
+		<string name="utcm4">(UTC -4) Atlantic Time (USA)</string>
+		<string name="utcm3">(UTC -3) Brasilien, Buenos Aires</string>
+		<string name="utcm2">(UTC -2) Mittelatlantik</string>
+		<string name="utcm1">(UTC -1) Azores, Cape Verde</string>
+		<string name="utc0">(UTC 0) London, Dublin, Lissabon</string>
+		<string name="utcp1">(UTC +1) Berlin, Brüssel, Paris</string>
+		<string name="utcp2">(UTC +2) Athen, Istanbul, Südafrika</string>
+		<string name="utcp3">(UTC +3) Moskau, Bagdad</string>
+		<string name="utcp4">(UTC +4) Abu Dhabi, Tiflis, Muscat</string>
+		<string name="utcp5">(UTC +5) Ekaterinburg, Islamabad</string>
+		<string name="utcp6">(UTC +6) Almaty, Dhaka, Colombo</string>
+		<string name="utcp7">(UTC +7) Bangkok, Hanoi, Jakarta</string>
+		<string name="utcp8">(UTC +8) Peking, Singapur, Hong Kong</string>
+		<string name="utcp9">(UTC +9) Tokio, Seoul, Yakutsk</string>
+		<string name="utcp10">(UTC +10) Ostaustralien, Guam</string>
+		<string name="utcp11">(UTC +11) Vladivostok, Salomonen</string>
+		<string name="utcp12">(UTC +12) Auckland, Wellington, Fidschi</string>
+		<string name="sel_tz_offset">Zeitverschiebung: %tw_time_zone_guioffset%</string>
+		<string name="tz_offset_none">Keine</string>
+		<string name="tz_offset_0">0</string>
+		<string name="tz_offset_15">15</string>
+		<string name="tz_offset_30">30</string>
+		<string name="tz_offset_45">45</string>
+		<string name="use_dst_chk">Sommerzeit verwenden</string>
+		<string name="curr_tz">Aktuelle Zeitzone: %tw_time_zone%</string>
+		<string name="curr_tz_s">Aktuelle Zeitzone:</string>
+		<string name="set_tz_btn">Zeitzone einstellen</string>
+		<string name="settings_screen_hdr">Bildschirm</string>
+		<string name="settings_screen_timeout_hdr">Bildschirm-Timeout</string>
+		<string name="enable_timeout_chk">Bildschirm automatisch ausschalten</string>
+		<string name="screen_to_slider">Zeit bis zum Ausschalten (in Sekunden):</string>
+		<string name="screen_to_slider_s">Ausschalten nach %tw_screen_timeout_secs% Sekunden (0 = deaktiviert): </string>
+		<string name="screen_to_na">Bildschirm-Abschaltung nicht verfügbar</string>
+		<string name="screen_bright_slider">Helligkeit: %tw_brightness_pct% %</string>
+		<string name="screen_bright_na">Helligkeit nicht verfügbar</string>
+		<string name="vibration_hdr">Vibration</string>
+		<string name="button_vibration_hdr">Tasten-Vibration</string>
+		<string name="kb_vibration_hdr">Tastatur-Vibration</string>
+		<string name="act_vibration_hdr">Aktion-Vibration</string>
+		<string name="button_vibration">Tasten-Vibration:</string>
+		<string name="kb_vibration">Tastatur-Vibration:</string>
+		<string name="act_vibration">Aktion-Vibration:</string>
+		<string name="select_language">Sprache auswählen:</string>
+		<string name="sel_lang_btn">Sprache auswählen</string>
+		<string name="set_language_btn">Sprache einstellen</string>
+		<string name="advanced_hdr">Erweitert</string>
+		<string name="copy_log_confirm">Log auf SD-Karte kopieren?</string>
+		<string name="copying_log">Kopiere Log auf SD-Karte...</string>
+		<string name="copy_log_complete">Log erfolgreich kopiert</string>
+		<string name="fix_context_btn">SELinux Kontexte</string>
+		<string name="part_sd_btn">SD-Karte partitionieren</string>
+		<string name="part_sd_s_btn">SD-Karte</string>
+		<string name="file_manager_btn">Dateimanager</string>
+		<string name="language_hdr">Sprache</string>
+		<string name="terminal_btn">Terminal</string>
+		<string name="reload_theme_btn">Theme neu laden</string>
+		<string name="dumlock_btn">HTC Dumlock</string>
+		<string name="inject_twrp_btn">TWRP injizieren</string>
+		<string name="inject_twrp_confirm">TWRP wieder injizieren?</string>
+		<string name="injecting_twrp">TWRP wird wieder injiziert...</string>
+		<string name="inject_twrp_complete">TWRP-Injektion abgeschlossen</string>
+		<string name="swipe_to_confirm">Aktion bestätigen</string>
+		<string name="part_sd_hdr">SD-Karte partitionieren</string>
+		<string name="invalid_partsd_sel">Es muss ein Wechseldatenträger ausgewählt sein!</string>
+		<string name="part_sd_lose">Es werden alle Dateien von der SD-Karte gelöscht!</string>
+		<string name="part_sd_undo">Diese Aktion kann nicht rückgängig gemacht werden!</string>
+		<string name="part_sd_ext_sz">EXT Grösse:</string>
+		<string name="part_sd_swap_sz">Grösse der Auslagerungsdatei:</string>
+		<string name="part_sd_m">-</string>
+		<string name="part_sd_p">+</string>
+		<string name="file_system">Dateisystem:</string>
+		<string name="swipe_part_sd">SD-Karte partitionieren</string>
+		<string name="swipe_part_sd_s">Partitionieren</string>
+		<string name="partitioning_sd">Partitioniere SD-Karte...</string>
+		<string name="partitioning_sd2">Dies wird einige Minuten dauern.</string>
+		<string name="part_sd_complete">Partitionierung abgeschlossen</string>
+		<string name="dumlock_hdr">HTC Dumlock</string>
+		<string name="dumlock_restore_btn">Orginale Boot-Partition wiederherstellen</string>
+		<string name="dumlock_restore_confirm">Orginales Image der Boot-Partition wiederherstellen?</string>
+		<string name="dumlock_restoring">Stelle originale Boot-Partition wieder her...</string>
+		<string name="dumlock_restore_complete">Wiederherstellen der orginalen Boot-Partition abgeschlossen</string>
+		<string name="dumlock_reflash_btn">Recovery erneut einspielen</string>
+		<string name="dumlock_reflash_confirm">Recovery in Boot-Partition einspielen?</string>
+		<string name="dumlock_reflashing">Spiele Recovery in Boot-Partition ein...</string>
+		<string name="dumlock_reflash_complete">Einspielen der Recovery in die Boot-Partition abgeschlossen</string>
+		<string name="dumlock_install_btn">HTC Dumlock installieren</string>
+		<string name="dumlock_install_confirm">HTC Dumlock Dateien ins ROM installieren?</string>
+		<string name="dumlock_installing">Installiere HTC Dumlock...</string>
+		<string name="dumlock_install_complete">HTC Dumlock Installation abgeschlossen</string>
+		<string name="swipe_to_unlock">Bildschirm entsperren</string>
+		<string name="swipe_unlock">Entsperren</string>
+		<string name="fm_hdr">Dateimanager</string>
+		<string name="fm_sel_file">Datei oder Ordner auswählen</string>
+		<string name="fm_type_folder">Ordner</string>
+		<string name="fm_type_file">Datei</string>
+		<string name="fm_choose_act">Aktion auswählen</string>
+		<string name="fm_selected">%tw_fm_type%:</string>
+		<string name="fm_copy_btn">Kopieren</string>
+		<string name="fm_copy_file_btn">Datei kopieren</string>
+		<string name="fm_copy_folder_btn">Ordner kopieren</string>
+		<string name="fm_copying">Kopiere</string>
+		<string name="fm_move_btn">Verschieben</string>
+		<string name="fm_moving">Verschiebe</string>
+		<string name="fm_chmod755_btn">chmod 755</string>
+		<string name="fm_chmod755ing">chmod 755</string>
+		<string name="fm_chmod_btn">chmod</string>
+		<string name="fm_delete_btn">Löschen</string>
+		<string name="fm_deleting">Wird gelöscht</string>
+		<string name="fm_rename_btn">Umbenennen</string>
+		<string name="fm_rename_file_btn">Datei umbennen</string>
+		<string name="fm_rename_folder_btn">Ordner umbenennen</string>
+		<string name="fm_renaming">Umbenennen</string>
+		<string name="fm_sel_dest">Zielordner auswählen</string>
+		<string name="fm_sel_curr_folder">Aktuellen Ordner auswählen</string>
+		<string name="fm_rename_hdr">Umbenennen</string>
+		<string name="fm_set_perms_hdr">Berechtigungen setzen</string>
+		<string name="fm_perms">Berechtigungen:</string>
+		<string name="fm_complete">Dateivorgang beendet</string>
+		<string name="decrypt_data_hdr">Daten-Partition entschlüsseln</string>
+		<string name="decrypt_data_enter_pass">Passwort eingeben:</string>
+		<string name="decrypt_data_failed">Passwort falsch, bitte erneut versuchen!</string>
+		<string name="decrypt_data_failed_pattern">Muster falsch, bitte erneut versuchen!</string>
+		<string name="decrypt_data_enter_pattern">Muster eingeben.</string>
+		<string name="decrypt_data_trying">Versuche Entschlüsselung</string>
+		<string name="term_hdr">Terminal</string>
+		<string name="term_s_hdr">Terminal</string>
+		<string name="term_kill_btn">BEENDEN</string>
+		<string name="term_sel_folder_hdr">Zum Stamm-Ordner navigieren</string>
+		<string name="adb_sideload_hdr">ADB Sideload</string>
+		<string name="sideload_wipe_dalvik_chk">Dalvik Cache löschen</string>
+		<string name="sideload_wipe_cache_chk">Cache löschen</string>
+		<string name="swipe_to_sideload">ADB Sideload starten</string>
+		<string name="swipe_sideload">Start</string>
+		<string name="sideload_confirm">ADB Sideload</string>
+		<string name="sideload_usage">Syntax: adb sideload Dateiname.zip</string>
+		<string name="sideload_complete">ADB Sideload abgeschlossen</string>
+		<string name="fix_contexts_hdr">SELinux Kontexte</string>
+		<string name="fix_contexts_note1">Das Korrigieren der Kontexte wird selten benötigt!</string>
+		<string name="fix_contexts_note2">Das Korrigieren der SELinux-Kontexte kann</string>
+		<string name="fix_contexts_note3">Startprobleme verursachen.</string>
+		<string name="swipe_to_fix_contexts">SELinux-Kontexte korrigieren</string>
+		<string name="swipe_fix_contexts">Korrigieren</string>
+		<string name="fixing_contexts">Korrigiere Kontexte...</string>
+		<string name="fix_contexts_complete">Korrektur der Kontexte abgeschlossen</string>
+		<string name="reboot_hdr">Neustart</string>
+		<string name="su_hdr">SuperSU-Check</string>
+		<string name="su_note1">Anscheinend besteht kein Root-Zugriff auf das Gerät.</string>
+		<string name="su_note2">SuperSU jetzt installieren?</string>
+		<string name="su_note3">Dies wird Root-Zugriff auf dem Gerät einrichten.</string>
+		<string name="su_cancel">Nicht installieren</string>
+		<string name="swipe_su_to_install">Installation starten</string>
+		<string name="swipe_su_install">Installieren</string>
+		<string name="su_installing">Installiere SuperSU</string>
+		<string name="sel_storage_list">Speicher auswählen</string>
+		<string name="ok_btn">OK</string>
+
+		<!-- Various console messages - these consist of user displayed messages, oftentimes errors -->
+		<string name="no_kernel_selinux">Dieser Kernel hat keine Leseunterstützung für SELinux-Kontexte.</string>
+		<string name="full_selinux">Volle SELinux-Unterstützung ist vorhanden.</string>
+		<string name="no_selinux">Keine SELinux-Unterstützung vorhanden (kein libselinux).</string>
+		<string name="mtp_enabled">MTP aktiviert</string>
+		<string name="mtp_crash">MTP abgestürzt, MTP wird künftig während Bootvorgang nicht gestartet.</string>
+		<string name="decrypt_success">Erfolgreich mit dem Standardpasswort entschlüsselt.</string>
+		<string name="unable_to_decrypt">Entschlüsselung mit Standardpasswort nicht möglich. Eventuell muss die Daten-Partition formatiert werden.</string>
+		<string name="generating_md51">Generiere MD5</string>
+		<!-- Message displayed during a backup if we are generating an MD5, ideally, leave the leading " * " to help align and separate this text from other console text -->
+		<string name="generating_md52"> * generiere MD5...</string>
+		<string name="md5_created"> * MD5 erstellt.</string>
+		<string name="md5_error"> * MD5-Fehler!</string>
+		<string name="md5_compute_error"> * Fehler bei MD5-Berechnung.</string>
+		<string name="current_date">(Aktuelles Datum)</string>
+		<string name="auto_generate">(Automatisch generiert)</string>
+		<string name="unable_to_locate_partition">Kann '{1}' Partition für Sicherungsberechnungen nicht finden.</string>
+		<string name="no_partition_selected">Keine Partitionen für die Sicherung ausgewählt.</string>
+		<string name="total_partitions_backup"> * Anzahl der zu sichernden Partitionen: {1}</string>
+		<string name="total_backup_size"> * Gesamtgröße aller Daten: {1}MB</string>
+		<string name="available_space"> * Verfügbare Speicherplatz: {1}MB</string>
+		<string name="unable_locate_storage">Kann Sicherungsgerät nicht finden.</string>
+		<string name="no_space">Zu wenig freier Speicherplatz.</string>
+		<string name="backup_started">[SICHERUNG GESTARTET]</string>
+		<string name="backup_folder"> * Ordner für Sicherung: {1}</string>
+		<string name="fail_backup_folder">Ordner für Sicherung konnte nicht erstellt werden.</string>
+		<string name="avg_backup_fs">Durchschnittliche Sicherungsgeschwindigkeit für Dateisysteme: {1} MB/sek</string>
+		<string name="avg_backup_img">Durchschnittliche Sicherungsgeschwindigkeit für abgebildete Laufwerke: {1} MB/sek</string>
+		<string name="total_backed_size">[INSGESAMT {1} MB GESICHERT]</string>
+		<string name="backup_completed">[SICHERUNG ABGESCHLOSSEN IN {1} SEKUNDEN]</string>
+		<string name="restore_started">[WIEDERHERSTELLEN GESTARTET]</string>
+		<string name="restore_folder">Wiederherstellen aus Ordner: '{1}'</string>
+		<!-- {1} is the partition display name and {2} is the number of seconds -->
+		<string name="restore_part_done">[{1} fertiggestellt ({2} Sekunden)]</string>
+		<string name="verifying_md5">Überprüfe MD5</string>
+		<string name="skip_md5">Überspringe MD5-Prüfung aufgrund Benutzereinstellungen.</string>
+		<string name="calc_restore">Berechne Wiederherstellungsinformationen...</string>
+		<string name="restore_read_only">Kann {1} nicht wiederherstellen -- Partition schreibgeschützt.</string>
+		<string name="restore_unable_locate">Kann wiederherzustellende '{1}'-Partition nicht finden.</string>
+		<string name="no_part_restore">Keine Partitionen zur Wiederherstellung ausgewählt.</string>
+		<string name="restore_part_count">{1} Partitionen wiederherstellen...</string>
+		<string name="total_restore_size">Insgesamt wiederherzustellen: {1}MB</string>
+		<string name="updating_system_details">Aktualisieren der System-Details</string>
+		<string name="restore_completed">[WIEDERHERSTELLEN ABGESCHLOSSEN IN {1} SEKUNDEN]</string>
+		<!-- {1} is the path we could not open, {2} is strerror output -->
+		<string name="error_opening_strerr">Fehler beim Öffnen: '{1}' ({2})</string>
+		<string name="unable_locate_part_backup_name">Partition nicht anhand des Sicherungsnamens ermittelbar: '{1}'</string>
+		<string name="unable_find_part_path">Partition für Pfad '{1}' nicht gefunden</string>
+		<string name="update_part_details">Partitions-Informationen werden aktualisiert...</string>
+		<string name="update_part_details_done">...Fertig</string>
+		<string name="wiping_dalvik">Dalvik Cache-Verzeichnisse bereinigen...</string>
+		<string name="cleaned">Bereinigt: {1}...</string>
+		<string name="dalvik_done">-- Dalvik Cache-Verzeichnisse bereinigt!</string>
+		<string name="no_andsec">Keine "Android Secure"-Partitionen gefunden.</string>
+		<string name="unable_to_locate">{1} nicht gefunden.</string>
+		<string name="wiping_datamedia">Lösche internen Speicher -- /data/media...</string>
+		<string name="unable_to_mount">Kann {1} nicht einhängen</string>
+		<string name="unable_to_mount_internal">Kann internen Speicher nicht einhängen</string>
+		<string name="unable_to_mount_storage">Kann Speicher nicht einhängen</string>
+		<string name="fail_decrypt">Entschlüsselung der Daten-Partition fehlgeschlagen.</string>
+		<string name="no_crypto_support">In diese Version wurde keine Krypto-Unterstützung eingebunden.</string>
+		<string name="decrypt_success_dev">Erfolgreich mit Standardpasswort entschlüsselt.</string>
+		<string name="done">Abgeschlossen.</string>
+		<string name="start_partition_sd">Partitioniere SD Karte...</string>
+		<string name="partition_sd_locate">Zu partitionierendes Gerät nicht gefunden.</string>
+		<string name="ext_swap_size">EXT + Auslagerung ist grösser als die SD-Karte.</string>
+		<string name="remove_part_table">Entferne Partitionstabelle...</string>
+		<string name="unable_rm_part">Partitionstabelle kann nicht entfernt werden.</string>
+		<string name="create_part">Erstelle {1}-Partition...</string>
+		<string name="unable_to_create_part">{1}-Partition kann nicht erstellt werden.</string>
+		<string name="format_sdext_as">Formatiere sd-ext als {1}...</string>
+		<string name="part_complete">Partitionierung abgeschlossen.</string>
+		<string name="unable_to_open">'{1}' kann nicht geöffnet werden.</string>
+		<string name="mtp_already_enabled">MTP bereits aktiviert</string>
+		<string name="mtp_fail">Fehler beim Aktivieren von MTP</string>
+		<string name="no_mtp">MTP-Unterstützung nicht integriert</string>
+		<string name="image_flash_start">[IMAGE-DATEI WIRD AUFGESPIELT]</string>
+		<string name="img_to_flash">Aufzuspielendes Image: '{1}'</string>
+		<string name="flash_unable_locate">'{1}'-Partition wurde nicht gefunden.</string>
+		<string name="no_part_flash">Keine Partitionen ausgewählt.</string>
+		<string name="too_many_flash">Zu viele Partitionen ausgewählt.</string>
+		<string name="invalid_flash">Ungültige Partitions-Auswahl.</string>
+		<string name="flash_done">[IMAGE EINSPIELEN ABGESCHLOSSEN]</string>
+		<string name="wiping">Lösche {1}</string>
+		<string name="repair_not_exist">{1} existiert nicht! Reparieren nicht möglich!</string>
+		<string name="repairing_using">Reparatur von {1} mit {2}...</string>
+		<string name="unable_repair">{1} kann nicht repariert werden.</string>
+		<string name="mount_data_footer">/data konnte nicht eingehängt werden und Krypto-Signatur wurde nicht gefunden.</string>
+		<!-- {1} is the folder name that we could not create, {2} is strerror output -->
+		<string name="create_folder_strerr">Ordner '{1}' konnte nicht angelegt werden ({2}).</string>
+		<!-- {1} is the folder name that we could not mount, {2} is strerror output -->
+		<string name="fail_mount">'{1}' konnte nicht eingehängt werden ({2})</string>
+		<!-- {1} is the folder name that we could not unmount, {2} is strerror output -->
+		<string name="fail_unmount">'{1}' konnte nicht eingehängt werden ({2})</string>
+		<string name="cannot_resize">Größe von {1} kann nicht geändert werden.</string>
+		<string name="repair_resize">{1} wird repariert. Danach wird die Größe geändert.</string>
+		<string name="unable_resize">Größe von {1} kann nicht geändert werden.</string>
+		<string name="no_md5_found">Keine MD5-Datei für '{1}' gefunden. Bitte MD5-Prüfung für Wiederherstellung deaktivieren.</string>
+		<string name="md5_fail_match">MD5-Prüfung für '{1}' fehlgeschlagen.</string>
+		<string name="fail_decrypt_tar">TAR-Datei '{1}' konnte nicht entschlüsselt werden.</string>
+		<string name="format_data_msg">Ein Neustart von TWRP kann notwendig sein, damit /data wieder verwendet werden kann.</string>
+		<string name="format_data_err">Formatierung zum Entfernen der Verschlüsselung kann nicht durchgeführt werden.</string>
+		<string name="formatting_using">Formatiere {1} mit {2}...</string>
+		<string name="unable_to_wipe">{1} kann nicht gelöscht werden.</string>
+		<string name="cannot_wipe">Partition {1} kann nicht gelöscht werden.</string>
+		<string name="remove_all">Entferne alle Dateien unter '{1}'</string>
+		<string name="wiping_data">Lösche Daten, aber verschone internen Speicher...</string>
+		<string name="backing_up">Sichere {1}...</string>
+		<string name="backing">Sichere</string>
+		<string name="backup_size">Sicherung von '{1}' hat 0 Byte.</string>
+		<string name="datamedia_fs_restore">WARNUNG: Diese Sicherung wurde mit dem Dateisystem {1} erstellt! Es kann sein, dass wieder zu {1} gewechselt werden muss, damit das Gerät nach der Wiederherstellung auch startet.</string>
+		<string name="restoring">Wiederherstellung läuft</string>
+		<string name="restoring_hdr">Wiederherstellung läuft</string>
+		<string name="recreate_folder_err">Ordner {1} kann nicht wiederhergestellt werden.</string>
+		<string name="img_size_err">Image ist zu groß für das Gerät</string>
+		<string name="flashing">Einspielen von {1}...</string>
+		<string name="backup_folder_set"> * Ordner für Sicherung: {1}</string>
+		<string name="locate_backup_err">Sicherung '{1}' nicht gefunden</string>
+		<string name="set_restore_opt">Setze Wiederherstellungs-Optionen: '{1}':</string>
+		<string name="md5_check_skip">MD5-Prüfung ist deaktiviert</string>
+		<string name="ors_encrypt_restore_err">Eine verschlüsselte Sicherung kann nicht per OpenRecoveryScript wiederhergestellt werden.</string>
+		<string name="mounting">Einhängen</string>
+		<string name="unmounting">Auswerfen</string>
+		<string name="mounted">'{1}' eingehängt</string>
+		<string name="unmounted">'{1}' ausgeworfen</string>
+		<string name="setting">Setze '{1}' auf '{2}'</string>
+		<string name="setting_empty">Setze '{1}' auf leer</string>
+		<string name="making_dir1">Erstelle Verzeichnis</string>
+		<string name="making_dir2">Erstelle Verzeichnis: '{1}'</string>
+		<string name="running_command">Führe Befehl aus</string>
+		<string name="sideload">ADB Sideload</string>
+		<string name="start_sideload">Starte ADB Sideload...</string>
+		<string name="need_new_adb">Für dieses Gerät wird ADB 1.0.32 oder neuer benötigt.</string>
+		<string name="no_pwd">Kein Passwort angegeben.</string>
+		<string name="done_ors">Skript wurde verarbeitet</string>
+		<string name="injecttwrp">Injiziere TWRP in das Boot-Image...</string>
+		<string name="zip_err">Fehler beim Installieren von ZIP '{1}'</string>
+		<string name="installing_zip">Installiere Zip: %tw_file%</string>
+		<string name="select_backup_opt">Setze Sicherungs-Optionen:</string>
+		<string name="compression_on">Komprimierung ist aktiviert</string>
+		<string name="md5_off">MD5-Generierung ist deaktiviert</string>
+		<string name="backup_fail">Sicherung fehlgeschlagen</string>
+		<string name="backup_clean">Sicherung fehlgeschlagen, bereinige Sicherungs-Verzeichnis</string>
+		<string name="running_recovery_commands">Führe Recovery-Befehle aus</string>
+		<string name="recovery_commands_complete">Recovery-Befehle ausgeführt</string>
+		<string name="running_ors">Führe OpenRecoveryScript aus</string>
+		<string name="ors_complete">OpenRecoveryScript ausgeführt</string>
+		<string name="no_updater_binary">'{1}' konnte in der ZIP nicht gefunden werden.</string>
+		<string name="check_for_md5">Suche nach MD5-Datei...</string>
+		<string name="fail_sysmap">'{1}' kann nicht zugeordnet werden</string>
+		<string name="verify_zip_sig">Überprüfe ZIP-Signatur...</string>
+		<string name="verify_zip_fail">Prüfung der ZIP-Signatur fehlgeschlagen!</string>
+		<string name="verify_zip_done">Prüfung der ZIP-Signatur erfolgreich.</string>
+		<string name="zip_corrupt">ZIP-Datei ist beschädigt!</string>
+		<string name="no_md5">MD5-Prüfung übersprungen: keine MD5-Datei gefunden</string>
+		<string name="md5_fail">MD5 stimmt nicht überein</string>
+		<string name="md5_match">MD5 stimmt überein</string>
+		<string name="pid_signal">Prozess {1} endete mit Meldung: {2}</string>
+		<string name="pid_error">Prozess {1} endete mit FEHLER: {2}</string>
+		<string name="install_dumlock">Installiere HTC Dumlock in System-Partition...</string>
+		<string name="dumlock_restore">Stelle originale Boot-Partition wieder her...</string>
+		<string name="dumlock_reflash">Recovery auf Boot-Partition einspielen...</string>
+		<string name="run_script">Führe {1}-Skript aus...</string>
+		<string name="rename_stock">Hersteller-Recovery in "/system" wurde umbenannt, damit das Hersteller-ROM TWRP nicht überschreibt.</string>
+		<string name="split_backup">Sicherungs-Datei wird in mehrere Archive aufgeteilt...</string>
+		<string name="backup_error">Fehler beim Erstellen der Sicherung.</string>
+		<string name="restore_error">Fehler während der Wiederherstellung.</string>
+		<string name="split_thread">Teile Thread-ID {1} in Archiv {2}</string>
+		<!-- These 2 items are saved in the data manager instead of resource manager, so %llu, etc is correct instead of {1} -->
+		<string name="file_progress">%llu von %llu Dateien, %i%%</string>
+		<string name="size_progress">%lluMB von %lluMB, %i%%</string>
+		<string name="decrypt_cmd">Versuche die Daten-Partition per Kommandozeile zu entschlüsseln.</string>
+		<string name="base_pkg_err">Basis-Pakete konnten nicht geladen werden.</string>
+		<string name="simulating">Simuliere Aktionen...</string>
+		<string name="backup_cancel">Sicherung abgebrochen</string>
+		<string name="config_twrp">Konfiguriere TWRP...</string>
+		<string name="config_twrp_err">Konfigurieren von TWRP mit diesem Kernel nicht möglich.</string>
+		<string name="copy_log">Recovery-Log wurde nach {1} kopiert.</string>
+		<string name="max_queue">Maximale Anzahl an ZIP-Dateien erreicht!</string>
+		<string name="min_queue">Minimale Anzahl an ZIP-Dateien erreicht!</string>
+		<string name="screenshot_saved">Bildschirmfoto gespeichert unter {1}</string>
+		<string name="screenshot_err">Bildschirmfoto konnte nicht erstellt werden!</string>
+		<string name="zip_wipe_cache">Eine oder mehrere ZIP-Dateien wollen den Cache löschen -- Lösche Cache jetzt.</string>
+		<string name="and_sec_wipe_err">Android Secure kann nicht gelöscht werden</string>
+		<string name="dalvik_wipe_err">Löschen von Dalvik fehlgeschlagen</string>
+		<string name="auto_gen">(automatisch erstellt)</string>
+		<string name="curr_date">(aktuelles Datum)</string>
+		<string name="backup_name_len">Der Name der Sicherung ist zu lang.</string>
+		<string name="backup_name_invalid">Sicherungs-Name '{1}' enthält ungültige Zeichen: '{1}'</string>
+		<string name="no_real_sdcard">Dieses Gerät verwendet keine SD-Karte! Abbruch!</string>
+		<string name="cancel_sideload">ADB Sideload wird abgebrochen...</string>
+		<string name="change_fs_err">Fehler beim Ändern des Dateisystems.</string>
+		<string name="theme_ver_err">Theme-Version inkompatibel zu TWRP-Version. Standard-Theme wird verwendet.</string>
+		<string name="up_a_level">(Übergeordneter Ordner)</string>
+	</resources>
+</language>
\ No newline at end of file
diff --git a/gui/theme/common/languages/en.xml b/gui/theme/common/languages/en.xml
index 1bb9b68..4b7743a 100644
--- a/gui/theme/common/languages/en.xml
+++ b/gui/theme/common/languages/en.xml
@@ -505,7 +505,7 @@
 		<string name="restore_started">[RESTORE STARTED]</string>
 		<string name="restore_folder">Restore folder: '{1}'</string>
 		<!-- {1} is the partition display name and {2} is the number of seconds -->
-		<string name="restort_part_done">[{1} done ({2} seconds)]</string>
+		<string name="restore_part_done">[{1} done ({2} seconds)]</string>
 		<string name="verifying_md5">Verifying MD5</string>
 		<string name="skip_md5">Skipping MD5 check based on user setting.</string>
 		<string name="calc_restore">Calculating restore details...</string>
diff --git a/gui/theme/common/languages/es.xml b/gui/theme/common/languages/es.xml
deleted file mode 100644
index ec2b41d..0000000
--- a/gui/theme/common/languages/es.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0"?>
-
-<language>
-	<display>Español</display>
-
-	<resources>
-		<resource name="font" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
-		<resource name="mediumfont" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
-		<resource name="filelist" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
-		<resource name="fixed" type="fontoverride" filename="DroidSansMono.ttf" scale="100" />
-		<string name="install_btn">Instalar</string>
-	</resources>
-</language>
diff --git a/gui/theme/common/languages/fi.xml b/gui/theme/common/languages/fi.xml
deleted file mode 100644
index 51ed60d..0000000
--- a/gui/theme/common/languages/fi.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<?xml version="1.0"?>
-
-<language>
-	<display>Suomi</display>
-
-	<resources>
-		<resource name="font" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
-		<resource name="mediumfont" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
-		<resource name="filelist" type="fontoverride" filename="RobotoCondensed-Regular.ttf" scale="100" />
-		<resource name="fixed" type="fontoverride" filename="DroidSansMono.ttf" scale="100" />
-		<string name="install_btn">Asenna</string>
-	</resources>
-</language>
diff --git a/gui/theme/common/languages/ru.xml b/gui/theme/common/languages/ru.xml
index 7050421..451d113 100755
--- a/gui/theme/common/languages/ru.xml
+++ b/gui/theme/common/languages/ru.xml
@@ -508,7 +508,7 @@
 		<string name="restore_started">[ВОССТАНОВЛЕНИЕ НАЧАТО]</string>
 		<string name="restore_folder">Папка восстановления: '{1}'</string>
 		<!-- {1} is the partition display name and {2} is the number of seconds -->
-		<string name="restort_part_done">[{1} готово ({2} секунд)]</string>
+		<string name="restore_part_done">[{1} готово ({2} секунд)]</string>
 		<string name="verifying_md5">Проверка MD5</string>
 		<string name="skip_md5">Пропуск проверки MD5 согласно настроек.</string>
 		<string name="calc_restore">Вычисление информации о восстановлении...</string>
diff --git a/gui/theme/extra-languages/languages/zh_CN.xml b/gui/theme/extra-languages/languages/zh_CN.xml
index a73bec6..0d8bfd3 100644
--- a/gui/theme/extra-languages/languages/zh_CN.xml
+++ b/gui/theme/extra-languages/languages/zh_CN.xml
@@ -505,7 +505,7 @@
 		<string name="restore_started">[还原已经开始]</string>
 		<string name="restore_folder">还原目录：'{1}'</string>
 		<!-- {1} is the partition display name and {2} is the number of seconds -->
-		<string name="restort_part_done">[{1} 完成 ({2} 秒)]</string>
+		<string name="restore_part_done">[{1} 完成 ({2} 秒)]</string>
 		<string name="verifying_md5">正在校验 MD5</string>
 		<string name="skip_md5">正在跳过 MD5 检测基于用户设置。</string>
 		<string name="calc_restore">正在计算还原详情…</string>
diff --git a/gui/theme/extra-languages/languages/zh_TW.xml b/gui/theme/extra-languages/languages/zh_TW.xml
index e1c8b3d..b7d6b1e 100644
--- a/gui/theme/extra-languages/languages/zh_TW.xml
+++ b/gui/theme/extra-languages/languages/zh_TW.xml
@@ -505,7 +505,7 @@
 		<string name="restore_started">[已開始恢復]</string>
 		<string name="restore_folder">恢復檔案夾：'{1}'</string>
 		<!-- {1} is the partition display name and {2} is the number of seconds -->
-		<string name="restort_part_done">[{1}恢復完成({2}秒)]</string>
+		<string name="restore_part_done">[{1}恢復完成({2}秒)]</string>
 		<string name="verifying_md5">正在校驗MD5</string>
 		<string name="skip_md5">基於用戶設置，已跳過MD5檢查。</string>
 		<string name="calc_restore">正在計算恢復詳情…</string>
