diff --git a/app/src/main/java/com/philkes/notallyx/data/NotallyDatabase.kt b/app/src/main/java/com/philkes/notallyx/data/NotallyDatabase.kt
index 7895e580..3f7ed8b7 100644
--- a/app/src/main/java/com/philkes/notallyx/data/NotallyDatabase.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/NotallyDatabase.kt
@@ -114,6 +114,18 @@ abstract class NotallyDatabase : RoomDatabase() {
                 }
         }
 
+        fun clearInstance(context: Context) {
+            val preferences = NotallyXPreferences.getInstance(context)
+            instance?.value?.biometricLockObserver?.let {
+                preferences.biometricLock.removeObserver(it)
+            }
+            instance?.value?.dataInPublicFolderObserver?.let {
+                preferences.dataInPublicFolder.removeObserver(it)
+            }
+            instance?.value?.close()
+            instance = null
+        }
+
         private var testInstance: NotallyDatabase? = null
 
         private fun getTestDatabase(context: ContextWrapper): NotallyDatabase {
@@ -162,7 +174,7 @@ abstract class NotallyDatabase : RoomDatabase() {
                         Migration8,
                         Migration9,
                         Migration10,
-                        Migration11
+                        Migration11,
                     )
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                 System.loadLibrary("sqlcipher")
diff --git a/app/src/main/java/com/philkes/notallyx/data/dao/BaseNoteDao.kt b/app/src/main/java/com/philkes/notallyx/data/dao/BaseNoteDao.kt
index 1c4ea836..a13e5e26 100644
--- a/app/src/main/java/com/philkes/notallyx/data/dao/BaseNoteDao.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/dao/BaseNoteDao.kt
@@ -104,12 +104,12 @@ interface BaseNoteDao {
 
     @Insert suspend fun insert(baseNotes: List<BaseNote>): List<Long>
 
+    @Update suspend fun updateAll(baseNotes: List<BaseNote>)
+
     @Update(entity = BaseNote::class) suspend fun update(labelsInBaseNotes: List<LabelsInBaseNote>)
 
     @Query("SELECT COUNT(*) FROM BaseNote") fun count(): Int
 
-    @Query("DELETE FROM BaseNote") suspend fun deleteAll()
-
     @Query("DELETE FROM BaseNote WHERE id = :id") suspend fun delete(id: Long)
 
     @Query("DELETE FROM BaseNote WHERE id IN (:ids)") suspend fun delete(ids: LongArray)
diff --git a/app/src/main/java/com/philkes/notallyx/data/dao/CommonDao.kt b/app/src/main/java/com/philkes/notallyx/data/dao/CommonDao.kt
index e4965f51..ef5d250d 100644
--- a/app/src/main/java/com/philkes/notallyx/data/dao/CommonDao.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/dao/CommonDao.kt
@@ -1,5 +1,6 @@
 package com.philkes.notallyx.data.dao
 
+import android.util.Log
 import androidx.room.Dao
 import androidx.room.Transaction
 import com.philkes.notallyx.data.NotallyDatabase
@@ -46,7 +47,11 @@ abstract class CommonDao(private val database: NotallyDatabase) {
     }
 
     @Transaction
-    open suspend fun importBackup(baseNotes: List<BaseNote>, labels: List<Label>): ImportResult {
+    open suspend fun importBackup(
+        baseNotes: List<BaseNote>,
+        labels: List<Label>,
+        readCorrupted: Int,
+    ): ImportResult {
         val dao = database.getBaseNoteDao()
         // Insert notes, splitting oversized text notes instead of truncating
         var insertedCount = 0
@@ -70,7 +75,11 @@ abstract class CommonDao(private val database: NotallyDatabase) {
         labelDao.insert(
             labels.mapIndexed { index, label -> Label(label.value, maxOrder + 1 + index) }
         )
-        return ImportResult(inserted = insertedCount, duplicates = duplicates)
+        return ImportResult(
+            inserted = insertedCount,
+            duplicates = duplicates,
+            corruptedNotes = readCorrupted,
+        )
     }
 
     /**
@@ -83,6 +92,7 @@ abstract class CommonDao(private val database: NotallyDatabase) {
         baseNotes: List<BaseNote>,
         originalIds: List<Long>,
         labels: List<Label>,
+        readCorrupted: Int,
     ): ImportResult {
         val baseNoteDao = database.getBaseNoteDao()
 
@@ -90,7 +100,7 @@ abstract class CommonDao(private val database: NotallyDatabase) {
         val idMap = HashMap<Long, Long>(originalIds.size)
         // Keep all inserted note ids with their spans for remapping pass
         val insertedParts = ArrayList<Pair<Long, List<SpanRepresentation>>>()
-
+        var corrupted = readCorrupted
         var insertedCount = 0
         var duplicates = 0
         for (i in baseNotes.indices) {
@@ -105,11 +115,21 @@ abstract class CommonDao(private val database: NotallyDatabase) {
                 continue
             }
             val (firstId, parts) =
-                if (original.type == Type.NOTE && original.body.length > MAX_BODY_CHAR_LENGTH) {
-                    NoteSplitUtils.splitAndInsertForImport(original, baseNoteDao)
-                } else {
-                    val newId = baseNoteDao.insert(original.copy(id = 0))
-                    Pair(newId, listOf(Pair(newId, original.spans)))
+                try {
+                    if (original.type == Type.NOTE && original.body.length > MAX_BODY_CHAR_LENGTH) {
+                        NoteSplitUtils.splitAndInsertForImport(original, baseNoteDao)
+                    } else {
+                        val newId = baseNoteDao.insert(original.copy(id = 0))
+                        Pair(newId, listOf(Pair(newId, original.spans)))
+                    }
+                } catch (e: Exception) {
+                    Log.e(
+                        "Import",
+                        "Failed to import note ${original.title} (id: ${original.id}), skipping it as corrupted",
+                        e,
+                    )
+                    corrupted++
+                    continue
                 }
             val oldId = originalIds.getOrNull(i)
             if (oldId != null) idMap[oldId] = firstId
@@ -134,7 +154,11 @@ abstract class CommonDao(private val database: NotallyDatabase) {
                     } else span
                 }
             if (changed) {
-                baseNoteDao.updateSpans(noteId, updated)
+                try {
+                    baseNoteDao.updateSpans(noteId, updated)
+                } catch (e: Exception) {
+                    Log.e("Import", "Failed to update spans for noteId: ${noteId})", e)
+                }
             }
         }
 
@@ -143,7 +167,11 @@ abstract class CommonDao(private val database: NotallyDatabase) {
         labelDaoForRemap.insert(
             labels.mapIndexed { index, label -> Label(label.value, maxOrderForRemap + 1 + index) }
         )
-        return ImportResult(inserted = insertedCount, duplicates = duplicates)
+        return ImportResult(
+            inserted = insertedCount,
+            duplicates = duplicates,
+            corruptedNotes = corrupted,
+        )
     }
 
     /**
diff --git a/app/src/main/java/com/philkes/notallyx/data/imports/ExternalImporter.kt b/app/src/main/java/com/philkes/notallyx/data/imports/ExternalImporter.kt
index 51aa3c4d..21d654ad 100644
--- a/app/src/main/java/com/philkes/notallyx/data/imports/ExternalImporter.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/imports/ExternalImporter.kt
@@ -4,6 +4,7 @@ import android.app.Application
 import android.net.Uri
 import androidx.lifecycle.MutableLiveData
 import com.philkes.notallyx.data.model.BaseNote
+import com.philkes.notallyx.presentation.view.misc.Progress
 import java.io.File
 
 interface ExternalImporter {
@@ -18,6 +19,6 @@ interface ExternalImporter {
         app: Application,
         source: Uri,
         destination: File,
-        progress: MutableLiveData<ImportProgress>? = null,
+        progress: MutableLiveData<Progress>? = null,
     ): Pair<List<BaseNote>, File?>
 }
diff --git a/app/src/main/java/com/philkes/notallyx/data/imports/NotesImporter.kt b/app/src/main/java/com/philkes/notallyx/data/imports/NotesImporter.kt
index 03082b7f..8807b7ff 100644
--- a/app/src/main/java/com/philkes/notallyx/data/imports/NotesImporter.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/imports/NotesImporter.kt
@@ -10,14 +10,15 @@ import com.philkes.notallyx.data.NotallyDatabase
 import com.philkes.notallyx.data.dao.BaseNoteDao.Companion.MAX_BODY_CHAR_LENGTH
 import com.philkes.notallyx.data.imports.evernote.EvernoteImporter
 import com.philkes.notallyx.data.imports.google.GoogleKeepImporter
+import com.philkes.notallyx.data.imports.json.JsonImporter
 import com.philkes.notallyx.data.imports.quillpad.QuillpadImporter
-import com.philkes.notallyx.data.imports.txt.JsonImporter
 import com.philkes.notallyx.data.imports.txt.PlainTextImporter
 import com.philkes.notallyx.data.model.Audio
 import com.philkes.notallyx.data.model.FileAttachment
 import com.philkes.notallyx.data.model.Label
 import com.philkes.notallyx.data.model.Type
 import com.philkes.notallyx.data.model.toText
+import com.philkes.notallyx.presentation.view.misc.Progress
 import com.philkes.notallyx.presentation.viewmodel.NotallyModel
 import com.philkes.notallyx.utils.MIME_TYPE_ZIP
 import com.philkes.notallyx.utils.NoteSplitUtils
@@ -27,14 +28,14 @@ import com.philkes.notallyx.utils.backup.importImage
 import java.io.File
 import java.util.concurrent.atomic.AtomicInteger
 
-data class ImportResult(val inserted: Int, val duplicates: Int)
+data class ImportResult(val inserted: Int, val duplicates: Int, val corruptedNotes: Int)
 
 class NotesImporter(private val app: Application, private val database: NotallyDatabase) {
 
     suspend fun import(
         uri: Uri,
         importSource: ImportSource,
-        progress: MutableLiveData<ImportProgress>? = null,
+        progress: MutableLiveData<Progress>? = null,
     ): ImportResult {
         val tempDir = File(app.cacheDir, IMPORT_CACHE_FOLDER)
         if (!tempDir.exists()) {
@@ -80,24 +81,35 @@ class NotesImporter(private val app: Application, private val database: NotallyD
             // Insert notes with split handling for oversized text notes, skipping duplicates
             val dao = database.getBaseNoteDao()
             var insertedCount = 0
+            var corruptedCount = 0
             val totalCandidates = notes.size
             notes.forEach { note ->
                 val dup = findDuplicateId(note)
                 if (dup == null) {
-                    if (note.type == Type.NOTE && note.body.length > MAX_BODY_CHAR_LENGTH) {
-                        // Split into parts, preserving spans and adding navigation links
-                        NoteSplitUtils.splitAndInsertForImport(note, dao)
-                    } else {
-                        // Regular insert; ensure id is auto-generated
-                        dao.insert(note.copy(id = 0))
+                    try {
+                        if (note.type == Type.NOTE && note.body.length > MAX_BODY_CHAR_LENGTH) {
+                            // Split into parts, preserving spans and adding navigation links
+                            NoteSplitUtils.splitAndInsertForImport(note, dao)
+                        } else {
+                            // Regular insert; ensure id is auto-generated
+                            dao.insert(note.copy(id = 0))
+                        }
+                        insertedCount++
+                    } catch (e: Exception) {
+                        Log.e(
+                            "Import",
+                            "Failed to import note ${note.title} (id: ${note.id}), skipping it as corrupted",
+                            e,
+                        )
+                        corruptedCount++
                     }
-                    insertedCount++
                 }
             }
             progress?.postValue(ImportProgress(inProgress = false))
             return ImportResult(
                 inserted = insertedCount,
-                duplicates = (totalCandidates - insertedCount),
+                duplicates = (totalCandidates - insertedCount - corruptedCount),
+                corruptedNotes = corruptedCount,
             )
         } finally {
             tempDir.deleteRecursively()
@@ -108,7 +120,7 @@ class NotesImporter(private val app: Application, private val database: NotallyD
         files: List<FileAttachment>,
         sourceFolder: File,
         fileType: NotallyModel.FileType,
-        progress: MutableLiveData<ImportProgress>?,
+        progress: MutableLiveData<Progress>?,
         total: Int?,
         counter: AtomicInteger?,
     ) {
@@ -136,7 +148,7 @@ class NotesImporter(private val app: Application, private val database: NotallyD
     private suspend fun importAudios(
         audios: List<Audio>,
         sourceFolder: File,
-        progress: MutableLiveData<ImportProgress>?,
+        progress: MutableLiveData<Progress>?,
         totalFiles: Int,
         counter: AtomicInteger,
     ) {
diff --git a/app/src/main/java/com/philkes/notallyx/data/imports/evernote/EvernoteImporter.kt b/app/src/main/java/com/philkes/notallyx/data/imports/evernote/EvernoteImporter.kt
index 86ba900d..990a7172 100644
--- a/app/src/main/java/com/philkes/notallyx/data/imports/evernote/EvernoteImporter.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/imports/evernote/EvernoteImporter.kt
@@ -19,6 +19,7 @@ import com.philkes.notallyx.data.model.Folder
 import com.philkes.notallyx.data.model.ListItem
 import com.philkes.notallyx.data.model.NoteViewMode
 import com.philkes.notallyx.data.model.Type
+import com.philkes.notallyx.presentation.view.misc.Progress
 import com.philkes.notallyx.utils.log
 import com.philkes.notallyx.utils.startsWithAnyOf
 import com.philkes.notallyx.utils.write
@@ -39,7 +40,7 @@ class EvernoteImporter : ExternalImporter {
         app: Application,
         source: Uri,
         destination: File,
-        progress: MutableLiveData<ImportProgress>?,
+        progress: MutableLiveData<Progress>?,
     ): Pair<List<BaseNote>, File> {
         progress?.postValue(ImportProgress(indeterminate = true))
         if (MimeTypeMap.getFileExtensionFromUrl(source.toString()) != "enex") {
@@ -81,7 +82,7 @@ class EvernoteImporter : ExternalImporter {
         app: Application,
         resources: Collection<EvernoteResource>,
         dir: File,
-        progress: MutableLiveData<ImportProgress>? = null,
+        progress: MutableLiveData<Progress>? = null,
     ) {
         progress?.postValue(
             ImportProgress(total = resources.size, stage = ImportStage.EXTRACT_FILES)
diff --git a/app/src/main/java/com/philkes/notallyx/data/imports/google/GoogleKeepImporter.kt b/app/src/main/java/com/philkes/notallyx/data/imports/google/GoogleKeepImporter.kt
index 5b541024..f4b15ab4 100644
--- a/app/src/main/java/com/philkes/notallyx/data/imports/google/GoogleKeepImporter.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/imports/google/GoogleKeepImporter.kt
@@ -16,6 +16,7 @@ import com.philkes.notallyx.data.model.Folder
 import com.philkes.notallyx.data.model.ListItem
 import com.philkes.notallyx.data.model.NoteViewMode
 import com.philkes.notallyx.data.model.Type
+import com.philkes.notallyx.presentation.view.misc.Progress
 import com.philkes.notallyx.utils.listFilesRecursive
 import com.philkes.notallyx.utils.log
 import java.io.File
@@ -41,7 +42,7 @@ class GoogleKeepImporter : ExternalImporter {
         app: Application,
         source: Uri,
         destination: File,
-        progress: MutableLiveData<ImportProgress>?,
+        progress: MutableLiveData<Progress>?,
     ): Pair<List<BaseNote>, File> {
         progress?.postValue(ImportProgress(indeterminate = true, stage = ImportStage.EXTRACT_FILES))
         val dataFolder =
diff --git a/app/src/main/java/com/philkes/notallyx/data/imports/json/JsonImporter.kt b/app/src/main/java/com/philkes/notallyx/data/imports/json/JsonImporter.kt
index 09d4d91e..71720580 100644
--- a/app/src/main/java/com/philkes/notallyx/data/imports/json/JsonImporter.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/imports/json/JsonImporter.kt
@@ -1,13 +1,13 @@
-package com.philkes.notallyx.data.imports.txt
+package com.philkes.notallyx.data.imports.json
 
 import android.app.Application
 import android.net.Uri
 import androidx.documentfile.provider.DocumentFile
 import androidx.lifecycle.MutableLiveData
 import com.philkes.notallyx.data.imports.ExternalImporter
-import com.philkes.notallyx.data.imports.ImportProgress
 import com.philkes.notallyx.data.model.BaseNote
 import com.philkes.notallyx.data.model.toBaseNote
+import com.philkes.notallyx.presentation.view.misc.Progress
 import com.philkes.notallyx.utils.MIME_TYPE_JSON
 import java.io.BufferedReader
 import java.io.File
@@ -19,7 +19,7 @@ class JsonImporter : ExternalImporter {
         app: Application,
         source: Uri,
         destination: File,
-        progress: MutableLiveData<ImportProgress>?,
+        progress: MutableLiveData<Progress>?,
     ): Pair<List<BaseNote>, File?> {
         val notes = mutableListOf<BaseNote>()
         fun readJsonFiles(file: DocumentFile) {
diff --git a/app/src/main/java/com/philkes/notallyx/data/imports/quillpad/QuillpadImporter.kt b/app/src/main/java/com/philkes/notallyx/data/imports/quillpad/QuillpadImporter.kt
index 3882f79d..3d5f9511 100644
--- a/app/src/main/java/com/philkes/notallyx/data/imports/quillpad/QuillpadImporter.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/imports/quillpad/QuillpadImporter.kt
@@ -17,6 +17,7 @@ import com.philkes.notallyx.data.model.ListItem
 import com.philkes.notallyx.data.model.NoteViewMode
 import com.philkes.notallyx.data.model.Reminder
 import com.philkes.notallyx.data.model.Type
+import com.philkes.notallyx.presentation.view.misc.Progress
 import com.philkes.notallyx.utils.getMimeType
 import com.philkes.notallyx.utils.moveAllFiles
 import com.philkes.notallyx.utils.toMillis
@@ -45,7 +46,7 @@ class QuillpadImporter : ExternalImporter {
         app: Application,
         source: Uri,
         destination: File,
-        progress: MutableLiveData<ImportProgress>?,
+        progress: MutableLiveData<Progress>?,
     ): Pair<List<BaseNote>, File> {
         progress?.postValue(ImportProgress(indeterminate = true, stage = ImportStage.EXTRACT_FILES))
         val dataFolder =
diff --git a/app/src/main/java/com/philkes/notallyx/data/imports/txt/PlainTextImporter.kt b/app/src/main/java/com/philkes/notallyx/data/imports/txt/PlainTextImporter.kt
index 5dc531d3..bcc9f684 100644
--- a/app/src/main/java/com/philkes/notallyx/data/imports/txt/PlainTextImporter.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/imports/txt/PlainTextImporter.kt
@@ -5,13 +5,13 @@ import android.net.Uri
 import androidx.documentfile.provider.DocumentFile
 import androidx.lifecycle.MutableLiveData
 import com.philkes.notallyx.data.imports.ExternalImporter
-import com.philkes.notallyx.data.imports.ImportProgress
 import com.philkes.notallyx.data.imports.markdown.parseBodyAndSpansFromMarkdown
 import com.philkes.notallyx.data.model.BaseNote
 import com.philkes.notallyx.data.model.Folder
 import com.philkes.notallyx.data.model.ListItem
 import com.philkes.notallyx.data.model.NoteViewMode
 import com.philkes.notallyx.data.model.Type
+import com.philkes.notallyx.presentation.view.misc.Progress
 import com.philkes.notallyx.presentation.viewmodel.ExportMimeType
 import com.philkes.notallyx.utils.MIME_TYPE_JSON
 import com.philkes.notallyx.utils.log
@@ -24,7 +24,7 @@ class PlainTextImporter : ExternalImporter {
         app: Application,
         source: Uri,
         destination: File,
-        progress: MutableLiveData<ImportProgress>?,
+        progress: MutableLiveData<Progress>?,
     ): Pair<List<BaseNote>, File?> {
         val notes = mutableListOf<BaseNote>()
         fun readTxtFiles(file: DocumentFile) {
diff --git a/app/src/main/java/com/philkes/notallyx/data/model/ConverterErrorReporter.kt b/app/src/main/java/com/philkes/notallyx/data/model/ConverterErrorReporter.kt
new file mode 100644
index 00000000..ee178d3b
--- /dev/null
+++ b/app/src/main/java/com/philkes/notallyx/data/model/ConverterErrorReporter.kt
@@ -0,0 +1,31 @@
+package com.philkes.notallyx.data.model
+
+import android.app.Dialog
+import androidx.lifecycle.MutableLiveData
+import java.util.Collections
+import java.util.concurrent.atomic.AtomicBoolean
+
+/** Helper to register Converter errors while accessing the database. */
+object ConverterErrorReporter {
+    val enabled = AtomicBoolean(true)
+    val errors = MutableLiveData<Throwable?>(null)
+    val activeDialogs = Collections.synchronizedSet(mutableSetOf<Dialog>())
+
+    fun reportError(throwable: Throwable) {
+        if (enabled.get() && errors.value == null) {
+            errors.postValue(throwable)
+        }
+    }
+
+    fun registerDialog(dialog: Dialog) {
+        activeDialogs.add(dialog)
+        // Auto-remove when it's dismissed naturally
+        dialog.setOnDismissListener { activeDialogs.remove(dialog) }
+    }
+
+    fun dismissAllDialogs() {
+        activeDialogs.toList().forEach { it.dismiss() }
+        synchronized(activeDialogs) { activeDialogs.clear() }
+        errors.postValue(null)
+    }
+}
diff --git a/app/src/main/java/com/philkes/notallyx/data/model/Converters.kt b/app/src/main/java/com/philkes/notallyx/data/model/Converters.kt
index b0b7339c..ac5a6f85 100644
--- a/app/src/main/java/com/philkes/notallyx/data/model/Converters.kt
+++ b/app/src/main/java/com/philkes/notallyx/data/model/Converters.kt
@@ -7,27 +7,63 @@ import org.json.JSONArray
 import org.json.JSONException
 import org.json.JSONObject
 
+class ConverterException(message: String, cause: Throwable) : RuntimeException(message, cause)
+
 object Converters {
 
-    @TypeConverter fun labelsToJson(labels: List<String>) = JSONArray(labels).toString()
+    @TypeConverter
+    fun labelsToJson(labels: List<String>) =
+        try {
+            JSONArray(labels).toString()
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert Labels to JSON", e)
+            )
+            "[]"
+        }
 
-    @TypeConverter fun jsonToLabels(json: String) = jsonToLabels(JSONArray(json))
+    @TypeConverter
+    fun jsonToLabels(json: String) =
+        try {
+            jsonToLabels(JSONArray(json))
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert JSON to Labels", e)
+            )
+            emptyList()
+        }
 
     fun jsonToLabels(jsonArray: JSONArray) = jsonArray.iterable<String>().toList()
 
     @TypeConverter
     fun filesToJson(files: List<FileAttachment>): String {
-        val objects =
-            files.map { file ->
-                val jsonObject = JSONObject()
-                jsonObject.put("localName", file.localName)
-                jsonObject.put("originalName", file.originalName)
-                jsonObject.put("mimeType", file.mimeType)
-            }
-        return JSONArray(objects).toString()
+        return try {
+            val objects =
+                files.map { file ->
+                    val jsonObject = JSONObject()
+                    jsonObject.put("localName", file.localName)
+                    jsonObject.put("originalName", file.originalName)
+                    jsonObject.put("mimeType", file.mimeType)
+                }
+            JSONArray(objects).toString()
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert Files attachments to JSON", e)
+            )
+            "[]"
+        }
     }
 
-    @TypeConverter fun jsonToFiles(json: String) = jsonToFiles(JSONArray(json))
+    @TypeConverter
+    fun jsonToFiles(json: String) =
+        try {
+            jsonToFiles(JSONArray(json))
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert JSON to Files attachments", e)
+            )
+            emptyList()
+        }
 
     fun jsonToFiles(jsonArray: JSONArray): List<FileAttachment> {
         return jsonArray.iterable<JSONObject>().map { jsonObject ->
@@ -40,17 +76,33 @@ object Converters {
 
     @TypeConverter
     fun audiosToJson(audios: List<Audio>): String {
-        val objects =
-            audios.map { audio ->
-                val jsonObject = JSONObject()
-                jsonObject.put("name", audio.name)
-                jsonObject.put("duration", audio.duration)
-                jsonObject.put("timestamp", audio.timestamp)
-            }
-        return JSONArray(objects).toString()
+        return try {
+            val objects =
+                audios.map { audio ->
+                    val jsonObject = JSONObject()
+                    jsonObject.put("name", audio.name)
+                    jsonObject.put("duration", audio.duration)
+                    jsonObject.put("timestamp", audio.timestamp)
+                }
+            JSONArray(objects).toString()
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert Audios attachments to JSON", e)
+            )
+            "[]"
+        }
     }
 
-    @TypeConverter fun jsonToAudios(json: String) = jsonToAudios(JSONArray(json))
+    @TypeConverter
+    fun jsonToAudios(json: String) =
+        try {
+            jsonToAudios(JSONArray(json))
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert JSON to Audios attachments", e)
+            )
+            emptyList()
+        }
 
     fun jsonToAudios(json: JSONArray): List<Audio> {
         return json.iterable<JSONObject>().map { jsonObject ->
@@ -61,7 +113,16 @@ object Converters {
         }
     }
 
-    @TypeConverter fun jsonToSpans(json: String) = jsonToSpans(JSONArray(json))
+    @TypeConverter
+    fun jsonToSpans(json: String) =
+        try {
+            jsonToSpans(JSONArray(json))
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert JSON to Spans", e)
+            )
+            emptyList()
+        }
 
     fun jsonToSpans(jsonArray: JSONArray): List<SpanRepresentation> {
         return jsonArray
@@ -94,7 +155,15 @@ object Converters {
     }
 
     @TypeConverter
-    fun spansToJson(list: List<SpanRepresentation>) = spansToJSONArray(list).toString()
+    fun spansToJson(list: List<SpanRepresentation>) =
+        try {
+            spansToJSONArray(list).toString()
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert Spans to JSON", e)
+            )
+            "[]"
+        }
 
     fun spansToJSONArray(list: List<SpanRepresentation>): JSONArray {
         val objects =
@@ -112,7 +181,16 @@ object Converters {
         return JSONArray(objects)
     }
 
-    @TypeConverter fun jsonToItems(json: String) = jsonToItems(JSONArray(json))
+    @TypeConverter
+    fun jsonToItems(json: String) =
+        try {
+            jsonToItems(JSONArray(json))
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert JSON to List Items", e)
+            )
+            emptyList()
+        }
 
     fun jsonToItems(json: JSONArray): List<ListItem> {
         return json.iterable<JSONObject>().map { jsonObject ->
@@ -132,7 +210,16 @@ object Converters {
         }
     }
 
-    @TypeConverter fun itemsToJson(list: List<ListItem>) = itemsToJSONArray(list).toString()
+    @TypeConverter
+    fun itemsToJson(list: List<ListItem>) =
+        try {
+            itemsToJSONArray(list).toString()
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert List Items to JSON", e)
+            )
+            "[]"
+        }
 
     fun itemsToJSONArray(list: List<ListItem>): JSONArray {
         val objects =
@@ -148,7 +235,15 @@ object Converters {
     }
 
     @TypeConverter
-    fun remindersToJson(reminders: List<Reminder>) = remindersToJSONArray(reminders).toString()
+    fun remindersToJson(reminders: List<Reminder>) =
+        try {
+            remindersToJSONArray(reminders).toString()
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert Reminders to JSON", e)
+            )
+            "[]"
+        }
 
     fun remindersToJSONArray(reminders: List<Reminder>): JSONArray {
         val objects =
@@ -163,7 +258,16 @@ object Converters {
         return JSONArray(objects)
     }
 
-    @TypeConverter fun jsonToReminders(json: String) = jsonToReminders(JSONArray(json))
+    @TypeConverter
+    fun jsonToReminders(json: String) =
+        try {
+            jsonToReminders(JSONArray(json))
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert JSON to Reminders", e)
+            )
+            emptyList()
+        }
 
     fun jsonToReminders(jsonArray: JSONArray): List<Reminder> {
         return jsonArray.iterable<JSONObject>().map { jsonObject ->
@@ -177,7 +281,14 @@ object Converters {
 
     @TypeConverter
     fun repetitionToJson(repetition: Repetition): String {
-        return repetitionToJsonObject(repetition).toString()
+        return try {
+            repetitionToJsonObject(repetition).toString()
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert Reminder Repetition to JSON", e)
+            )
+            ""
+        }
     }
 
     fun repetitionToJsonObject(repetition: Repetition): JSONObject {
@@ -191,11 +302,18 @@ object Converters {
 
     @TypeConverter
     fun jsonToRepetition(json: String): Repetition {
-        val jsonObject = JSONObject(json)
-        val value = jsonObject.getInt("value").coerceAtLeast(1)
-        val unit = RepetitionTimeUnit.valueOf(jsonObject.getString("unit"))
-        val (occurrence, dayOfWeek) = getSafeRepetitionCustomization(jsonObject)
-        return Repetition(value, unit, occurrence, dayOfWeek)
+        return try {
+            val jsonObject = JSONObject(json)
+            val value = jsonObject.getInt("value").coerceAtLeast(1)
+            val unit = RepetitionTimeUnit.valueOf(jsonObject.getString("unit"))
+            val (occurrence, dayOfWeek) = getSafeRepetitionCustomization(jsonObject)
+            Repetition(value, unit, occurrence, dayOfWeek)
+        } catch (e: Exception) {
+            ConverterErrorReporter.reportError(
+                ConverterException("Failed to convert JSON to Reminder Repetition", e)
+            )
+            Repetition(1, RepetitionTimeUnit.DAYS)
+        }
     }
 
     private fun getSafeRepetitionCustomization(jsonObject: JSONObject): Pair<Int?, Int?> {
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/MainActivity.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/MainActivity.kt
index d187a93f..166d6b0c 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/MainActivity.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/MainActivity.kt
@@ -32,7 +32,7 @@ import com.google.android.material.transition.platform.MaterialFade
 import com.philkes.notallyx.R
 import com.philkes.notallyx.data.NotallyDatabase
 import com.philkes.notallyx.data.model.BaseNote
-import com.philkes.notallyx.data.model.Folder
+import com.philkes.notallyx.data.model.ConverterErrorReporter
 import com.philkes.notallyx.data.model.Label
 import com.philkes.notallyx.databinding.ActivityMainBinding
 import com.philkes.notallyx.presentation.activity.LockedActivity
@@ -45,6 +45,7 @@ import com.philkes.notallyx.presentation.activity.note.NoteActionHandler
 import com.philkes.notallyx.presentation.activity.note.handleRejection
 import com.philkes.notallyx.presentation.dp
 import com.philkes.notallyx.presentation.setupProgressDialog
+import com.philkes.notallyx.presentation.showToast
 import com.philkes.notallyx.presentation.viewmodel.BaseNoteModel.Companion.CURRENT_LABEL_EMPTY
 import com.philkes.notallyx.presentation.viewmodel.BaseNoteModel.Companion.CURRENT_LABEL_NONE
 import com.philkes.notallyx.presentation.viewmodel.ExportMimeType
@@ -53,7 +54,9 @@ import com.philkes.notallyx.presentation.viewmodel.preference.NotallyXPreference
 import com.philkes.notallyx.presentation.viewmodel.progress.MigrationProgress
 import com.philkes.notallyx.utils.LATEST_DATA_SCHEMA
 import com.philkes.notallyx.utils.backup.exportNotes
+import com.philkes.notallyx.utils.log
 import com.philkes.notallyx.utils.runMigrations
+import com.philkes.notallyx.utils.showErrorDialog
 import kotlinx.coroutines.launch
 
 class MainActivity : LockedActivity<ActivityMainBinding>() {
@@ -96,6 +99,28 @@ class MainActivity : LockedActivity<ActivityMainBinding>() {
 
         checkForMigrations(savedInstanceState)
 
+        ConverterErrorReporter.errors.observe(this@MainActivity) { throwable ->
+            if (throwable == null) {
+                return@observe
+            }
+            application.log("Converters", throwable = throwable)
+            if (ConverterErrorReporter.activeDialogs.isEmpty()) {
+                showErrorDialog(
+                        throwable,
+                        R.string.error,
+                        getString(R.string.error_loading_data, getString(R.string.clean_up)),
+                        neutralButtonTextResId = R.string.clean_up,
+                        neutralButtonClickListener = { dialog, _ ->
+                            ConverterErrorReporter.dismissAllDialogs()
+                            baseModel.cleanupDatabase {
+                                showToast(getString(R.string.cleanup_finished_title))
+                            }
+                        },
+                    )
+                    ?.let { ConverterErrorReporter.registerDialog(it) }
+            }
+        }
+
         onBackPressedDispatcher.addCallback(
             this,
             object : OnBackPressedCallback(true) {
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/SettingsFragment.kt b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/SettingsFragment.kt
index b63fa352..965b57fa 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/SettingsFragment.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/activity/main/fragment/settings/SettingsFragment.kt
@@ -24,6 +24,7 @@ import androidx.core.net.toUri
 import androidx.core.view.isVisible
 import androidx.fragment.app.Fragment
 import androidx.fragment.app.activityViewModels
+import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.lifecycleScope
 import androidx.work.WorkManager
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
@@ -33,6 +34,7 @@ import com.philkes.notallyx.R
 import com.philkes.notallyx.cancelAutoRemoveOldDeletedNotes
 import com.philkes.notallyx.data.imports.Display
 import com.philkes.notallyx.data.imports.FOLDER_OR_FILE_MIMETYPE
+import com.philkes.notallyx.data.imports.ImportProgress
 import com.philkes.notallyx.data.imports.ImportSource
 import com.philkes.notallyx.data.imports.txt.APPLICATION_TEXT_MIME_TYPES
 import com.philkes.notallyx.databinding.DialogTextInputBinding
@@ -83,6 +85,7 @@ class SettingsFragment : Fragment() {
     private val model: BaseNoteModel by activityViewModels()
 
     private lateinit var importBackupActivityResultLauncher: ActivityResultLauncher<Intent>
+    private lateinit var importRawDatabaseActivityResultLauncher: ActivityResultLauncher<Intent>
     private lateinit var importOtherActivityResultLauncher: ActivityResultLauncher<Intent>
     private lateinit var exportBackupActivityResultLauncher: ActivityResultLauncher<Intent>
     private lateinit var chooseBackupFolderActivityResultLauncher: ActivityResultLauncher<Intent>
@@ -144,6 +147,12 @@ class SettingsFragment : Fragment() {
                     result.data?.data?.let { importBackup(it) }
                 }
             }
+        importRawDatabaseActivityResultLauncher =
+            registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+                if (result.resultCode == RESULT_OK) {
+                    result.data?.data?.let { model.importRawDatabase(it) }
+                }
+            }
         importOtherActivityResultLauncher =
             registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
                 if (result.resultCode == RESULT_OK) {
@@ -483,7 +492,9 @@ class SettingsFragment : Fragment() {
                 exportBackupActivityResultLauncher.launch(intent)
             }
         }
-        model.importProgress.setupImportProgressDialog(this@SettingsFragment)
+        (model.importProgress as? MutableLiveData<ImportProgress>)?.setupImportProgressDialog(
+            this@SettingsFragment
+        )
     }
 
     private fun NotallyXPreferences.setupAutoBackups(binding: FragmentSettingsBinding) {
@@ -522,7 +533,7 @@ class SettingsFragment : Fragment() {
     }
 
     private fun importFromOtherApp() {
-        val notallyItem =
+        val notallyItems =
             mutableListOf(
                 object : Display {
                     override fun getTextId(): Int {
@@ -532,31 +543,58 @@ class SettingsFragment : Fragment() {
                     override fun getIconId(): Int {
                         return R.drawable.icon_notally
                     }
-                }
+                },
+                object : Display {
+                    override fun getTextId(): Int {
+                        return R.string.notallyx_raw_database
+                    }
+
+                    override fun getIconId(): Int {
+                        return R.drawable.database
+                    }
+                },
             )
         MaterialAlertDialogBuilder(requireContext())
             .setTitle(R.string.choose_other_app)
             .setAdapter(
                 TextWithIconAdapter(
                     requireContext(),
-                    notallyItem + ImportSource.entries.toMutableList(),
+                    notallyItems + ImportSource.entries.toMutableList(),
                     { item -> getString(item.getTextId()) },
                     Display::getIconId,
                 )
             ) { _, which ->
-                if (which == 0) {
-                    MaterialAlertDialogBuilder(requireContext())
-                        .setMessage(
-                            getString(
-                                R.string.import_from_notally,
-                                getString(R.string.import_backup),
+                when (which) {
+                    0 -> {
+                        MaterialAlertDialogBuilder(requireContext())
+                            .setMessage(
+                                getString(
+                                    R.string.import_from_notally,
+                                    getString(R.string.import_backup),
+                                )
                             )
+                            .setPositiveButton(android.R.string.ok) { dialog, _ ->
+                                dialog.dismiss()
+                            }
+                            .show()
+                        return@setAdapter
+                    }
+                    1 -> {
+                        importRawDatabaseActivityResultLauncher.launch(
+                            Intent(Intent.ACTION_OPEN_DOCUMENT)
+                                .apply {
+                                    type = "*/*"
+                                    addCategory(Intent.CATEGORY_OPENABLE)
+                                    val mimeTypes =
+                                        arrayOf("application/octet-stream", "application/x-sqlite3")
+                                    putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes)
+                                }
+                                .wrapWithChooser(requireContext())
                         )
-                        .setPositiveButton(android.R.string.ok) { dialog, _ -> dialog.dismiss() }
-                        .show()
-                    return@setAdapter
+                        return@setAdapter
+                    }
                 }
-                selectedImportSource = ImportSource.entries[which - 1]
+                selectedImportSource = ImportSource.entries[which - notallyItems.size]
                 MaterialAlertDialogBuilder(requireContext())
                     .setMessage(selectedImportSource.helpTextResId)
                     .setPositiveButton(R.string.import_action) { dialog, _ ->
diff --git a/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/BaseNoteModel.kt b/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/BaseNoteModel.kt
index 2f0cbceb..fb735cd5 100644
--- a/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/BaseNoteModel.kt
+++ b/app/src/main/java/com/philkes/notallyx/presentation/viewmodel/BaseNoteModel.kt
@@ -27,13 +27,13 @@ import com.philkes.notallyx.data.dao.LabelDao
 import com.philkes.notallyx.data.dao.NoteReminder
 import com.philkes.notallyx.data.dao.moveBaseNotes
 import com.philkes.notallyx.data.imports.ImportException
-import com.philkes.notallyx.data.imports.ImportProgress
 import com.philkes.notallyx.data.imports.ImportSource
 import com.philkes.notallyx.data.imports.NotesImporter
 import com.philkes.notallyx.data.model.Attachment
 import com.philkes.notallyx.data.model.Audio
 import com.philkes.notallyx.data.model.BaseNote
 import com.philkes.notallyx.data.model.Content
+import com.philkes.notallyx.data.model.ConverterErrorReporter
 import com.philkes.notallyx.data.model.Converters
 import com.philkes.notallyx.data.model.FileAttachment
 import com.philkes.notallyx.data.model.Folder
@@ -69,6 +69,7 @@ import com.philkes.notallyx.utils.backup.exportPdfFile
 import com.philkes.notallyx.utils.backup.exportPdfFileFolder
 import com.philkes.notallyx.utils.backup.exportPlainTextFile
 import com.philkes.notallyx.utils.backup.exportPlainTextFileFolder
+import com.philkes.notallyx.utils.backup.importRawDatabase
 import com.philkes.notallyx.utils.backup.importZip
 import com.philkes.notallyx.utils.backup.readAsBackup
 import com.philkes.notallyx.utils.cancelPinAndReminders
@@ -85,6 +86,7 @@ import com.philkes.notallyx.utils.security.decryptDatabase
 import com.philkes.notallyx.utils.security.encryptDatabase
 import com.philkes.notallyx.utils.security.isEncryptedDatabase
 import com.philkes.notallyx.utils.security.isUnencryptedDatabase
+import com.philkes.notallyx.utils.toMessage
 import com.philkes.notallyx.utils.toReadablePath
 import com.philkes.notallyx.utils.viewFile
 import java.io.File
@@ -138,7 +140,7 @@ class BaseNoteModel(private val app: Application) : AndroidViewModel(app) {
     val imageRoot
         get() = app.getCurrentImagesDirectory()
 
-    val importProgress = MutableLiveData<ImportProgress>()
+    val importProgress = MutableLiveData<Progress>()
     val progress = MutableLiveData<Progress>()
 
     val actionMode = ActionMode()
@@ -409,6 +411,19 @@ class BaseNoteModel(private val app: Application) : AndroidViewModel(app) {
         }
     }
 
+    fun importRawDatabase(uri: Uri) {
+        val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
+            app.log(TAG, throwable = throwable)
+            app.showToast("${app.getString(R.string.invalid_backup)}: ${throwable.message}")
+        }
+
+        viewModelScope.launch(exceptionHandler) {
+            val importResult =
+                withContext(Dispatchers.IO) { app.importRawDatabase(uri, importProgress) }
+            app.showToast(app.toMessage(importResult))
+        }
+    }
+
     fun importZipBackup(uri: Uri, password: String) {
         val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
             app.log(TAG, throwable = throwable)
@@ -436,14 +451,9 @@ class BaseNoteModel(private val app: Application) : AndroidViewModel(app) {
                             { "InputStream for '$uri' is null" },
                         )
                     val (baseNotes, labels) = stream.readAsBackup()
-                    commonDao.importBackup(baseNotes, labels)
+                    commonDao.importBackup(baseNotes, labels, 0)
                 }
-            val baseMsg = app.getQuantityString(R.plurals.imported_notes, result.inserted)
-            val message =
-                if (result.duplicates > 0)
-                    "$baseMsg (${app.getQuantityString(R.plurals.duplicates, result.duplicates)})"
-                else baseMsg
-            app.showToast(message)
+            app.showToast(app.toMessage(result))
         }
     }
 
@@ -463,11 +473,7 @@ class BaseNoteModel(private val app: Application) : AndroidViewModel(app) {
                 withContext(Dispatchers.IO) {
                     NotesImporter(app, database).import(uri, importSource, importProgress)
                 }
-            val baseMsg = app.getQuantityString(R.plurals.imported_notes, result.inserted)
-            val message =
-                if (result.duplicates > 0) "$baseMsg (${result.duplicates} duplicates skipped)"
-                else baseMsg
-            app.showToast(message)
+            app.showToast(app.toMessage(result))
         }
     }
 
@@ -937,6 +943,18 @@ class BaseNoteModel(private val app: Application) : AndroidViewModel(app) {
         viewModelScope.launch(Dispatchers.IO) { baseNoteDao.insert(notes) }
     }
 
+    fun cleanupDatabase(onComplete: () -> Unit) {
+        viewModelScope.launch(Dispatchers.IO) {
+            ConverterErrorReporter.enabled.set(false)
+            val allNotes = baseNoteDao.getAll()
+            baseNoteDao.updateAll(allNotes)
+            withContext(Dispatchers.Main) {
+                onComplete()
+                ConverterErrorReporter.enabled.set(true)
+            }
+        }
+    }
+
     companion object {
         private const val TAG = "BaseNoteModel"
 
diff --git a/app/src/main/java/com/philkes/notallyx/utils/AndroidExtensions.kt b/app/src/main/java/com/philkes/notallyx/utils/AndroidExtensions.kt
index 4f3e0059..8abd2046 100644
--- a/app/src/main/java/com/philkes/notallyx/utils/AndroidExtensions.kt
+++ b/app/src/main/java/com/philkes/notallyx/utils/AndroidExtensions.kt
@@ -10,6 +10,7 @@ import android.content.ClipboardManager
 import android.content.ContentResolver
 import android.content.Context
 import android.content.ContextWrapper
+import android.content.DialogInterface
 import android.content.Intent
 import android.content.res.Configuration
 import android.net.Uri
@@ -20,6 +21,7 @@ import android.util.Log
 import android.webkit.MimeTypeMap
 import androidx.annotation.ColorInt
 import androidx.annotation.RequiresApi
+import androidx.appcompat.app.AlertDialog
 import androidx.core.content.ContextCompat
 import androidx.core.content.FileProvider
 import androidx.core.net.toUri
@@ -33,6 +35,7 @@ import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import com.philkes.notallyx.BuildConfig
 import com.philkes.notallyx.R
 import com.philkes.notallyx.data.dao.BaseNoteDao.Companion.MAX_BODY_CHAR_LENGTH
+import com.philkes.notallyx.data.imports.ImportResult
 import com.philkes.notallyx.data.model.BaseNote
 import com.philkes.notallyx.data.model.Type
 import com.philkes.notallyx.data.model.toText
@@ -40,6 +43,7 @@ import com.philkes.notallyx.databinding.DialogErrorBinding
 import com.philkes.notallyx.presentation.activity.note.EditActivity.Companion.EXTRA_SELECTED_BASE_NOTE
 import com.philkes.notallyx.presentation.activity.note.EditListActivity
 import com.philkes.notallyx.presentation.activity.note.EditNoteActivity
+import com.philkes.notallyx.presentation.getQuantityString
 import com.philkes.notallyx.presentation.setCancelButton
 import com.philkes.notallyx.presentation.showToast
 import com.philkes.notallyx.presentation.view.misc.NotNullLiveData
@@ -227,7 +231,9 @@ fun Activity.showErrorDialog(
     titleResId: Int,
     message: String,
     originalStacktrace: String? = null,
-) {
+    neutralButtonTextResId: Int? = null,
+    neutralButtonClickListener: DialogInterface.OnClickListener? = null,
+): AlertDialog? {
     val stacktrace = throwable.stackTraceToString()
     val layout =
         DialogErrorBinding.inflate(layoutInflater, null, false).apply {
@@ -235,14 +241,17 @@ fun Activity.showErrorDialog(
             ExceptionDetails.text = stacktrace
             CopyButton.setOnClickListener { copyToClipBoard(stacktrace) }
         }
-    MaterialAlertDialogBuilder(this)
-        .setTitle(titleResId)
-        .setView(layout.root)
-        .setPositiveButton(R.string.report_bug) { dialog, _ ->
-            dialog.cancel()
-            reportBug(originalStacktrace ?: throwable.stackTraceToString())
+    return MaterialAlertDialogBuilder(this)
+        .apply {
+            setTitle(titleResId)
+            setView(layout.root)
+            setPositiveButton(R.string.report_bug) { dialog, _ ->
+                dialog.cancel()
+                reportBug(originalStacktrace ?: throwable.stackTraceToString())
+            }
+            neutralButtonTextResId?.let { setNeutralButton(it, neutralButtonClickListener) }
+            setCancelButton()
         }
-        .setCancelButton()
         .show()
 }
 
@@ -416,6 +425,26 @@ fun ContextWrapper.shareNote(note: BaseNote) {
     shareNote(note.title, body, filesUris)
 }
 
+fun ContextWrapper.toMessage(importResult: ImportResult) =
+    StringBuilder()
+        .apply {
+            append(getQuantityString(R.plurals.imported_notes, importResult.inserted))
+            if (importResult.duplicates > 0) {
+                append("\n")
+                append(getQuantityString(R.plurals.duplicates, importResult.duplicates))
+            }
+            if (importResult.corruptedNotes > 0) {
+                append("\n")
+                append(
+                    getQuantityString(
+                        R.plurals.skipped_corrupted_notes,
+                        importResult.corruptedNotes,
+                    )
+                )
+            }
+        }
+        .toString()
+
 fun Context.textMaxLengthFilter() = arrayOf(LengthFilterWithToast(this, MAX_BODY_CHAR_LENGTH))
 
 private fun Context.shareNote(title: String, body: CharSequence, imageUris: List<Uri>) {
diff --git a/app/src/main/java/com/philkes/notallyx/utils/ErrorActivity.kt b/app/src/main/java/com/philkes/notallyx/utils/ErrorActivity.kt
index acc8bee8..4e6452e6 100644
--- a/app/src/main/java/com/philkes/notallyx/utils/ErrorActivity.kt
+++ b/app/src/main/java/com/philkes/notallyx/utils/ErrorActivity.kt
@@ -2,6 +2,8 @@ package com.philkes.notallyx.utils
 
 import android.content.Intent
 import android.os.Bundle
+import android.provider.DocumentsContract
+import android.util.Log
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
@@ -13,15 +15,20 @@ import com.philkes.notallyx.R
 import com.philkes.notallyx.R.string.auto_backup_failed
 import com.philkes.notallyx.R.string.crash_export_backup_failed
 import com.philkes.notallyx.R.string.report_bug
+import com.philkes.notallyx.data.NotallyDatabase
 import com.philkes.notallyx.databinding.ActivityErrorBinding
 import com.philkes.notallyx.presentation.exportedText
+import com.philkes.notallyx.presentation.restartApplication
 import com.philkes.notallyx.presentation.setCancelButton
 import com.philkes.notallyx.presentation.setupProgressDialog
 import com.philkes.notallyx.presentation.showToast
 import com.philkes.notallyx.presentation.view.misc.Progress
 import com.philkes.notallyx.presentation.viewmodel.preference.NotallyXPreferences
 import com.philkes.notallyx.utils.backup.BACKUP_TIMESTAMP_FORMATTER
+import com.philkes.notallyx.utils.backup.copyDatabase
 import com.philkes.notallyx.utils.backup.exportAsZip
+import com.philkes.notallyx.utils.backup.exportRawDatabase
+import com.philkes.notallyx.utils.backup.importRawDatabase
 import java.util.Date
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.Dispatchers
@@ -35,7 +42,8 @@ import kotlinx.coroutines.withContext
 class ErrorActivity : AppCompatActivity() {
 
     private lateinit var exportBackupActivityResultLauncher: ActivityResultLauncher<Intent>
-    private val exportBackupProgress = MutableLiveData<Progress>()
+    private lateinit var exportDatabaseActivityResultLauncher: ActivityResultLauncher<Intent>
+    private val backupProgress = MutableLiveData<Progress>()
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -94,11 +102,40 @@ class ErrorActivity : AppCompatActivity() {
                     result.data?.data?.let { uri ->
                         val preferences = NotallyXPreferences.getInstance(this)
                         val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
+                            try {
+                                DocumentsContract.deleteDocument(contentResolver, uri)
+                                Log.d(TAG, "Successfully deleted empty backup file '$uri'")
+                            } catch (e: Exception) {
+                                Log.w(TAG, "Failed to delete empty backup file '$uri'", e)
+                            }
                             showErrorDialog(
                                 throwable,
                                 auto_backup_failed,
-                                getString(crash_export_backup_failed, this.getString(report_bug)),
+                                getString(
+                                    R.string.crash_export_backup,
+                                    getString(report_bug),
+                                    getString(R.string.export_database),
+                                ),
                                 originalStacktrace = stacktrace,
+                                neutralButtonTextResId = R.string.export_database,
+                                neutralButtonClickListener = { _, _ ->
+                                    val intent =
+                                        Intent(Intent.ACTION_CREATE_DOCUMENT)
+                                            .apply {
+                                                type = "application/octet-stream"
+                                                addCategory(Intent.CATEGORY_OPENABLE)
+                                                putExtra(
+                                                    Intent.EXTRA_TITLE,
+                                                    "NotallyX_Raw_Database-${
+                                                        BACKUP_TIMESTAMP_FORMATTER.format(
+                                                            Date()
+                                                        )
+                                                    }.sqlite",
+                                                )
+                                            }
+                                            .wrapWithChooser(this@ErrorActivity)
+                                    exportDatabaseActivityResultLauncher.launch(intent)
+                                },
                             )
                         }
                         lifecycleScope.launch(exceptionHandler) {
@@ -107,7 +144,7 @@ class ErrorActivity : AppCompatActivity() {
                                     return@withContext application.exportAsZip(
                                         uri,
                                         password = preferences.backupPassword.value,
-                                        backupProgress = exportBackupProgress,
+                                        backupProgress = backupProgress,
                                     )
                                 }
                             val message = application.exportedText(exportedNotesAndAttachments)
@@ -116,7 +153,83 @@ class ErrorActivity : AppCompatActivity() {
                     }
                 }
             }
-        exportBackupProgress.setupProgressDialog(this)
+        exportDatabaseActivityResultLauncher =
+            registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+                if (result.resultCode == RESULT_OK) {
+                    result.data?.data?.let { uri ->
+                        val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
+                            try {
+                                // This is the specific method for SAF Uris
+                                DocumentsContract.deleteDocument(contentResolver, uri)
+                                Log.d(TAG, "Successfully deleted empty database file '$uri'")
+                            } catch (e: Exception) {
+                                Log.w(TAG, "Failed to delete empty database file '$uri'", e)
+                            }
+                            showErrorDialog(
+                                throwable,
+                                auto_backup_failed,
+                                getString(crash_export_backup_failed, getString(report_bug)),
+                                originalStacktrace = stacktrace,
+                            )
+                        }
+                        lifecycleScope.launch(exceptionHandler) {
+                            withContext(Dispatchers.IO) { application.exportRawDatabase(uri) }
+                            application.showToast(
+                                "${getString(R.string.exported)} ${getString(R.string.database)}"
+                            )
+                            MaterialAlertDialogBuilder(this@ErrorActivity)
+                                .apply {
+                                    setTitle(R.string.database)
+                                    setMessage(R.string.reimport_database_message)
+                                    setPositiveButton(R.string.reimport_database) { dialog, _ ->
+                                        dialog.cancel()
+                                        val exceptionHandler =
+                                            CoroutineExceptionHandler { _, throwable ->
+                                                showErrorDialog(
+                                                    throwable,
+                                                    R.string.reimport_database_failed,
+                                                    getString(
+                                                        crash_export_backup_failed,
+                                                        getString(report_bug),
+                                                    ),
+                                                    originalStacktrace =
+                                                        throwable.stackTraceToString(),
+                                                )
+                                            }
+                                        lifecycleScope.launch(exceptionHandler) {
+                                            val importResult =
+                                                withContext(Dispatchers.IO) {
+                                                    // Safety copy of internal database
+                                                    val (_, databaseCopy) =
+                                                        copyDatabase(suffix = "_BEFORE_REIMPORT")
+                                                    deleteDatabase(NotallyDatabase.DATABASE_NAME)
+                                                    NotallyDatabase.clearInstance(
+                                                        this@ErrorActivity
+                                                    )
+                                                    application.importRawDatabase(
+                                                        uri,
+                                                        backupProgress,
+                                                    )
+                                                }
+                                            MaterialAlertDialogBuilder(this@ErrorActivity)
+                                                .setMessage(
+                                                    this@ErrorActivity.toMessage(importResult)
+                                                )
+                                                .setPositiveButton(R.string.restart_app) { _, _ ->
+                                                    restartApplication()
+                                                }
+                                                .setCancelButton()
+                                                .show()
+                                        }
+                                    }
+                                    setCancelButton()
+                                }
+                                .show()
+                        }
+                    }
+                }
+            }
+        backupProgress.setupProgressDialog(this)
     }
 
     companion object {
diff --git a/app/src/main/java/com/philkes/notallyx/utils/backup/ExportExtensions.kt b/app/src/main/java/com/philkes/notallyx/utils/backup/ExportExtensions.kt
index fa808f91..704b2369 100644
--- a/app/src/main/java/com/philkes/notallyx/utils/backup/ExportExtensions.kt
+++ b/app/src/main/java/com/philkes/notallyx/utils/backup/ExportExtensions.kt
@@ -8,10 +8,12 @@ import android.content.Context
 import android.content.ContextWrapper
 import android.content.Intent
 import android.content.pm.PackageManager
+import android.database.sqlite.SQLiteDatabase
 import android.net.Uri
 import android.os.Build
 import android.print.PdfPrintListener
 import android.print.printPdf
+import android.provider.OpenableColumns
 import android.util.Log
 import androidx.activity.result.ActivityResultLauncher
 import androidx.core.app.NotificationCompat
@@ -317,6 +319,39 @@ fun ContextWrapper.modifiedNoteBackupExists(backupPath: String): Boolean {
 
 typealias NotesAndAttachments = Pair<Int, Int>
 
+fun ContextWrapper.exportRawDatabase(fileUri: Uri) {
+    val (_, databaseCopy) = copyDatabase()
+    val database =
+        SQLiteDatabase.openDatabase(databaseCopy.path, null, SQLiteDatabase.OPEN_READONLY)
+    database
+        .rawQuery(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+            arrayOf("BaseNote"),
+        )
+        .use { cursor ->
+            if (cursor.count < 1) {
+                throw IOException("Database does not contain 'BaseNote' table!")
+            }
+        }
+    val outputStream =
+        contentResolver.openOutputStream(fileUri)
+            ?: throw IOException("Failed to open output stream for $fileUri")
+    outputStream.use { outputStream ->
+        FileInputStream(databaseCopy).use { inputStream ->
+            inputStream.copyToLarge(outputStream)
+            outputStream.flush()
+        }
+    }
+    contentResolver.query(fileUri, null, null, null, null)?.use { cursor ->
+        val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
+        if (cursor.moveToFirst()) {
+            if (cursor.getLong(sizeIndex) <= 0) {
+                throw IOException("Exported Raw Database file is empty!")
+            }
+        }
+    }
+}
+
 fun ContextWrapper.exportAsZip(
     fileUri: Uri,
     compress: Boolean = false,
diff --git a/app/src/main/java/com/philkes/notallyx/utils/backup/ImportExtensions.kt b/app/src/main/java/com/philkes/notallyx/utils/backup/ImportExtensions.kt
index 61c38623..f8d7d6d4 100644
--- a/app/src/main/java/com/philkes/notallyx/utils/backup/ImportExtensions.kt
+++ b/app/src/main/java/com/philkes/notallyx/utils/backup/ImportExtensions.kt
@@ -15,12 +15,14 @@ import androidx.documentfile.provider.DocumentFile
 import androidx.lifecycle.MutableLiveData
 import com.philkes.notallyx.R
 import com.philkes.notallyx.data.NotallyDatabase
+import com.philkes.notallyx.data.NotallyDatabase.Companion.DATABASE_NAME
 import com.philkes.notallyx.data.dao.BaseNoteDao.Companion.MAX_BODY_CHAR_LENGTH
 import com.philkes.notallyx.data.imports.ImportProgress
+import com.philkes.notallyx.data.imports.ImportResult
 import com.philkes.notallyx.data.imports.ImportStage
 import com.philkes.notallyx.data.model.Audio
 import com.philkes.notallyx.data.model.BaseNote
-import com.philkes.notallyx.data.model.BaseNote.Companion
+import com.philkes.notallyx.data.model.ConverterErrorReporter
 import com.philkes.notallyx.data.model.Converters
 import com.philkes.notallyx.data.model.FileAttachment
 import com.philkes.notallyx.data.model.Folder
@@ -28,8 +30,8 @@ import com.philkes.notallyx.data.model.Label
 import com.philkes.notallyx.data.model.NoteViewMode
 import com.philkes.notallyx.data.model.Type
 import com.philkes.notallyx.data.model.parseToColorString
-import com.philkes.notallyx.presentation.getQuantityString
 import com.philkes.notallyx.presentation.showToast
+import com.philkes.notallyx.presentation.view.misc.Progress
 import com.philkes.notallyx.presentation.viewmodel.NotallyModel.FileType
 import com.philkes.notallyx.presentation.viewmodel.preference.NotallyXPreferences
 import com.philkes.notallyx.utils.FileError
@@ -50,6 +52,7 @@ import com.philkes.notallyx.utils.pinAndScheduleReminders
 import com.philkes.notallyx.utils.rename
 import com.philkes.notallyx.utils.security.SQLCipherUtils
 import com.philkes.notallyx.utils.security.decryptDatabase
+import com.philkes.notallyx.utils.toMessage
 import com.philkes.notallyx.utils.toNotallyXReminder
 import java.io.File
 import java.io.FileInputStream
@@ -90,6 +93,67 @@ fun getOptionalColumns(db: SQLiteDatabase, tableName: String): Array<String> {
         .toTypedArray()
 }
 
+suspend fun ContextWrapper.importRawDatabase(
+    dbFileUri: Uri,
+    importProgress: MutableLiveData<Progress>? = null,
+): ImportResult {
+    val tempDbFile = File(cacheDir, DATABASE_NAME + "_IMPORT")
+    try {
+        requireNotNull(
+                contentResolver.openInputStream(dbFileUri),
+                { "InputStream for dbFileUri '$dbFileUri' is null" },
+            )
+            .use { inputStream ->
+                inputStream.copyToFile(tempDbFile)
+                val (baseNotes, originalIds, labels, corruptedNotes) =
+                    readBaseNotes(tempDbFile, importProgress)
+                val import = import(baseNotes, originalIds, labels, corruptedNotes)
+                importProgress?.postValue(ImportProgress(inProgress = false))
+                return import
+            }
+    } finally {
+        tempDbFile.delete()
+    }
+}
+
+data class BaseNotesImport(
+    val baseNotes: List<BaseNote>,
+    val originalIds: List<Long>,
+    val labels: List<Label>,
+    val corruptedNotes: Int,
+)
+
+fun ContextWrapper.readBaseNotes(
+    dbFile: File,
+    progress: MutableLiveData<Progress>? = null,
+): BaseNotesImport {
+    val database = SQLiteDatabase.openDatabase(dbFile.path, null, SQLiteDatabase.OPEN_READONLY)
+    try {
+        val labelCursor = database.query("Label", null, null, null, null, null, null)
+
+        val safeColumns = getOptionalColumns(database, "BaseNote")
+
+        val baseNoteCursor = database.query("BaseNote", safeColumns, null, null, null, null, null)
+        val (labels, _) = labelCursor.toList { cursor -> cursor.toLabel() }
+
+        val total = baseNoteCursor.count
+        var counter = 1
+        progress?.postValue(ImportProgress(0, total))
+        val originalIds = ArrayList<Long>(baseNoteCursor.count)
+        val (baseNotes, corrupted) =
+            baseNoteCursor.toList { cursor ->
+                val baseNote = cursor.toBaseNote(database)
+                val originalId = cursor.getLong(cursor.getColumnIndexOrThrow("id"))
+                originalIds.add(originalId)
+                progress?.postValue(ImportProgress(counter++, total))
+                baseNote
+            }
+        return BaseNotesImport(baseNotes, originalIds, labels, corrupted)
+    } finally {
+        database.close()
+    }
+}
+
 /**
  * We only import the images/files referenced in notes. e.g If someone has added garbage to the ZIP
  * file, like a 100 MB image, ignore it.
@@ -98,9 +162,9 @@ suspend fun ContextWrapper.importZip(
     zipFileUri: Uri,
     databaseFolder: File,
     zipPassword: String,
-    importingBackup: MutableLiveData<ImportProgress>? = null,
+    progress: MutableLiveData<Progress>? = null,
 ) {
-    importingBackup?.postValue(ImportProgress(indeterminate = true))
+    progress?.postValue(ImportProgress(indeterminate = true))
     try {
         val result =
             withContext(Dispatchers.IO) {
@@ -144,38 +208,15 @@ suspend fun ContextWrapper.importZip(
                         )
                     }
                 }
-                val database =
-                    SQLiteDatabase.openDatabase(dbFile.path, null, SQLiteDatabase.OPEN_READONLY)
-
-                val labelCursor = database.query("Label", null, null, null, null, null, null)
-
-                val safeColumns = getOptionalColumns(database, "BaseNote")
-
-                val baseNoteCursor =
-                    database.query("BaseNote", safeColumns, null, null, null, null, null)
-                val labels = labelCursor.toList { cursor -> cursor.toLabel() }
-
-                var total = baseNoteCursor.count
-                var counter = 1
-                importingBackup?.postValue(ImportProgress(0, total))
-                val originalIds = ArrayList<Long>(baseNoteCursor.count)
-                val baseNotes =
-                    baseNoteCursor.toList { cursor ->
-                        val baseNote = cursor.toBaseNote(database)
-                        val originalId = cursor.getLong(cursor.getColumnIndexOrThrow("id"))
-                        originalIds.add(originalId)
-                        importingBackup?.postValue(ImportProgress(counter++, total))
-                        baseNote
-                    }
-                delay(1000)
 
-                total =
+                delay(1000)
+                val (baseNotes, originalIds, labels, corruptedNotes) =
+                    readBaseNotes(dbFile, progress)
+                val total =
                     baseNotes.fold(0) { acc, baseNote ->
                         acc + baseNote.images.size + baseNote.files.size + baseNote.audios.size
                     }
-                importingBackup?.postValue(
-                    ImportProgress(0, total, stage = ImportStage.IMPORT_FILES)
-                )
+                progress?.postValue(ImportProgress(0, total, stage = ImportStage.IMPORT_FILES))
 
                 val current = AtomicInteger(1)
                 val imageRoot = getCurrentImagesDirectory()
@@ -189,7 +230,7 @@ suspend fun ContextWrapper.importZip(
                         zipFile,
                         current,
                         total,
-                        importingBackup,
+                        progress,
                     )
                     importFiles(
                         baseNote.files,
@@ -198,7 +239,7 @@ suspend fun ContextWrapper.importZip(
                         zipFile,
                         current,
                         total,
-                        importingBackup,
+                        progress,
                     )
                     baseNote.audios.forEach { audio ->
                         try {
@@ -212,7 +253,7 @@ suspend fun ContextWrapper.importZip(
                         } catch (exception: Exception) {
                             log(TAG, throwable = exception)
                         } finally {
-                            importingBackup?.postValue(
+                            progress?.postValue(
                                 ImportProgress(
                                     current.getAndIncrement(),
                                     total,
@@ -222,23 +263,10 @@ suspend fun ContextWrapper.importZip(
                         }
                     }
                 }
-
-                val notallyDatabase =
-                    NotallyDatabase.getDatabase(this@importZip, observePreferences = false).value
-                val importResult =
-                    notallyDatabase.getCommonDao().importBackup(baseNotes, originalIds, labels)
-                val notesToRemind = notallyDatabase.getBaseNoteDao().getAllWithRemindersOrPinned()
-                cancelPinAndReminders(notesToRemind)
-                pinAndScheduleReminders(notesToRemind)
-                importResult
+                import(baseNotes, originalIds, labels, corruptedNotes)
             }
         databaseFolder.clearDirectory()
-        val baseMsg = getQuantityString(R.plurals.imported_notes, result.inserted)
-        val message =
-            if (result.duplicates > 0)
-                "$baseMsg (${getQuantityString(R.plurals.duplicates, result.duplicates)})"
-            else baseMsg
-        showToast(message)
+        showToast(toMessage(result))
     } catch (e: ZipException) {
         if (e.type == ZipException.Type.WRONG_PASSWORD) {
             log(TAG, throwable = e)
@@ -247,10 +275,25 @@ suspend fun ContextWrapper.importZip(
             throw e
         }
     } finally {
-        importingBackup?.value = ImportProgress(inProgress = false)
+        progress?.value = ImportProgress(inProgress = false)
     }
 }
 
+private suspend fun ContextWrapper.import(
+    baseNotes: List<BaseNote>,
+    originalIds: List<Long>,
+    labels: List<Label>,
+    readCorrupted: Int,
+): ImportResult {
+    val notallyDatabase = NotallyDatabase.getDatabase(this, observePreferences = false).value
+    val importResult =
+        notallyDatabase.getCommonDao().importBackup(baseNotes, originalIds, labels, readCorrupted)
+    val notesToRemind = notallyDatabase.getBaseNoteDao().getAllWithRemindersOrPinned()
+    cancelPinAndReminders(notesToRemind)
+    pinAndScheduleReminders(notesToRemind)
+    return importResult
+}
+
 private fun ContextWrapper.importFiles(
     files: List<FileAttachment>,
     subFolder: String,
@@ -258,7 +301,7 @@ private fun ContextWrapper.importFiles(
     zipFile: ZipFile,
     current: AtomicInteger,
     total: Int,
-    importingBackup: MutableLiveData<ImportProgress>? = null,
+    importingBackup: MutableLiveData<Progress>? = null,
 ) {
     files.forEach { file ->
         try {
@@ -406,15 +449,24 @@ private fun Cursor.toBaseNote(sourceDb: SQLiteDatabase): BaseNote {
     )
 }
 
-private fun <T> Cursor.toList(convert: (cursor: Cursor) -> T): ArrayList<T> {
-    val list = ArrayList<T>(count)
-    while (moveToNext()) {
-        val item = convert(this)
-        list.add(item)
+private fun <T> Cursor.toList(convert: (cursor: Cursor) -> T): Pair<ArrayList<T>, Int> =
+    try {
+        ConverterErrorReporter.enabled.set(false)
+        val list = ArrayList<T>(count)
+        var corrupted = 0
+        while (moveToNext()) {
+            try {
+                list.add(convert(this))
+            } catch (e: Exception) {
+                Log.e(TAG, "Error while converting DB cursor", e)
+                corrupted++
+            }
+        }
+        close()
+        Pair(list, corrupted)
+    } finally {
+        ConverterErrorReporter.enabled.set(true)
     }
-    close()
-    return list
-}
 
 fun Context.importPreferences(jsonFile: Uri, to: SharedPreferences.Editor): Boolean {
     try {
diff --git a/app/src/main/res/drawable/database.xml b/app/src/main/res/drawable/database.xml
new file mode 100644
index 00000000..92d06509
--- /dev/null
+++ b/app/src/main/res/drawable/database.xml
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="960"
+    android:viewportHeight="960"
+    android:tint="?attr/colorControlNormal">
+  <path
+      android:fillColor="@android:color/white"
+      android:pathData="M480,840Q329,840 224.5,793.5Q120,747 120,680L120,280Q120,214 225.5,167Q331,120 480,120Q629,120 734.5,167Q840,214 840,280L840,680Q840,747 735.5,793.5Q631,840 480,840ZM480,361Q569,361 659,335.5Q749,310 760,281Q749,252 659.5,226Q570,200 480,200Q389,200 301.5,225.5Q214,251 200,281Q214,311 301.5,336Q389,361 480,361ZM480,560Q522,560 561,556Q600,552 635.5,544.5Q671,537 702.5,526Q734,515 760,501L760,381Q734,395 702.5,406Q671,417 635.5,424.5Q600,432 561,436Q522,440 480,440Q438,440 398,436Q358,432 322.5,424.5Q287,417 256,406Q225,395 200,381L200,501Q225,515 256,526Q287,537 322.5,544.5Q358,552 398,556Q438,560 480,560ZM480,760Q526,760 573.5,753Q621,746 661,734.5Q701,723 728,708.5Q755,694 760,679L760,581Q734,595 702.5,606Q671,617 635.5,624.5Q600,632 561,636Q522,640 480,640Q438,640 398,636Q358,632 322.5,624.5Q287,617 256,606Q225,595 200,581L200,680Q205,695 231.5,709Q258,723 298,734.5Q338,746 386,753Q434,760 480,760Z"/>
+</vector>
diff --git a/app/src/main/res/layout/dialog_error.xml b/app/src/main/res/layout/dialog_error.xml
index 2ab8b6ee..8caf1e9d 100644
--- a/app/src/main/res/layout/dialog_error.xml
+++ b/app/src/main/res/layout/dialog_error.xml
@@ -14,7 +14,6 @@
       android:singleLine="false"
       android:gravity="center"
       android:padding="4dp"
-      android:textColor="@android:color/black"
       android:textIsSelectable="true"
       android:textSize="14sp"
       android:textStyle="bold"
@@ -42,7 +41,6 @@
           android:scrollbars="vertical|horizontal"
           android:scrollHorizontally="false"
           android:singleLine="false"
-          android:textColor="@android:color/black"
           android:textIsSelectable="true"
           android:textSize="14sp" />
     </HorizontalScrollView>
@@ -62,6 +60,5 @@
       android:layout_height="wrap_content"
       android:visibility="gone"
       android:padding="8dp"
-      android:textColor="@android:color/black"
       android:textSize="14sp" />
 </LinearLayout>
\ No newline at end of file
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 337ad11b..819d51df 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -100,6 +100,7 @@
     <string name="copied_link">Copied Link to Clipboard</string>
     <string name="copy">Copy</string>
     <string name="count" translatable="false">%1$d / %2$d</string>
+    <string name="crash_export_backup">Unfortunately, exporting the backup failed.\nYou can use \'%1$s\' button to report the crash or try to export the raw database file (SQLite) via \'%2$s\'. It will only include notes contents, no attachments. But if it succeeds you can import it back via the Import from other apps option.</string>
     <string name="crash_export_backup_failed">Unfortunately, exporting the backup failed.\nPlease use the \'%1$s\' button to report the crash</string>
     <string name="crash_export_backup_message">You can try to create a backup of your notes by clicking \'%1$s\'.\nThis might fail if the crash lead to broken/corrupted data. In that case, please use the \'%2$s\' button to report the crash</string>
     <string name="crash_message">An unexpected error occurred.\nSorry for the inconvenience.</string>
@@ -110,6 +111,7 @@
     <string name="dark">Dark</string>
     <string name="data_in_public">Store data in public folder</string>
     <string name="data_in_public_message">By enabling this, the app’s internal database and attached files will be moved into the app’s public folder (Android/media/com.philkes.notallyx). In combination with file synchronization apps this can be used to synchronize NotallyX data between multiple devices.</string>
+    <string name="database">Database</string>
     <string name="date">Date</string>
     <string name="date_format">Date format</string>
     <string name="date_format_hint">Applies selected datetime format in Notes Overview</string>
@@ -171,6 +173,8 @@
     <string name="enable_lock_description">This will also encrypt the database</string>
     <string name="enable_lock_title">Enable lock via Biometric/PIN</string>
     <string name="enabled">Enabled</string>
+    <string name="error">Error</string>
+    <string name="error_loading_data">Error while loading some data from the database. Corrupted notes will not be displayed.\nYou can cleanup (deleting corrupted notes) the database by using \'%1$s\'</string>
     <string name="error_while_renaming_file">Error while renaming file</string>
     <string name="error_while_renaming_image">Error while renaming image</string>
     <string name="evernote">Evernote</string>
@@ -178,6 +182,7 @@
     <string name="every">Every</string>
     <string name="export">Export</string>
     <string name="export_backup">Export backup</string>
+    <string name="export_database">Export DB</string>
     <string name="export_settings">Export Settings</string>
     <string name="export_settings_failure">Failed to export settings, did you choose an invalid path\?</string>
     <string name="export_settings_message">All Settings will be exported to a JSON file, which can be used to re-import stored settings.\n\nBe aware, that this does not include encrypted settings like the auto-backup password or the biometric encryption key</string>
@@ -275,6 +280,7 @@
     <string name="none">None</string>
     <string name="not_exists">\'%1$s\' does not exist</string>
     <string name="notally" translatable="false">Notally</string>
+    <string name="notallyx_raw_database" translatable="false">NotallyX Raw Database</string>
     <string name="note">Note</string>
     <string name="note_text_too_long_truncated">Text too long, truncated to %1$d characters</string>
     <string name="note_too_big_truncating">Note is too big to save, it was truncated to %1$s characters (was: %2$s)</string>
@@ -315,6 +321,9 @@
     <string name="record_audio">Record audio</string>
     <string name="recording">Recording…</string>
     <string name="redo">Redo</string>
+    <string name="reimport_database">Reimport DB</string>
+    <string name="reimport_database_failed">Reimporting Database failed</string>
+    <string name="reimport_database_message">You can now try to reimport a raw database. This deletes the current corrupted database and then tries to import the raw database by skipping corrupted notes if possible</string>
     <string name="reminder_no_repetition">No repetition</string>
     <string name="reminders">Reminders</string>
     <string name="remove_link">Remove Link</string>
@@ -352,6 +361,10 @@
     <string name="single_file">Single File</string>
     <string name="single_note_or_list">Single note or list</string>
     <string name="skip">Skip</string>
+    <plurals name="skipped_corrupted_notes">
+        <item quantity="one">Skipped %1$s corrupted Note</item>
+        <item quantity="other">Skipped %1$s corrupted Notes</item>
+    </plurals>
     <string name="small">Small</string>
     <string name="something_went_wrong">Something went wrong. Please try again.</string>
     <string name="something_went_wrong_audio">Something went wrong. The audio recording may have been moved or deleted.\n\nError : (%1$d, %2$d)</string>
diff --git a/app/translations.xlsx b/app/translations.xlsx
index 166f8f24..4e4acb84 100644
Binary files a/app/translations.xlsx and b/app/translations.xlsx differ