diff --git a/src/exifreader.cpp b/src/exifreader.cpp
index 06db53d..0a9ddb7 100644
--- a/src/exifreader.cpp
+++ b/src/exifreader.cpp
@@ -1,10 +1,14 @@
 #include "exifreader.h"
 
-#include <QFileInfo>
+#include <QFile>
 #include <QImageReader>
 
 #include <exiv2/exiv2.hpp>
 
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
 // Raw EXIF date format is "YYYY:MM:DD HH:MM:SS"; reformat date separators to dashes
 static QString formatDate(const QString &raw)
 {
@@ -53,17 +57,17 @@ QList<QPair<QString, QString>> ExifData::toList() const
     return result;
 }
 
-ExifData ExifReader::read(const QString &path)
+ExifData ExifReader::read(const QByteArray &path)
 {
     ExifData data;
 
-    QFileInfo fi(path);
-    if (!fi.exists() || fi.isDir())
+    struct ::stat st{};
+    if (::stat(path.constData(), &st) != 0 || !S_ISREG(st.st_mode))
         return data;
 
     // File size
     {
-        qint64 size = fi.size();
+        qint64 size = static_cast<qint64>(st.st_size);
         if (size < 1024)
             data.fileSize = QString::number(size) + QLatin1String(" B");
         else if (size < 1024 * 1024)
@@ -74,17 +78,26 @@ ExifData ExifReader::read(const QString &path)
 
     // Image dimensions via Qt (reads only the header, no full decode needed)
     {
-        QImageReader reader(path);
-        reader.setDecideFormatFromContent(true);
-        QSize sz = reader.size();
-        if (sz.isValid())
-            data.dimensions = QString::fromLatin1("%1 * %2")
-                                  .arg(sz.width()).arg(sz.height());
+        int fd = ::open(path.constData(), O_RDONLY | O_CLOEXEC);
+        if (fd >= 0) {
+            QFile file;
+            if (file.open(fd, QIODevice::ReadOnly, QFileDevice::AutoCloseHandle)) {
+                QImageReader reader(&file);
+                reader.setDecideFormatFromContent(true);
+                QSize sz = reader.size();
+                        if (sz.isValid())
+                    data.dimensions = QString::fromLatin1("%1 * %2")
+                                          .arg(sz.width()).arg(sz.height());
+            } else {
+                ::close(fd);
+            }
+        }
     }
 
     // EXIF tags via exiv2
     try {
-        std::unique_ptr<Exiv2::Image> image = Exiv2::ImageFactory::open(path.toStdString());
+        std::unique_ptr<Exiv2::Image> image =
+            Exiv2::ImageFactory::open(path.toStdString());
         image->readMetadata();
         const Exiv2::ExifData &exif = image->exifData();
 
diff --git a/src/exifreader.h b/src/exifreader.h
index 7b354c4..6d2957a 100644
--- a/src/exifreader.h
+++ b/src/exifreader.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <QByteArray>
 #include <QString>
 #include <QList>
 #include <QPair>
@@ -21,5 +22,5 @@ struct ExifData {
 };
 
 namespace ExifReader {
-ExifData read(const QString &path);
+ExifData read(const QByteArray &path);
 } // namespace ExifReader
diff --git a/src/imagemodel.cpp b/src/imagemodel.cpp
index 6fb9368..93cc8d4 100644
--- a/src/imagemodel.cpp
+++ b/src/imagemodel.cpp
@@ -1,11 +1,14 @@
 #include "imagemodel.h"
 #include "thumbnailworker.h"
 
-#include <QDir>
+#include <QFile>
 #include <QImageReader>
-#include <QFileInfo>
 #include <QFileIconProvider>
 
+#include <algorithm>
+#include <filesystem>
+#include <vector>
+
 ImageModel::ImageModel(QObject *parent)
     : QAbstractListModel(parent)
 {
@@ -69,6 +72,11 @@ void ImageModel::setThumbnailSize(ThumbnailCache::Size size)
 
 void ImageModel::setDirectory(const QString &path)
 {
+    setDirectory(QFile::encodeName(path));
+}
+
+void ImageModel::setDirectory(const QByteArray &path)
+{
     m_cancelFlag = true;
     m_threadPool.waitForDone();
     m_cancelFlag = false;
@@ -94,49 +102,101 @@ void ImageModel::setDirectory(const QString &path)
     m_pendingRows.clear();
     m_currentDir = path;
 
-    QDir dir(path);
+    // Build set of supported image extensions (lower-case, without dot)
+    QSet<QByteArray> imageExts;
+    for (const QByteArray &fmt : QImageReader::supportedImageFormats())
+        imageExts.insert(fmt.toLower());
+
+    // Use std::filesystem::directory_iterator so that directory entries with
+    // non-UTF-8 filenames (e.g. Latin-1 encoded names) are not silently
+    // skipped or mangled as they would be with QDir::entryInfoList().
+    namespace fs = std::filesystem;
+
+    std::vector<std::string> dirs;
+    std::vector<std::string> imageFiles;
+
+    try {
+        fs::path dirPath(path.toStdString());
+
+        // Add ".." parent entry directly with the literal display name ".."
+        // (mirrors QDir::NoDot behaviour)
+        fs::path parentPath = dirPath.parent_path();
+        if (!parentPath.empty() && parentPath != dirPath) {
+            QPixmap folderPixmap = m_folderIcon.pixmap(128, 128);
+            m_items.append({QByteArray::fromStdString(parentPath.native()),
+                            QStringLiteral(".."), folderPixmap, true, true});
+        }
 
-    // Add subdirectories first
-    dir.setFilter(QDir::AllDirs | QDir::NoDot);
-    dir.setSorting(QDir::Name);
-    const auto dirs = dir.entryInfoList();
-    QPixmap folderPixmap = m_folderIcon.pixmap(128, 128);
-    for (const QFileInfo &d : dirs)
-    {
-        QString name = d.fileName();  // preserves ".." for the parent entry
-        m_items.append({d.absoluteFilePath(), name, folderPixmap, true, true});
+        for (const fs::directory_entry &entry :
+             fs::directory_iterator(dirPath,
+                 fs::directory_options::skip_permission_denied))
+        {
+            std::error_code ec;
+            const std::string fname = entry.path().filename().native();
+            if (fname.empty() || fname[0] == '.')
+                continue;   // skip hidden entries
+
+            if (entry.is_directory(ec)) {
+                dirs.push_back(entry.path().native());
+            } else if (entry.is_regular_file(ec)) {
+                // Filter by image extension
+                const std::string &nativeExt = entry.path().extension().native();
+                if (nativeExt.empty())
+                    continue;
+                // extension() includes the dot; strip it and lower-case
+                QByteArray ext = QByteArray(nativeExt.c_str() + 1,
+                                           static_cast<qsizetype>(nativeExt.size()) - 1).toLower();
+                if (imageExts.contains(ext))
+                    imageFiles.push_back(entry.path().native());
+            }
+        }
+    } catch (const fs::filesystem_error &) {
+        // Directory unreadable — show empty listing
     }
 
-    // Then add image files
-    QStringList filters;
+    // Sort subdirectories by filename
+    std::sort(dirs.begin(), dirs.end(),
+              [](const auto &a, const auto &b) {
+                  return fs::path(a).filename() < fs::path(b).filename();
+              });
 
-    const auto formats = QImageReader::supportedImageFormats();
-    for (const QByteArray &fmt : formats)
-        filters << "*." + fmt;
+    std::sort(imageFiles.begin(), imageFiles.end(),
+              [](const auto &a, const auto &b) {
+                  return fs::path(a).filename() < fs::path(b).filename();
+              });
 
-    dir.setNameFilters(filters);
-    dir.setFilter(QDir::Files);
-    dir.setSorting(QDir::Name);
-
-    const auto files = dir.entryInfoList();
+    QPixmap folderPixmap = m_folderIcon.pixmap(128, 128);
+    for (const std::string &nativePath : dirs)
+    {
+        QByteArray entryPath = QByteArray::fromStdString(nativePath);
+        std::string fname = fs::path(nativePath).filename().native();
+        QString displayName = QString::fromLocal8Bit(fname.c_str(),
+                                                     static_cast<qsizetype>(fname.size()));
+        m_items.append({entryPath, displayName, folderPixmap, true, true});
+    }
 
     // Restore cached thumbnails for this folder if available
     const ThumbnailMap *cached = m_folderThumbnailCache.contains(path)
         ? &m_folderThumbnailCache[path]
         : nullptr;
 
-    for (const QFileInfo &file : files)
+    for (const std::string &nativePath : imageFiles)
     {
+        QByteArray entryPath = QByteArray::fromStdString(nativePath);
+        std::string fname = fs::path(nativePath).filename().native();
+        QString displayName = QString::fromLocal8Bit(fname.c_str(),
+                                                     static_cast<qsizetype>(fname.size()));
+
         QPixmap thumb = m_placeholder;
         bool loaded = false;
         if (cached) {
-            auto it = cached->find(file.absoluteFilePath());
+            auto it = cached->find(entryPath);
             if (it != cached->end()) {
                 thumb = it.value();
                 loaded = true;
             }
         }
-        m_items.append({file.absoluteFilePath(), file.fileName(), thumb, loaded, false});
+        m_items.append({entryPath, displayName, thumb, loaded, false});
     }
 
     endResetModel();
@@ -187,7 +247,7 @@ void ImageModel::queueRow(int row)
     m_threadPool.start(worker);
 }
 
-QString ImageModel::filePath(const QModelIndex &index) const
+QByteArray ImageModel::filePath(const QModelIndex &index) const
 {
     if (!index.isValid())
         return {};
@@ -202,7 +262,7 @@ bool ImageModel::isFolder(const QModelIndex &index) const
     return m_items[index.row()].isFolder;
 }
 
-QString ImageModel::currentDirectory() const
+QByteArray ImageModel::currentDirectory() const
 {
     return m_currentDir;
 }
diff --git a/src/imagemodel.h b/src/imagemodel.h
index 515de46..e64708d 100644
--- a/src/imagemodel.h
+++ b/src/imagemodel.h
@@ -3,6 +3,7 @@
 #include "thumbnailcache.h"
 
 #include <QAbstractListModel>
+#include <QByteArray>
 #include <QPixmap>
 #include <QVector>
 #include <QThreadPool>
@@ -22,10 +23,12 @@ public:
     explicit ImageModel(QObject *parent = nullptr);
     ~ImageModel();
 
-    void setDirectory(const QString &path);
-    QString filePath(const QModelIndex &index) const;
+    // path is the raw native OS byte string (handles non-UTF-8 filenames)
+    void setDirectory(const QByteArray &path);
+    void setDirectory(const QString &path);   // convenience: converts via QFile::encodeName
+    QByteArray filePath(const QModelIndex &index) const;
     bool isFolder(const QModelIndex &index) const;
-    QString currentDirectory() const;
+    QByteArray currentDirectory() const;
 
     void requestThumbnails(int firstRow, int lastRow);
     void setCacheMaxSize(int n);
@@ -39,7 +42,7 @@ public:
 private:
     struct Item
     {
-        QString path;
+        QByteArray path;      // raw native OS bytes — safe for non-UTF-8 filenames
         QString displayName;
         QPixmap thumbnail;
         bool loaded = false;
@@ -48,7 +51,7 @@ private:
 
     void queueRow(int row);
 
-    using ThumbnailMap = QHash<QString, QPixmap>;
+    using ThumbnailMap = QHash<QByteArray, QPixmap>;
 
     QVector<Item> m_items;
     QThreadPool m_threadPool;
@@ -57,11 +60,11 @@ private:
     QSet<int> m_pendingRows;
     std::atomic_bool m_cancelFlag{false};
     QIcon m_folderIcon;
-    QString m_currentDir;
+    QByteArray m_currentDir;
 
     // Folder thumbnail cache (last N visited directories)
-    QHash<QString, ThumbnailMap> m_folderThumbnailCache;
-    QList<QString> m_cacheOrder;
+    QHash<QByteArray, ThumbnailMap> m_folderThumbnailCache;
+    QList<QByteArray> m_cacheOrder;
     int m_cacheMaxSize = 4;
 
     ThumbnailCache::Size m_thumbnailSize = ThumbnailCache::Size::Normal;
diff --git a/src/imageviewwidget.cpp b/src/imageviewwidget.cpp
index b94233d..44802b2 100644
--- a/src/imageviewwidget.cpp
+++ b/src/imageviewwidget.cpp
@@ -3,21 +3,38 @@
 #include <QPainter>
 #include <QKeyEvent>
 #include <QMouseEvent>
+#include <QFile>
 #include <QImageReader>
 #include <QPalette>
 #include <algorithm>
 #include <iostream>
 
+#include <fcntl.h>
+#include <unistd.h>
+
 // --- ImageLoadWorker ---
 
-ImageLoadWorker::ImageLoadWorker(const QString &path, QObject *parent)
+ImageLoadWorker::ImageLoadWorker(const QByteArray &path, QObject *parent)
     : QThread(parent), m_path(path)
 {
 }
 
 void ImageLoadWorker::run()
 {
-    QImageReader reader(m_path);
+    int fd = ::open(m_path.constData(), O_RDONLY | O_CLOEXEC);
+    if (fd < 0) {
+        emit imageLoaded(m_path, QPixmap{});
+        return;
+    }
+
+    QFile file;
+    if (!file.open(fd, QIODevice::ReadOnly, QFileDevice::AutoCloseHandle)) {
+        ::close(fd);
+        emit imageLoaded(m_path, QPixmap{});
+        return;
+    }
+
+    QImageReader reader(&file);
     reader.setAutoTransform(true);
     reader.setDecideFormatFromContent(true);
     reader.setAllocationLimit(0);
@@ -44,9 +61,19 @@ ImageViewWidget::ImageViewWidget(QWidget *parent)
     setBackgroundColor("black");
 }
 
-QPixmap ImageViewWidget::loadImageFromDisk(const QString &path)
+QPixmap ImageViewWidget::loadImageFromDisk(const QByteArray &path)
 {
-    QImageReader reader(path);
+    int fd = ::open(path.constData(), O_RDONLY | O_CLOEXEC);
+    if (fd < 0)
+        return {};
+
+    QFile file;
+    if (!file.open(fd, QIODevice::ReadOnly, QFileDevice::AutoCloseHandle)) {
+        ::close(fd);
+        return {};
+    }
+
+    QImageReader reader(&file);
     reader.setAutoTransform(true);
     reader.setDecideFormatFromContent(true);
     reader.setAllocationLimit(0);
@@ -59,10 +86,10 @@ QPixmap ImageViewWidget::loadImageFromDisk(const QString &path)
             image = image.convertToFormat(QImage::Format_ARGB32);
         return QPixmap::fromImage(image);
     }
-    return QPixmap();
+    return {};
 }
 
-void ImageViewWidget::setImage(const QString &path)
+void ImageViewWidget::setImage(const QByteArray &path)
 {
     m_currentPath = path;
     m_exifData = ExifData{}; // clear stale EXIF until new data is set
@@ -83,7 +110,7 @@ void ImageViewWidget::setImage(const QString &path)
     // Trigger prefetch of neighbors if they have been set
     if (!m_neighborPaths.isEmpty()) {
         // Evict entries that are no longer in the neighbor window
-        QSet<QString> keep(m_neighborPaths.begin(), m_neighborPaths.end());
+        QSet<QByteArray> keep(m_neighborPaths.begin(), m_neighborPaths.end());
         keep.insert(m_currentPath);
         for (auto it = m_cache.begin(); it != m_cache.end(); ) {
             if (!keep.contains(it.key()))
@@ -93,13 +120,13 @@ void ImageViewWidget::setImage(const QString &path)
         }
 
         // Prefetch neighbors that are not yet cached
-        for (const QString &neighbor : m_neighborPaths) {
+        for (const QByteArray &neighbor : m_neighborPaths) {
             prefetchImage(neighbor);
         }
     }
 }
 
-void ImageViewWidget::prefetchImage(const QString &path)
+void ImageViewWidget::prefetchImage(const QByteArray &path)
 {
     if (m_cache.contains(path) || m_pendingLoads.contains(path))
         return;
@@ -111,19 +138,19 @@ void ImageViewWidget::prefetchImage(const QString &path)
     worker->start();
 }
 
-void ImageViewWidget::onImageLoaded(const QString &path, const QPixmap &pixmap)
+void ImageViewWidget::onImageLoaded(const QByteArray &path, const QPixmap &pixmap)
 {
     m_pendingLoads.remove(path);
 
     // Only cache if path is still relevant (current or a neighbor)
-    QSet<QString> keep(m_neighborPaths.begin(), m_neighborPaths.end());
+    QSet<QByteArray> keep(m_neighborPaths.begin(), m_neighborPaths.end());
     keep.insert(m_currentPath);
     if (keep.contains(path)) {
         m_cache[path] = pixmap;
     }
 }
 
-void ImageViewWidget::setNeighborPaths(const QStringList &paths)
+void ImageViewWidget::setNeighborPaths(const QList<QByteArray> &paths)
 {
     m_neighborPaths = paths;
 }
diff --git a/src/imageviewwidget.h b/src/imageviewwidget.h
index 4d87b1b..3895eca 100644
--- a/src/imageviewwidget.h
+++ b/src/imageviewwidget.h
@@ -3,10 +3,10 @@
 #include <QWidget>
 #include <QImage>
 #include <QPixmap>
-#include <QString>
-#include <QPoint>
+#include <QByteArray>
+#include <QList>
 #include <QMap>
-#include <QStringList>
+#include <QSet>
 #include <QThread>
 #include "exifreader.h"
 
@@ -14,12 +14,12 @@ class ImageLoadWorker : public QThread
 {
     Q_OBJECT
 public:
-    explicit ImageLoadWorker(const QString &path, QObject *parent = nullptr);
+    explicit ImageLoadWorker(const QByteArray &path, QObject *parent = nullptr);
     void run() override;
 signals:
-    void imageLoaded(const QString &path, const QPixmap &pixmap);
+    void imageLoaded(const QByteArray &path, const QPixmap &pixmap);
 private:
-    QString m_path;
+    QByteArray m_path;
 };
 
 class ImageViewWidget : public QWidget
@@ -35,15 +35,15 @@ public:
 
     explicit ImageViewWidget(QWidget *parent = nullptr);
 
-    void setImage(const QString &path);
+    void setImage(const QByteArray &path);
     void setBackgroundColor(const QString &color);
     void zoomIn();
     void zoomOut();
     void zoomOriginal();
     void zoomFitToScreen();
 
-    void prefetchImage(const QString &path);
-    void setNeighborPaths(const QStringList &paths);
+    void prefetchImage(const QByteArray &path);
+    void setNeighborPaths(const QList<QByteArray> &paths);
     void clearCache();
 
     void setExifData(const ExifData &data);
@@ -64,19 +64,19 @@ protected:
 
 private:
     void clampOffset(int imgW, int imgH);
-    QPixmap loadImageFromDisk(const QString &path);
-    void onImageLoaded(const QString &path, const QPixmap &pixmap);
+    QPixmap loadImageFromDisk(const QByteArray &path);
+    void onImageLoaded(const QByteArray &path, const QPixmap &pixmap);
 
     QPixmap m_pixmap;
     ZoomMode m_zoomMode = FitToScreen;
     double m_zoomFactor = 1.0;
     QString m_backgroundColor = "black";
-    QString m_currentPath;
+    QByteArray m_currentPath;
 
     // Image cache: path -> pixmap
-    QMap<QString, QPixmap> m_cache;
-    QStringList m_neighborPaths;       // ordered list of paths around current image
-    QSet<QString> m_pendingLoads;      // paths currently being loaded in background
+    QMap<QByteArray, QPixmap> m_cache;
+    QList<QByteArray> m_neighborPaths;    // ordered list of paths around current image
+    QSet<QByteArray> m_pendingLoads;      // paths currently being loaded in background
 
     // Panning state
     QPoint m_offset;        // current pan offset (pixels)
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 12ff796..110812f 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -5,6 +5,7 @@
 #include "thumbnailcache.h"
 #include "exifreader.h"
 
+#include <QFile>
 #include <QFileSystemModel>
 #include <QTreeView>
 #include <QListView>
@@ -29,6 +30,10 @@
 #include <QTableWidget>
 #include <iostream>
 
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
 namespace
 {
 ThumbnailCache::Size thumbnailSizeFromString(const QString &s)
@@ -160,9 +165,17 @@ void MainWindow::setupMenuBar()
 
 void MainWindow::navigateToFolder(const QString &path)
 {
+    navigateToFolder(QFile::encodeName(path));
+}
+
+void MainWindow::navigateToFolder(const QByteArray &path)
+{
     m_previousFolderPath = m_imageModel->currentDirectory();
     m_imageModel->setDirectory(path);
-    QModelIndex dirIdx = m_dirModel->index(path);
+    // The tree view uses QFileSystemModel which works with QString; convert for it.
+    // If the path contains non-UTF-8 bytes the index lookup may fail — that is
+    // acceptable (the tree view simply won't highlight the node).
+    QModelIndex dirIdx = m_dirModel->index(QFile::decodeName(path));
     if (dirIdx.isValid())
         m_treeView->setCurrentIndex(dirIdx);
     QTimer::singleShot(0, this, [this]() {
@@ -178,19 +191,19 @@ void MainWindow::openPath(const QString &path)
         return;
 
     if (info.isDir()) {
-        navigateToFolder(info.absoluteFilePath());
+        navigateToFolder(QFile::encodeName(info.absoluteFilePath()));
     } else if (info.isFile()) {
-        navigateToFolder(info.absolutePath());
+        navigateToFolder(QFile::encodeName(info.absolutePath()));
 
         // ImageModel::setDirectory is synchronous, so items are ready now.
         // Find the file in the model and open it.
+        QByteArray target = QFile::encodeName(info.absoluteFilePath());
         for (int i = 0; i < m_imageModel->rowCount(); ++i) {
             QModelIndex idx = m_imageModel->index(i);
-            if (m_imageModel->filePath(idx) == info.absoluteFilePath()) {
+            if (m_imageModel->filePath(idx) == target) {
                 m_listView->setCurrentIndex(idx);
                 m_listView->scrollTo(idx);
                 showPreview(idx);
-                // ImageModel only lists image files and folders; non-folder = image.
                 if (!m_imageModel->isFolder(idx))
                     enterSingleImageMode(idx);
                 break;
@@ -208,7 +221,7 @@ void MainWindow::selectPreviousFolderIfExists()
     for (int i = 0; i < m_imageModel->rowCount(); ++i) {
         QModelIndex idx = m_imageModel->index(i);
         if (m_imageModel->isFolder(idx)) {
-            QString folderPath = m_imageModel->filePath(idx);
+            QByteArray folderPath = m_imageModel->filePath(idx);
             if (folderPath == m_previousFolderPath) {
                 m_listView->setCurrentIndex(idx);
                 m_listView->scrollTo(idx);
@@ -246,7 +259,7 @@ void MainWindow::setupConnections()
     connect(m_listView, &QListView::doubleClicked, this,
             [this](const QModelIndex &index) {
                 if (m_imageModel->isFolder(index)) {
-                    QString path = m_imageModel->filePath(index);
+                    QByteArray path = m_imageModel->filePath(index);
                     navigateToFolder(path);
                 } else {
                     enterSingleImageMode(index);
@@ -321,31 +334,36 @@ void MainWindow::showPreview(const QModelIndex &index)
     if (!index.isValid())
         return;
 
-    QString path = m_imageModel->filePath(index);
-
-    QImageReader reader(path);
-    reader.setAutoTransform(true);
-    // Scale during decoding for the preview to avoid the 128 MB allocation limit
-    QSize fullSize = reader.size();
-    if (fullSize.isValid()) {
-        QSize target = fullSize.scaled(m_previewLabel->size(), Qt::KeepAspectRatio);
-        reader.setScaledSize(target);
+    QByteArray path = m_imageModel->filePath(index);
+
+    int fd = ::open(path.constData(), O_RDONLY | O_CLOEXEC);
+    if (fd >= 0) {
+        QFile file;
+        if (file.open(fd, QIODevice::ReadOnly, QFileDevice::AutoCloseHandle)) {
+            QImageReader reader(&file);
+            reader.setAutoTransform(true);
+            QSize fullSize = reader.size();
+            if (fullSize.isValid()) {
+                QSize target = fullSize.scaled(m_previewLabel->size(), Qt::KeepAspectRatio);
+                reader.setScaledSize(target);
+            }
+            QImage image = reader.read();
+            m_previewLabel->setPixmap(
+                QPixmap::fromImage(image).scaled(
+                    m_previewLabel->size(),
+                    Qt::KeepAspectRatio,
+                    Qt::SmoothTransformation));
+        }
     }
-    QImage image = reader.read();
-
-    m_previewLabel->setPixmap(
-        QPixmap::fromImage(image).scaled(
-            m_previewLabel->size(),
-            Qt::KeepAspectRatio,
-            Qt::SmoothTransformation));
 
     updateExifInfo(path);
 }
 
-void MainWindow::updateExifInfo(const QString &path)
+void MainWindow::updateExifInfo(const QByteArray &path)
 {
-    QFileInfo fi(path);
-    if (fi.isDir()) {
+    // Check if this is a folder by attempting stat
+    struct ::stat st{};
+    if (::stat(path.constData(), &st) != 0 || S_ISDIR(st.st_mode)) {
         m_exifTable->setRowCount(0);
         return;
     }
@@ -378,7 +396,7 @@ void MainWindow::enterSingleImageMode(const QModelIndex &index)
     }
 
     m_imageView->setBackgroundColor(m_backgroundColorPreference);
-    QString path = m_imageModel->filePath(index);
+    QByteArray path = m_imageModel->filePath(index);
     m_imageView->setNeighborPaths(computeNeighborPaths(index));
     m_imageView->setImage(path);
     m_imageView->setExifData(ExifReader::read(path));
@@ -412,9 +430,9 @@ void MainWindow::leaveSingleImageMode()
     m_listView->setFocus();
 }
 
-QStringList MainWindow::computeNeighborPaths(const QModelIndex &index) const
+QList<QByteArray> MainWindow::computeNeighborPaths(const QModelIndex &index) const
 {
-    QStringList paths;
+    QList<QByteArray> paths;
     int row = index.row();
 
     // Collect up to CacheKeepBehind non-folder images before current
@@ -475,7 +493,7 @@ void MainWindow::keyPressEvent(QKeyEvent *event)
         if (current.isValid())
         {
             if (m_imageModel->isFolder(current)) {
-                QString path = m_imageModel->filePath(current);
+                QByteArray path = m_imageModel->filePath(current);
                 navigateToFolder(path);
             } else {
                 enterSingleImageMode(current);
diff --git a/src/mainwindow.h b/src/mainwindow.h
index fef271a..444b448 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <QByteArray>
 #include <QMainWindow>
 
 class QTreeView;
@@ -31,15 +32,16 @@ private:
     void savePreferences();
     void onPreferencesTriggered();
     void resetLayoutToDefault();
-    void navigateToFolder(const QString &path);
+    void navigateToFolder(const QByteArray &path);
+    void navigateToFolder(const QString &path);  // convenience: converts via QFile::encodeName
     void selectPreviousFolderIfExists();
     void setFullScreenMode(bool fullScreen);
     void loadVisibleThumbnails();
     void showPreview(const QModelIndex &index);
-    void updateExifInfo(const QString &path);
+    void updateExifInfo(const QByteArray &path);
     void enterSingleImageMode(const QModelIndex &index);
     void leaveSingleImageMode();
-    QStringList computeNeighborPaths(const QModelIndex &index) const;
+    QList<QByteArray> computeNeighborPaths(const QModelIndex &index) const;
 
     void keyPressEvent(QKeyEvent *event) override;
     bool eventFilter(QObject *obj, QEvent *event) override;
@@ -61,7 +63,7 @@ private:
     ImageViewWidget *m_imageView;
     bool m_wasMaximized = false;
     bool m_imageViewWasFullScreen = false;
-    QString m_previousFolderPath;
+    QByteArray m_previousFolderPath;
     QMenuBar *m_menuBar = nullptr;
     QDockWidget *m_rootDock = nullptr;
     QDockWidget *m_folderDock = nullptr;
diff --git a/src/thumbnailcache.cpp b/src/thumbnailcache.cpp
index fd25ee2..8f6ad00 100644
--- a/src/thumbnailcache.cpp
+++ b/src/thumbnailcache.cpp
@@ -3,12 +3,12 @@
 #include <QCryptographicHash>
 #include <QDir>
 #include <QFile>
-#include <QFileInfo>
-#include <QMimeDatabase>
 #include <QStandardPaths>
 #include <QTemporaryFile>
 #include <QUrl>
 
+#include <sys/stat.h>
+
 namespace
 {
 constexpr const char *kSoftware = "SagoImageBrowser";
@@ -38,43 +38,41 @@ QString ThumbnailCache::subdirFor(Size size)
     return cacheRoot() + "/" + name;
 }
 
-QString ThumbnailCache::canonicalUri(const QString &absPath)
+QByteArray ThumbnailCache::canonicalUri(const QByteArray &absPath)
 {
-    // Per the spec, use the absolute file URI (percent-encoded).
-    return QUrl::fromLocalFile(absPath).toString(QUrl::FullyEncoded);
+    // Build a correct file:// URI by percent-encoding the raw byte path.
+    // Forward slashes are kept unencoded; all other bytes (including non-UTF-8
+    // ones such as Latin-1 \xF8) are percent-encoded.
+    return "file://" + QUrl::toPercentEncoding(absPath, "/");
 }
 
-QString ThumbnailCache::hashedName(const QString &canonicalUri)
+QString ThumbnailCache::hashedName(const QByteArray &canonicalUri)
 {
-    QByteArray hash = QCryptographicHash::hash(canonicalUri.toUtf8(),
-                                               QCryptographicHash::Md5)
-                          .toHex();
+    QByteArray hash =
+        QCryptographicHash::hash(canonicalUri, QCryptographicHash::Md5).toHex();
     return QString::fromLatin1(hash) + ".png";
 }
 
-bool ThumbnailCache::isInsideCache(const QString &absPath)
+bool ThumbnailCache::isInsideCache(const QByteArray &absPath)
 {
-    QString abs = QFileInfo(absPath).absoluteFilePath();
-    QString root = QFileInfo(cacheRoot()).absoluteFilePath();
-    if (root.isEmpty())
-        return false;
-    return abs.startsWith(root + "/") || abs == root;
+    QByteArray root = cacheRoot().toUtf8(); // cache root is always valid UTF-8
+    return absPath.startsWith(root + '/') || absPath == root;
 }
 
-QImage ThumbnailCache::load(const QString &sourcePath, Size size)
+QImage ThumbnailCache::load(const QByteArray &sourcePath, Size size)
 {
-    QFileInfo info(sourcePath);
-    if (!info.exists() || !info.isFile())
+    struct ::stat st{};
+    if (::stat(sourcePath.constData(), &st) != 0 || !S_ISREG(st.st_mode))
         return {};
 
-    const QString uri = canonicalUri(info.absoluteFilePath());
+    const QByteArray uri = canonicalUri(sourcePath);
     const QString cachePath = subdirFor(size) + "/" + hashedName(uri);
 
     QImage img;
     if (!img.load(cachePath, "PNG"))
         return {};
 
-    const qint64 mtime = info.lastModified().toSecsSinceEpoch();
+    const qint64 mtime = static_cast<qint64>(st.st_mtime);
     bool ok = false;
     const qint64 cachedMTime = img.text("Thumb::MTime").toLongLong(&ok);
     if (!ok || cachedMTime != mtime)
@@ -83,16 +81,16 @@ QImage ThumbnailCache::load(const QString &sourcePath, Size size)
     return img;
 }
 
-void ThumbnailCache::save(const QString &sourcePath, Size size, const QImage &thumbImage)
+void ThumbnailCache::save(const QByteArray &sourcePath, Size size, const QImage &thumbImage)
 {
     if (thumbImage.isNull())
         return;
 
-    QFileInfo info(sourcePath);
-    if (!info.exists() || !info.isFile())
+    struct ::stat st{};
+    if (::stat(sourcePath.constData(), &st) != 0 || !S_ISREG(st.st_mode))
         return;
 
-    const QString uri = canonicalUri(info.absoluteFilePath());
+    const QByteArray uri = canonicalUri(sourcePath);
     const QString subdir = subdirFor(size);
     const QString finalPath = subdir + "/" + hashedName(uri);
 
@@ -103,16 +101,10 @@ void ThumbnailCache::save(const QString &sourcePath, Size size, const QImage &th
     QFile::setPermissions(cacheRoot(), dirPerms());
 
     QImage tagged = thumbImage;
-    tagged.setText("Thumb::URI", uri);
+    tagged.setText("Thumb::URI", QString::fromLatin1(uri));
     tagged.setText("Thumb::MTime",
-                   QString::number(info.lastModified().toSecsSinceEpoch()));
-    tagged.setText("Thumb::Size", QString::number(info.size()));
-    QMimeDatabase mimeDb;
-    QString mime = mimeDb.mimeTypeForFile(info).name();
-    if (!mime.isEmpty())
-        tagged.setText("Thumb::Mimetype", mime);
-    tagged.setText("Thumb::Image::Width", QString::number(thumbImage.width()));
-    tagged.setText("Thumb::Image::Height", QString::number(thumbImage.height()));
+                   QString::number(static_cast<qint64>(st.st_mtime)));
+    tagged.setText("Thumb::Size", QString::number(static_cast<qint64>(st.st_size)));
     tagged.setText("Software", QString::fromLatin1(kSoftware));
 
     QTemporaryFile tmp(subdir + "/tmp_XXXXXX.png");
diff --git a/src/thumbnailcache.h b/src/thumbnailcache.h
index 67b9155..d9c0f66 100644
--- a/src/thumbnailcache.h
+++ b/src/thumbnailcache.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <QByteArray>
 #include <QString>
 #include <QImage>
 
@@ -13,17 +14,17 @@ public:
     };
 
     // Returns a non-null QImage if a valid cached thumbnail exists for sourcePath
-    // at the requested size. Validity is determined by comparing the original
-    // file's mtime to the Thumb::MTime tEXt chunk in the cached PNG.
-    static QImage load(const QString &sourcePath, Size size);
+    // at the requested size. sourcePath must be the raw native OS byte string.
+    static QImage load(const QByteArray &sourcePath, Size size);
 
     // Atomically writes thumbImage to the cache with the required Freedesktop
-    // tEXt chunks. No-op if sourcePath cannot be stat'ed.
-    static void save(const QString &sourcePath, Size size, const QImage &thumbImage);
+    // tEXt chunks. sourcePath must be the raw native OS byte string.
+    static void save(const QByteArray &sourcePath, Size size, const QImage &thumbImage);
 
     static QString cacheRoot();
     static QString subdirFor(Size size);
-    static QString canonicalUri(const QString &absPath);
-    static QString hashedName(const QString &canonicalUri);
-    static bool isInsideCache(const QString &absPath);
+    // Canonical file:// URI built from raw byte path (correct percent-encoding)
+    static QByteArray canonicalUri(const QByteArray &absPath);
+    static QString hashedName(const QByteArray &canonicalUri);
+    static bool isInsideCache(const QByteArray &absPath);
 };
diff --git a/src/thumbnailworker.cpp b/src/thumbnailworker.cpp
index 04868a5..3e1024f 100644
--- a/src/thumbnailworker.cpp
+++ b/src/thumbnailworker.cpp
@@ -2,8 +2,12 @@
 
 #include "thumbnailcache.h"
 
+#include <QFile>
 #include <QImageReader>
 
+#include <fcntl.h>
+#include <unistd.h>
+
 namespace
 {
 constexpr int kDisplaySize = 128;
@@ -20,7 +24,7 @@ QImage downscaleForDisplay(const QImage &src)
 }
 } // namespace
 
-ThumbnailWorker::ThumbnailWorker(const QString &path,
+ThumbnailWorker::ThumbnailWorker(const QByteArray &path,
                                  int row,
                                  ThumbnailCache::Size size,
                                  std::atomic_bool *cancelFlag)
@@ -53,7 +57,20 @@ void ThumbnailWorker::run()
         return;
     }
 
-    QImageReader reader(m_path);
+    // Open the file via POSIX open() so that paths with non-UTF-8 bytes
+    // (e.g. Latin-1 encoded filenames) are handled correctly.
+    int fd = ::open(m_path.constData(), O_RDONLY | O_CLOEXEC);
+    if (fd < 0)
+        return;
+
+    QFile file;
+    if (!file.open(fd, QIODevice::ReadOnly, QFileDevice::AutoCloseHandle))
+    {
+        ::close(fd);
+        return;
+    }
+
+    QImageReader reader(&file);
     reader.setAutoTransform(true);
 
     // Scale during decoding to avoid hitting the allocation limit
diff --git a/src/thumbnailworker.h b/src/thumbnailworker.h
index c481763..65d6485 100644
--- a/src/thumbnailworker.h
+++ b/src/thumbnailworker.h
@@ -2,6 +2,7 @@
 
 #include "thumbnailcache.h"
 
+#include <QByteArray>
 #include <QRunnable>
 #include <QObject>
 #include <QImage>
@@ -12,7 +13,7 @@ class ThumbnailWorker : public QObject, public QRunnable
     Q_OBJECT
 
 public:
-    ThumbnailWorker(const QString &path,
+    ThumbnailWorker(const QByteArray &path,
                     int row,
                     ThumbnailCache::Size size,
                     std::atomic_bool *cancelFlag);
@@ -23,7 +24,7 @@ signals:
     void finished(int row, const QImage &image);
 
 private:
-    QString m_path;
+    QByteArray m_path;
     int m_row;
     ThumbnailCache::Size m_size;
     std::atomic_bool *m_cancelFlag;