diff --git a/deps/CMakeLists.txt b/deps/CMakeLists.txt
index 5f9b48ca..c948a097 100644
--- a/deps/CMakeLists.txt
+++ b/deps/CMakeLists.txt
@@ -40,7 +40,7 @@ set(MATRIX_STRUCTS_URL https://github.com/mujx/matrix-structs)
 set(MATRIX_STRUCTS_TAG eeb7373729a1618e2b3838407863342b88b8a0de)
 
 set(MTXCLIENT_URL https://github.com/mujx/mtxclient)
-set(MTXCLIENT_TAG 26aad7088b9532808ded9919d55f58711c0138e3)
+set(MTXCLIENT_TAG 688d5b0fd1fd16319d7fcbdbf938109eaa850545)
 
 set(OLM_URL https://git.matrix.org/git/olm.git)
 set(OLM_TAG 4065c8e11a33ba41133a086ed3de4da94dcb6bae)
diff --git a/deps/cmake/Olm.cmake b/deps/cmake/Olm.cmake
index dde18db9..c476f71d 100644
--- a/deps/cmake/Olm.cmake
+++ b/deps/cmake/Olm.cmake
@@ -1,8 +1,4 @@
-if(MSVC)
-    set(MAKE_CMD "mingw32-make.exe")
-else()
-    set(MAKE_CMD "make")
-endif()
+set(OLM_PATCH ${CMAKE_CURRENT_SOURCE_DIR}/patches/olm-CMake-Support.patch)
 
 ExternalProject_Add(
   Olm
@@ -12,12 +8,18 @@ ExternalProject_Add(
 
   BUILD_IN_SOURCE 1
   SOURCE_DIR ${DEPS_BUILD_DIR}/olm
-  CONFIGURE_COMMAND ""
-  BUILD_COMMAND ${MAKE_CMD} static
-  INSTALL_COMMAND 
-    mkdir -p ${DEPS_INSTALL_DIR}/lib &&
-    cp -R ${DEPS_BUILD_DIR}/olm/include ${DEPS_INSTALL_DIR} &&
-    cp ${DEPS_BUILD_DIR}/olm/build/libolm.a ${DEPS_INSTALL_DIR}/lib
-)
+  CONFIGURE_COMMAND ${CMAKE_COMMAND} -E copy
+      ${CMAKE_CURRENT_SOURCE_DIR}/cmake/OlmCMakeLists.txt
+      ${DEPS_BUILD_DIR}/olm/CMakeLists.txt
+    COMMAND ${CMAKE_COMMAND} -E copy
+      ${CMAKE_CURRENT_SOURCE_DIR}/cmake/OlmConfig.cmake.in
+      ${DEPS_BUILD_DIR}/olm/cmake/OlmConfig.cmake.in
+    COMMAND ${CMAKE_COMMAND}
+      -DCMAKE_INSTALL_PREFIX=${DEPS_INSTALL_DIR}
+      -DCMAKE_BUILD_TYPE=Release
+      ${DEPS_BUILD_DIR}/olm
+  BUILD_COMMAND ${CMAKE_COMMAND}
+    --build ${DEPS_BUILD_DIR}/olm
+    --config Release)
 
 list(APPEND THIRD_PARTY_DEPS Olm)
diff --git a/deps/cmake/OlmCMakeLists.txt b/deps/cmake/OlmCMakeLists.txt
new file mode 100644
index 00000000..529cbb92
--- /dev/null
+++ b/deps/cmake/OlmCMakeLists.txt
@@ -0,0 +1,107 @@
+cmake_minimum_required(VERSION 3.1)
+
+project(olm VERSION 2.2.2 LANGUAGES CXX C)
+
+add_definitions(-DOLMLIB_VERSION_MAJOR=${PROJECT_VERSION_MAJOR})
+add_definitions(-DOLMLIB_VERSION_MINOR=${PROJECT_VERSION_MINOR})
+add_definitions(-DOLMLIB_VERSION_PATCH=${PROJECT_VERSION_PATCH})
+
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif()
+
+add_library(olm
+    src/account.cpp
+    src/base64.cpp
+    src/cipher.cpp
+    src/crypto.cpp
+    src/memory.cpp
+    src/message.cpp
+    src/pickle.cpp
+    src/ratchet.cpp
+    src/session.cpp
+    src/utility.cpp
+
+    src/ed25519.c
+    src/error.c
+    src/inbound_group_session.c
+    src/megolm.c
+    src/olm.cpp
+    src/outbound_group_session.c
+    src/pickle_encoding.c
+
+    lib/crypto-algorithms/aes.c
+    lib/crypto-algorithms/sha256.c
+    lib/curve25519-donna/curve25519-donna.c)
+add_library(Olm::Olm ALIAS olm)
+
+target_include_directories(olm
+    PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/lib)
+
+set_target_properties(olm PROPERTIES
+   SOVERSION ${PROJECT_VERSION_MAJOR}
+   VERSION ${PROJECT_VERSION})
+
+set_target_properties(olm PROPERTIES
+    ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_BINDIR}
+    LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR}
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/${CMAKE_INSTALL_LIBDIR})
+
+#
+# Installation
+#
+include(GNUInstallDirs)
+set(INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/Olm)
+install(TARGETS olm
+    EXPORT olm-targets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+# The exported target will be named Olm.
+set_target_properties(olm PROPERTIES EXPORT_NAME Olm)
+install(FILES
+    ${CMAKE_SOURCE_DIR}/include/olm/olm.h
+    ${CMAKE_SOURCE_DIR}/include/olm/outbound_group_session.h
+    ${CMAKE_SOURCE_DIR}/include/olm/inbound_group_session.h
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/olm)
+
+# Export the targets to a script.
+install(EXPORT olm-targets
+  FILE OlmTargets.cmake
+  NAMESPACE Olm::
+  DESTINATION ${INSTALL_CONFIGDIR})
+
+# Create a ConfigVersion.cmake file.
+include(CMakePackageConfigHelpers)
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/OlmConfigVersion.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion)
+
+configure_package_config_file(
+    ${CMAKE_CURRENT_LIST_DIR}/cmake/OlmConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/OlmConfig.cmake
+    INSTALL_DESTINATION ${INSTALL_CONFIGDIR})
+
+#Install the config & configversion.
+install(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/OlmConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/OlmConfigVersion.cmake
+    DESTINATION ${INSTALL_CONFIGDIR})
+
+# Register package in user's package registry
+export(EXPORT olm-targets
+    FILE ${CMAKE_CURRENT_BINARY_DIR}/OlmTargets.cmake
+    NAMESPACE Olm::)
+export(PACKAGE Olm)
diff --git a/deps/cmake/OlmConfig.cmake.in b/deps/cmake/OlmConfig.cmake.in
new file mode 100644
index 00000000..a7541f7a
--- /dev/null
+++ b/deps/cmake/OlmConfig.cmake.in
@@ -0,0 +1,11 @@
+get_filename_component(Olm_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
+include(CMakeFindDependencyMacro)
+
+list(APPEND CMAKE_MODULE_PATH ${Olm_CMAKE_DIR})
+list(REMOVE_AT CMAKE_MODULE_PATH -1)
+
+if(NOT TARGET Olm::olm)
+  include("${Olm_CMAKE_DIR}/OlmTargets.cmake")
+endif()
+
+set(Olm_LIBRARIES Olm::olm)
diff --git a/include/Logging.hpp b/include/Logging.hpp
index bdbd3e2c..2feae60d 100644
--- a/include/Logging.hpp
+++ b/include/Logging.hpp
@@ -3,12 +3,12 @@
 #include <memory>
 #include <spdlog/spdlog.h>
 
-namespace log {
+namespace nhlog {
 void
 init(const std::string &file);
 
 std::shared_ptr<spdlog::logger>
-main();
+ui();
 
 std::shared_ptr<spdlog::logger>
 net();
diff --git a/include/timeline/TimelineItem.h b/include/timeline/TimelineItem.h
index 4dcca1a5..6623a82c 100644
--- a/include/timeline/TimelineItem.h
+++ b/include/timeline/TimelineItem.h
@@ -194,19 +194,7 @@ public:
         void setEventId(const QString &event_id) { event_id_ = event_id; }
         void markReceived();
         void setRoomId(QString room_id) { room_id_ = room_id; }
-        void sendReadReceipt() const
-        {
-                if (!event_id_.isEmpty())
-                        http::v2::client()->read_event(
-                          room_id_.toStdString(),
-                          event_id_.toStdString(),
-                          [this](mtx::http::RequestErr err) {
-                                  if (err) {
-                                          qWarning() << QString("failed to read_event (%1, %2)")
-                                                          .arg(room_id_, event_id_);
-                                  }
-                          });
-        }
+        void sendReadReceipt() const;
 
         //! Add a user avatar for this event.
         void addAvatar();
diff --git a/src/AvatarProvider.cc b/src/AvatarProvider.cc
index ad095023..391f57d9 100644
--- a/src/AvatarProvider.cc
+++ b/src/AvatarProvider.cc
@@ -56,10 +56,10 @@ resolve(const QString &room_id, const QString &user_id, QObject *receiver, Avata
           opts,
           [opts, proxy = std::move(proxy)](const std::string &res, mtx::http::RequestErr err) {
                   if (err) {
-                          log::net()->warn("failed to download avatar: {} - ({} {})",
-                                           opts.mxc_url,
-                                           mtx::errors::to_string(err->matrix_error.errcode),
-                                           err->matrix_error.error);
+                          nhlog::net()->warn("failed to download avatar: {} - ({} {})",
+                                             opts.mxc_url,
+                                             mtx::errors::to_string(err->matrix_error.errcode),
+                                             err->matrix_error.error);
                           return;
                   }
 
diff --git a/src/Cache.cc b/src/Cache.cc
index 7c678b72..20572ece 100644
--- a/src/Cache.cc
+++ b/src/Cache.cc
@@ -119,7 +119,7 @@ Cache::Cache(const QString &userId, QObject *parent)
 void
 Cache::setup()
 {
-        log::db()->debug("setting up cache");
+        nhlog::db()->debug("setting up cache");
 
         auto statePath = QString("%1/%2")
                            .arg(QStandardPaths::writableLocation(QStandardPaths::CacheLocation))
@@ -136,7 +136,7 @@ Cache::setup()
         env_.set_max_dbs(1024UL);
 
         if (isInitial) {
-                log::db()->info("initializing LMDB");
+                nhlog::db()->info("initializing LMDB");
 
                 if (!QDir().mkpath(statePath)) {
                         throw std::runtime_error(
@@ -152,7 +152,7 @@ Cache::setup()
                                                  std::string(e.what()));
                 }
 
-                log::db()->warn("resetting cache due to LMDB version mismatch: {}", e.what());
+                nhlog::db()->warn("resetting cache due to LMDB version mismatch: {}", e.what());
 
                 QDir stateDir(statePath);
 
@@ -188,7 +188,7 @@ Cache::setup()
 void
 Cache::setEncryptedRoom(const std::string &room_id)
 {
-        log::db()->info("mark room {} as encrypted", room_id);
+        nhlog::db()->info("mark room {} as encrypted", room_id);
 
         auto txn = lmdb::txn::begin(env_);
         auto db  = lmdb::dbi::open(txn, ENCRYPTED_ROOMS_DB, MDB_CREATE);
@@ -398,7 +398,7 @@ Cache::restoreSessions()
                                   unpickle<OutboundSessionObject>(obj.at("session"), SECRET);
                                 session_storage.group_outbound_sessions[key] = std::move(session);
                         } catch (const nlohmann::json::exception &e) {
-                                log::db()->critical(
+                                nhlog::db()->critical(
                                   "failed to parse outbound megolm session data: {}", e.what());
                         }
                 }
@@ -419,7 +419,7 @@ Cache::restoreSessions()
 
         txn.commit();
 
-        log::db()->info("sessions restored");
+        nhlog::db()->info("sessions restored");
 }
 
 std::string
@@ -453,7 +453,7 @@ Cache::saveImage(const std::string &url, const std::string &img_data)
 
                 txn.commit();
         } catch (const lmdb::error &e) {
-                log::db()->critical("saveImage: {}", e.what());
+                nhlog::db()->critical("saveImage: {}", e.what());
         }
 }
 
@@ -478,7 +478,7 @@ Cache::image(lmdb::txn &txn, const std::string &url) const
 
                 return QByteArray(image.data(), image.size());
         } catch (const lmdb::error &e) {
-                log::db()->critical("image: {}, {}", e.what(), url);
+                nhlog::db()->critical("image: {}, {}", e.what(), url);
         }
 
         return QByteArray();
@@ -506,7 +506,7 @@ Cache::image(const QString &url) const
 
                 return QByteArray(image.data(), image.size());
         } catch (const lmdb::error &e) {
-                log::db()->critical("image: {} {}", e.what(), url.toStdString());
+                nhlog::db()->critical("image: {} {}", e.what(), url.toStdString());
         }
 
         return QByteArray();
@@ -588,7 +588,7 @@ Cache::deleteData()
         // TODO: We need to remove the env_ while not accepting new requests.
         if (!cacheDirectory_.isEmpty()) {
                 QDir(cacheDirectory_).removeRecursively();
-                log::db()->info("deleted cache files from disk");
+                nhlog::db()->info("deleted cache files from disk");
         }
 }
 
@@ -608,9 +608,9 @@ Cache::isFormatValid()
         std::string stored_version(current_version.data(), current_version.size());
 
         if (stored_version != CURRENT_CACHE_FORMAT_VERSION) {
-                log::db()->warn("breaking changes in the cache format. stored: {}, current: {}",
-                                stored_version,
-                                CURRENT_CACHE_FORMAT_VERSION);
+                nhlog::db()->warn("breaking changes in the cache format. stored: {}, current: {}",
+                                  stored_version,
+                                  CURRENT_CACHE_FORMAT_VERSION);
                 return false;
         }
 
@@ -660,7 +660,7 @@ Cache::readReceipts(const QString &event_id, const QString &room_id)
                 }
 
         } catch (const lmdb::error &e) {
-                log::db()->critical("readReceipts: {}", e.what());
+                nhlog::db()->critical("readReceipts: {}", e.what());
         }
 
         return receipts;
@@ -710,7 +710,7 @@ Cache::updateReadReceipt(lmdb::txn &txn, const std::string &room_id, const Recei
                                       lmdb::val(merged_receipts.data(), merged_receipts.size()));
 
                 } catch (const lmdb::error &e) {
-                        log::db()->critical("updateReadReceipts: {}", e.what());
+                        nhlog::db()->critical("updateReadReceipts: {}", e.what());
                 }
         }
 }
@@ -868,9 +868,9 @@ Cache::singleRoomInfo(const std::string &room_id)
 
                         return tmp;
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse room info: room_id ({}), {}",
-                                        room_id,
-                                        std::string(data.data(), data.size()));
+                        nhlog::db()->warn("failed to parse room info: room_id ({}), {}",
+                                          room_id,
+                                          std::string(data.data(), data.size()));
                 }
         }
 
@@ -900,9 +900,9 @@ Cache::getRoomInfo(const std::vector<std::string> &rooms)
 
                                 room_info.emplace(QString::fromStdString(room), std::move(tmp));
                         } catch (const json::exception &e) {
-                                log::db()->warn("failed to parse room info: room_id ({}), {}",
-                                                room,
-                                                std::string(data.data(), data.size()));
+                                nhlog::db()->warn("failed to parse room info: room_id ({}), {}",
+                                                  room,
+                                                  std::string(data.data(), data.size()));
                         }
                 } else {
                         // Check if the room is an invite.
@@ -915,7 +915,7 @@ Cache::getRoomInfo(const std::vector<std::string> &rooms)
                                         room_info.emplace(QString::fromStdString(room),
                                                           std::move(tmp));
                                 } catch (const json::exception &e) {
-                                        log::db()->warn(
+                                        nhlog::db()->warn(
                                           "failed to parse room info for invite: room_id ({}), {}",
                                           room,
                                           std::string(data.data(), data.size()));
@@ -1003,7 +1003,7 @@ Cache::getRoomAvatarUrl(lmdb::txn &txn,
 
                         return QString::fromStdString(msg.content.url);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.avatar event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.avatar event: {}", e.what());
                 }
         }
 
@@ -1026,7 +1026,7 @@ Cache::getRoomAvatarUrl(lmdb::txn &txn,
                         cursor.close();
                         return QString::fromStdString(m.avatar_url);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse member info: {}", e.what());
+                        nhlog::db()->warn("failed to parse member info: {}", e.what());
                 }
         }
 
@@ -1053,7 +1053,7 @@ Cache::getRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb)
                         if (!msg.content.name.empty())
                                 return QString::fromStdString(msg.content.name);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.name event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.name event: {}", e.what());
                 }
         }
 
@@ -1068,8 +1068,8 @@ Cache::getRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb)
                         if (!msg.content.alias.empty())
                                 return QString::fromStdString(msg.content.alias);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.canonical_alias event: {}",
-                                        e.what());
+                        nhlog::db()->warn("failed to parse m.room.canonical_alias event: {}",
+                                          e.what());
                 }
         }
 
@@ -1085,7 +1085,7 @@ Cache::getRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &membersdb)
                 try {
                         members.emplace(user_id, json::parse(member_data));
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse member info: {}", e.what());
+                        nhlog::db()->warn("failed to parse member info: {}", e.what());
                 }
 
                 ii++;
@@ -1129,7 +1129,7 @@ Cache::getRoomJoinRule(lmdb::txn &txn, lmdb::dbi &statesdb)
                           json::parse(std::string(event.data(), event.size()));
                         return msg.content.join_rule;
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.join_rule event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.join_rule event: {}", e.what());
                 }
         }
         return JoinRule::Knock;
@@ -1151,7 +1151,8 @@ Cache::getRoomGuestAccess(lmdb::txn &txn, lmdb::dbi &statesdb)
                           json::parse(std::string(event.data(), event.size()));
                         return msg.content.guest_access == AccessState::CanJoin;
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.guest_access event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.guest_access event: {}",
+                                          e.what());
                 }
         }
         return false;
@@ -1175,7 +1176,7 @@ Cache::getRoomTopic(lmdb::txn &txn, lmdb::dbi &statesdb)
                         if (!msg.content.topic.empty())
                                 return QString::fromStdString(msg.content.topic);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.topic event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.topic event: {}", e.what());
                 }
         }
 
@@ -1198,7 +1199,7 @@ Cache::getInviteRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &members
                           json::parse(std::string(event.data(), event.size()));
                         return QString::fromStdString(msg.content.name);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.name event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.name event: {}", e.what());
                 }
         }
 
@@ -1215,7 +1216,7 @@ Cache::getInviteRoomName(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &members
 
                         return QString::fromStdString(tmp.name);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse member info: {}", e.what());
+                        nhlog::db()->warn("failed to parse member info: {}", e.what());
                 }
         }
 
@@ -1240,7 +1241,7 @@ Cache::getInviteRoomAvatarUrl(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &me
                           json::parse(std::string(event.data(), event.size()));
                         return QString::fromStdString(msg.content.url);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.avatar event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.avatar event: {}", e.what());
                 }
         }
 
@@ -1257,7 +1258,7 @@ Cache::getInviteRoomAvatarUrl(lmdb::txn &txn, lmdb::dbi &statesdb, lmdb::dbi &me
 
                         return QString::fromStdString(tmp.avatar_url);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse member info: {}", e.what());
+                        nhlog::db()->warn("failed to parse member info: {}", e.what());
                 }
         }
 
@@ -1282,7 +1283,7 @@ Cache::getInviteRoomTopic(lmdb::txn &txn, lmdb::dbi &db)
                           json::parse(std::string(event.data(), event.size()));
                         return QString::fromStdString(msg.content.topic);
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.topic event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.topic event: {}", e.what());
                 }
         }
 
@@ -1318,9 +1319,9 @@ Cache::getRoomAvatar(const std::string &room_id)
                         return QImage();
                 }
         } catch (const json::exception &e) {
-                log::db()->warn("failed to parse room info: {}, {}",
-                                e.what(),
-                                std::string(response.data(), response.size()));
+                nhlog::db()->warn("failed to parse room info: {}, {}",
+                                  e.what(),
+                                  std::string(response.data(), response.size()));
         }
 
         if (!lmdb::dbi_get(txn, mediaDb_, lmdb::val(media_url), response)) {
@@ -1356,7 +1357,7 @@ void
 Cache::populateMembers()
 {
         auto rooms = joinedRooms();
-        log::db()->info("loading {} rooms", rooms.size());
+        nhlog::db()->info("loading {} rooms", rooms.size());
 
         auto txn = lmdb::txn::begin(env_);
 
@@ -1484,7 +1485,7 @@ Cache::getMembers(const std::string &room_id, std::size_t startIndex, std::size_
                                      QString::fromStdString(tmp.name),
                                      QImage::fromData(image(txn, tmp.avatar_url))});
                 } catch (const json::exception &e) {
-                        log::db()->warn("{}", e.what());
+                        nhlog::db()->warn("{}", e.what());
                 }
 
                 currentIndex += 1;
@@ -1555,7 +1556,8 @@ Cache::hasEnoughPowerLevel(const std::vector<mtx::events::EventType> &eventTypes
                                   std::min(min_event_level,
                                            (uint16_t)msg.content.state_level(to_string(ty)));
                 } catch (const json::exception &e) {
-                        log::db()->warn("failed to parse m.room.power_levels event: {}", e.what());
+                        nhlog::db()->warn("failed to parse m.room.power_levels event: {}",
+                                          e.what());
                 }
         }
 
diff --git a/src/ChatPage.cc b/src/ChatPage.cc
index c10d4aa2..cffb2a46 100644
--- a/src/ChatPage.cc
+++ b/src/ChatPage.cc
@@ -129,13 +129,13 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
         typingRefresher_->setInterval(TYPING_REFRESH_TIMEOUT);
 
         connect(this, &ChatPage::connectionLost, this, [this]() {
-                log::net()->info("connectivity lost");
+                nhlog::net()->info("connectivity lost");
                 isConnected_ = false;
                 http::v2::client()->shutdown();
                 text_input_->disableInput();
         });
         connect(this, &ChatPage::connectionRestored, this, [this]() {
-                log::net()->info("trying to re-connect");
+                nhlog::net()->info("trying to re-connect");
                 text_input_->enableInput();
                 isConnected_ = true;
 
@@ -165,19 +165,20 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
 
         connect(this, &ChatPage::loggedOut, this, &ChatPage::logout);
         connect(user_info_widget_, &UserInfoWidget::logout, this, [this]() {
-                http::v2::client()->logout([this](const mtx::responses::Logout &,
-                                                  mtx::http::RequestErr err) {
-                        if (err) {
-                                // TODO: handle special errors
-                                emit contentLoaded();
-                                log::net()->warn("failed to logout: {} - {}",
-                                                 mtx::errors::to_string(err->matrix_error.errcode),
-                                                 err->matrix_error.error);
-                                return;
-                        }
+                http::v2::client()->logout(
+                  [this](const mtx::responses::Logout &, mtx::http::RequestErr err) {
+                          if (err) {
+                                  // TODO: handle special errors
+                                  emit contentLoaded();
+                                  nhlog::net()->warn(
+                                    "failed to logout: {} - {}",
+                                    mtx::errors::to_string(err->matrix_error.errcode),
+                                    err->matrix_error.error);
+                                  return;
+                          }
 
-                        emit loggedOut();
-                });
+                          emit loggedOut();
+                  });
 
                 emit showOverlayProgressBar();
         });
@@ -252,8 +253,8 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                 http::v2::client()->stop_typing(
                   current_room_.toStdString(), [](mtx::http::RequestErr err) {
                           if (err) {
-                                  log::net()->warn("failed to stop typing notifications: {}",
-                                                   err->matrix_error.error);
+                                  nhlog::net()->warn("failed to stop typing notifications: {}",
+                                                     err->matrix_error.error);
                           }
                   });
         });
@@ -309,9 +310,9 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                                   if (err) {
                                           emit uploadFailed(
                                             tr("Failed to upload image. Please try again."));
-                                          log::net()->warn("failed to upload image: {} ({})",
-                                                           err->matrix_error.error,
-                                                           static_cast<int>(err->status_code));
+                                          nhlog::net()->warn("failed to upload image: {} ({})",
+                                                             err->matrix_error.error,
+                                                             static_cast<int>(err->status_code));
                                           return;
                                   }
 
@@ -352,9 +353,9 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                                   if (err) {
                                           emit uploadFailed(
                                             tr("Failed to upload file. Please try again."));
-                                          log::net()->warn("failed to upload file: {} ({})",
-                                                           err->matrix_error.error,
-                                                           static_cast<int>(err->status_code));
+                                          nhlog::net()->warn("failed to upload file: {} ({})",
+                                                             err->matrix_error.error,
+                                                             static_cast<int>(err->status_code));
                                           return;
                                   }
 
@@ -395,9 +396,9 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                                   if (err) {
                                           emit uploadFailed(
                                             tr("Failed to upload audio. Please try again."));
-                                          log::net()->warn("failed to upload audio: {} ({})",
-                                                           err->matrix_error.error,
-                                                           static_cast<int>(err->status_code));
+                                          nhlog::net()->warn("failed to upload audio: {} ({})",
+                                                             err->matrix_error.error,
+                                                             static_cast<int>(err->status_code));
                                           return;
                                   }
 
@@ -437,9 +438,9 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                                   if (err) {
                                           emit uploadFailed(
                                             tr("Failed to upload video. Please try again."));
-                                          log::net()->warn("failed to upload video: {} ({})",
-                                                           err->matrix_error.error,
-                                                           static_cast<int>(err->status_code));
+                                          nhlog::net()->warn("failed to upload video: {} ({})",
+                                                             err->matrix_error.error,
+                                                             static_cast<int>(err->status_code));
                                           return;
                                   }
 
@@ -569,7 +570,7 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                 try {
                         room_list_->cleanupInvites(cache::client()->invites());
                 } catch (const lmdb::error &e) {
-                        log::db()->error("failed to retrieve invites: {}", e.what());
+                        nhlog::db()->error("failed to retrieve invites: {}", e.what());
                 }
 
                 view_manager_->initialize(rooms);
@@ -593,7 +594,7 @@ ChatPage::ChatPage(QSharedPointer<UserSettings> userSettings, QWidget *parent)
                           [this](const mtx::responses::Notifications &res,
                                  mtx::http::RequestErr err) {
                                   if (err) {
-                                          log::net()->warn(
+                                          nhlog::net()->warn(
                                             "failed to retrieve notifications: {} ({})",
                                             err->matrix_error.error,
                                             static_cast<int>(err->status_code));
@@ -690,7 +691,7 @@ ChatPage::bootstrap(QString userid, QString homeserver, QString token)
         try {
                 http::v2::client()->set_user(parse<User>(userid.toStdString()));
         } catch (const std::invalid_argument &e) {
-                log::main()->critical("bootstrapped with invalid user_id: {}",
+                nhlog::ui()->critical("bootstrapped with invalid user_id: {}",
                                       userid.toStdString());
         }
 
@@ -709,7 +710,7 @@ ChatPage::bootstrap(QString userid, QString homeserver, QString token)
                 const bool isValid       = cache::client()->isFormatValid();
 
                 if (isInitialized && !isValid) {
-                        log::db()->warn("breaking changes in cache");
+                        nhlog::db()->warn("breaking changes in cache");
                         // TODO: Deleting session data but keep using the
                         //	 same device doesn't work.
                         cache::client()->deleteData();
@@ -721,23 +722,23 @@ ChatPage::bootstrap(QString userid, QString homeserver, QString token)
                         return;
                 }
         } catch (const lmdb::error &e) {
-                log::db()->critical("failure during boot: {}", e.what());
+                nhlog::db()->critical("failure during boot: {}", e.what());
                 cache::client()->deleteData();
-                log::net()->info("falling back to initial sync");
+                nhlog::net()->info("falling back to initial sync");
         }
 
         try {
                 // It's the first time syncing with this device
                 // There isn't a saved olm account to restore.
-                log::crypto()->info("creating new olm account");
+                nhlog::crypto()->info("creating new olm account");
                 olm::client()->create_new_account();
                 cache::client()->saveOlmAccount(olm::client()->save(STORAGE_SECRET_KEY));
         } catch (const lmdb::error &e) {
-                log::crypto()->critical("failed to save olm account {}", e.what());
+                nhlog::crypto()->critical("failed to save olm account {}", e.what());
                 emit dropToLoginPageCb(QString::fromStdString(e.what()));
                 return;
         } catch (const mtx::crypto::olm_exception &e) {
-                log::crypto()->critical("failed to create new olm account {}", e.what());
+                nhlog::crypto()->critical("failed to create new olm account {}", e.what());
                 emit dropToLoginPageCb(QString::fromStdString(e.what()));
                 return;
         }
@@ -771,7 +772,7 @@ void
 ChatPage::changeTopRoomInfo(const QString &room_id)
 {
         if (room_id.isEmpty()) {
-                log::main()->warn("cannot switch to empty room_id");
+                nhlog::ui()->warn("cannot switch to empty room_id");
                 return;
         }
 
@@ -795,7 +796,7 @@ ChatPage::changeTopRoomInfo(const QString &room_id)
                         top_bar_->updateRoomAvatar(img);
 
         } catch (const lmdb::error &e) {
-                log::main()->error("failed to change top bar room info: {}", e.what());
+                nhlog::ui()->error("failed to change top bar room info: {}", e.what());
         }
 
         current_room_ = room_id;
@@ -816,7 +817,7 @@ ChatPage::showUnreadMessageNotification(int count)
 void
 ChatPage::loadStateFromCache()
 {
-        log::db()->info("restoring state from cache");
+        nhlog::db()->info("restoring state from cache");
 
         getProfileInfo();
 
@@ -831,19 +832,19 @@ ChatPage::loadStateFromCache()
                         emit initializeEmptyViews(cache::client()->joinedRooms());
                         emit initializeRoomList(cache::client()->roomInfo());
                 } catch (const mtx::crypto::olm_exception &e) {
-                        log::crypto()->critical("failed to restore olm account: {}", e.what());
+                        nhlog::crypto()->critical("failed to restore olm account: {}", e.what());
                         emit dropToLoginPageCb(
                           tr("Failed to restore OLM account. Please login again."));
                         return;
                 } catch (const lmdb::error &e) {
-                        log::db()->critical("failed to restore cache: {}", e.what());
+                        nhlog::db()->critical("failed to restore cache: {}", e.what());
                         emit dropToLoginPageCb(
                           tr("Failed to restore save data. Please login again."));
                         return;
                 }
 
-                log::crypto()->info("ed25519   : {}", olm::client()->identity_keys().ed25519);
-                log::crypto()->info("curve25519: {}", olm::client()->identity_keys().curve25519);
+                nhlog::crypto()->info("ed25519   : {}", olm::client()->identity_keys().ed25519);
+                nhlog::crypto()->info("curve25519: {}", olm::client()->identity_keys().curve25519);
 
                 // Start receiving events.
                 emit trySyncCb();
@@ -890,7 +891,7 @@ ChatPage::removeRoom(const QString &room_id)
                 cache::client()->removeRoom(room_id);
                 cache::client()->removeInvite(room_id.toStdString());
         } catch (const lmdb::error &e) {
-                log::db()->critical("failure while removing room: {}", e.what());
+                nhlog::db()->critical("failure while removing room: {}", e.what());
                 // TODO: Notify the user.
         }
 
@@ -1009,7 +1010,7 @@ ChatPage::sendDesktopNotifications(const mtx::responses::Notifications &res)
                                   utils::event_body(item.event));
                         }
                 } catch (const lmdb::error &e) {
-                        log::db()->warn("error while sending desktop notification: {}", e.what());
+                        nhlog::db()->warn("error while sending desktop notification: {}", e.what());
                 }
         }
 }
@@ -1017,11 +1018,11 @@ ChatPage::sendDesktopNotifications(const mtx::responses::Notifications &res)
 void
 ChatPage::tryInitialSync()
 {
-        log::crypto()->info("ed25519   : {}", olm::client()->identity_keys().ed25519);
-        log::crypto()->info("curve25519: {}", olm::client()->identity_keys().curve25519);
+        nhlog::crypto()->info("ed25519   : {}", olm::client()->identity_keys().ed25519);
+        nhlog::crypto()->info("curve25519: {}", olm::client()->identity_keys().curve25519);
 
         // Upload one time keys for the device.
-        log::crypto()->info("generating one time keys");
+        nhlog::crypto()->info("generating one time keys");
         olm::client()->generate_one_time_keys(MAX_ONETIME_KEYS);
 
         http::v2::client()->upload_keys(
@@ -1029,9 +1030,9 @@ ChatPage::tryInitialSync()
           [this](const mtx::responses::UploadKeys &res, mtx::http::RequestErr err) {
                   if (err) {
                           const int status_code = static_cast<int>(err->status_code);
-                          log::crypto()->critical("failed to upload one time keys: {} {}",
-                                                  err->matrix_error.error,
-                                                  status_code);
+                          nhlog::crypto()->critical("failed to upload one time keys: {} {}",
+                                                    err->matrix_error.error,
+                                                    status_code);
                           // TODO We should have a timeout instead of keeping hammering the server.
                           emit tryInitialSyncCb();
                           return;
@@ -1039,10 +1040,10 @@ ChatPage::tryInitialSync()
 
                   olm::client()->mark_keys_as_published();
                   for (const auto &entry : res.one_time_key_counts)
-                          log::net()->info(
+                          nhlog::net()->info(
                             "uploaded {} {} one-time keys", entry.second, entry.first);
 
-                  log::net()->info("trying initial sync");
+                  nhlog::net()->info("trying initial sync");
 
                   mtx::http::SyncOpts opts;
                   opts.timeout = 0;
@@ -1065,7 +1066,7 @@ ChatPage::trySync()
         try {
                 opts.since = cache::client()->nextBatchToken();
         } catch (const lmdb::error &e) {
-                log::db()->error("failed to retrieve next batch token: {}", e.what());
+                nhlog::db()->error("failed to retrieve next batch token: {}", e.what());
                 return;
         }
 
@@ -1077,7 +1078,7 @@ ChatPage::trySync()
                           const auto err_code   = mtx::errors::to_string(err->matrix_error.errcode);
                           const int status_code = static_cast<int>(err->status_code);
 
-                          log::net()->error("sync error: {} {}", status_code, err_code);
+                          nhlog::net()->error("sync error: {} {}", status_code, err_code);
 
                           if (status_code <= 0 || status_code >= 600) {
                                   if (!http::v2::is_logged_in())
@@ -1109,7 +1110,7 @@ ChatPage::trySync()
                           }
                   }
 
-                  log::net()->debug("sync completed: {}", res.next_batch);
+                  nhlog::net()->debug("sync completed: {}", res.next_batch);
 
                   // Ensure that we have enough one-time keys available.
                   ensureOneTimeKeyCount(res.device_one_time_keys_count);
@@ -1126,7 +1127,7 @@ ChatPage::trySync()
                           emit syncTopBar(updates);
                           emit syncRoomlist(updates);
                   } catch (const lmdb::error &e) {
-                          log::db()->error("saving sync response: {}", e.what());
+                          nhlog::db()->error("saving sync response: {}", e.what());
                   }
 
                   emit trySyncCb();
@@ -1201,8 +1202,8 @@ ChatPage::sendTypingNotifications()
         http::v2::client()->start_typing(
           current_room_.toStdString(), 10'000, [](mtx::http::RequestErr err) {
                   if (err) {
-                          log::net()->warn("failed to send typing notification: {}",
-                                           err->matrix_error.error);
+                          nhlog::net()->warn("failed to send typing notification: {}",
+                                             err->matrix_error.error);
                   }
           });
 }
@@ -1216,7 +1217,7 @@ ChatPage::initialSyncHandler(const mtx::responses::Sync &res, mtx::http::Request
                 const auto err_code   = mtx::errors::to_string(err->matrix_error.errcode);
                 const int status_code = static_cast<int>(err->status_code);
 
-                log::net()->error("sync error: {} {}", status_code, err_code);
+                nhlog::net()->error("sync error: {} {}", status_code, err_code);
 
                 switch (status_code) {
                 case 502:
@@ -1232,7 +1233,7 @@ ChatPage::initialSyncHandler(const mtx::responses::Sync &res, mtx::http::Request
                 }
         }
 
-        log::net()->info("initial sync completed");
+        nhlog::net()->info("initial sync completed");
 
         try {
                 cache::client()->saveState(res);
@@ -1242,7 +1243,7 @@ ChatPage::initialSyncHandler(const mtx::responses::Sync &res, mtx::http::Request
                 emit initializeViews(std::move(res.rooms));
                 emit initializeRoomList(cache::client()->roomInfo());
         } catch (const lmdb::error &e) {
-                log::db()->error("{}", e.what());
+                nhlog::db()->error("{}", e.what());
                 emit tryInitialSyncCb();
                 return;
         }
@@ -1258,14 +1259,14 @@ ChatPage::ensureOneTimeKeyCount(const std::map<std::string, uint16_t> &counts)
                 if (entry.second < MAX_ONETIME_KEYS) {
                         const int nkeys = MAX_ONETIME_KEYS - entry.second;
 
-                        log::crypto()->info("uploading {} {} keys", nkeys, entry.first);
+                        nhlog::crypto()->info("uploading {} {} keys", nkeys, entry.first);
                         olm::client()->generate_one_time_keys(nkeys);
 
                         http::v2::client()->upload_keys(
                           olm::client()->create_upload_keys_request(),
                           [](const mtx::responses::UploadKeys &, mtx::http::RequestErr err) {
                                   if (err) {
-                                          log::crypto()->warn(
+                                          nhlog::crypto()->warn(
                                             "failed to update one-time keys: {} {}",
                                             err->matrix_error.error,
                                             static_cast<int>(err->status_code));
@@ -1287,7 +1288,7 @@ ChatPage::getProfileInfo()
         http::v2::client()->get_profile(
           userid, [this](const mtx::responses::Profile &res, mtx::http::RequestErr err) {
                   if (err) {
-                          log::net()->warn("failed to retrieve own profile info");
+                          nhlog::net()->warn("failed to retrieve own profile info");
                           return;
                   }
 
@@ -1311,7 +1312,7 @@ ChatPage::getProfileInfo()
                                 const std::string &,
                                 mtx::http::RequestErr err) {
                             if (err) {
-                                    log::net()->warn(
+                                    nhlog::net()->warn(
                                       "failed to download user avatar: {} - {}",
                                       mtx::errors::to_string(err->matrix_error.errcode),
                                       err->matrix_error.error);
diff --git a/src/CommunitiesList.cc b/src/CommunitiesList.cc
index 49affcb7..df4d6361 100644
--- a/src/CommunitiesList.cc
+++ b/src/CommunitiesList.cc
@@ -136,7 +136,7 @@ CommunitiesList::fetchCommunityAvatar(const QString &id, const QString &avatarUr
         http::v2::client()->get_thumbnail(
           opts, [this, opts, id](const std::string &res, mtx::http::RequestErr err) {
                   if (err) {
-                          log::net()->warn("failed to download avatar: {} - ({} {})",
+                          nhlog::net()->warn("failed to download avatar: {} - ({} {})",
                                            opts.mxc_url,
                                            mtx::errors::to_string(err->matrix_error.errcode),
                                            err->matrix_error.error);
diff --git a/src/Logging.cpp b/src/Logging.cpp
index 77e61e09..bccbe389 100644
--- a/src/Logging.cpp
+++ b/src/Logging.cpp
@@ -7,13 +7,13 @@ namespace {
 std::shared_ptr<spdlog::logger> db_logger     = nullptr;
 std::shared_ptr<spdlog::logger> net_logger    = nullptr;
 std::shared_ptr<spdlog::logger> crypto_logger = nullptr;
-std::shared_ptr<spdlog::logger> main_logger   = nullptr;
+std::shared_ptr<spdlog::logger> ui_logger     = nullptr;
 
 constexpr auto MAX_FILE_SIZE = 1024 * 1024 * 6;
 constexpr auto MAX_LOG_FILES = 3;
 }
 
-namespace log {
+namespace nhlog {
 void
 init(const std::string &file_path)
 {
@@ -26,17 +26,17 @@ init(const std::string &file_path)
         sinks.push_back(file_sink);
         sinks.push_back(console_sink);
 
-        net_logger  = std::make_shared<spdlog::logger>("net", std::begin(sinks), std::end(sinks));
-        main_logger = std::make_shared<spdlog::logger>("main", std::begin(sinks), std::end(sinks));
-        db_logger   = std::make_shared<spdlog::logger>("db", std::begin(sinks), std::end(sinks));
+        net_logger = std::make_shared<spdlog::logger>("net", std::begin(sinks), std::end(sinks));
+        ui_logger  = std::make_shared<spdlog::logger>("ui", std::begin(sinks), std::end(sinks));
+        db_logger  = std::make_shared<spdlog::logger>("db", std::begin(sinks), std::end(sinks));
         crypto_logger =
           std::make_shared<spdlog::logger>("crypto", std::begin(sinks), std::end(sinks));
 }
 
 std::shared_ptr<spdlog::logger>
-main()
+ui()
 {
-        return main_logger;
+        return ui_logger;
 }
 
 std::shared_ptr<spdlog::logger>
diff --git a/src/MainWindow.cc b/src/MainWindow.cc
index cca51f03..088bb5c0 100644
--- a/src/MainWindow.cc
+++ b/src/MainWindow.cc
@@ -155,7 +155,7 @@ MainWindow::MainWindow(QWidget *parent)
                         using namespace mtx::identifiers;
                         http::v2::client()->set_user(parse<User>(user_id.toStdString()));
                 } catch (const std::invalid_argument &e) {
-                        log::main()->critical("bootstrapped with invalid user_id: {}",
+                        nhlog::ui()->critical("bootstrapped with invalid user_id: {}",
                                               user_id.toStdString());
                 }
 
diff --git a/src/Olm.cpp b/src/Olm.cpp
index 6e130277..f39554f0 100644
--- a/src/Olm.cpp
+++ b/src/Olm.cpp
@@ -23,17 +23,17 @@ handle_to_device_messages(const std::vector<nlohmann::json> &msgs)
         if (msgs.empty())
                 return;
 
-        log::crypto()->info("received {} to_device messages", msgs.size());
+        nhlog::crypto()->info("received {} to_device messages", msgs.size());
 
         for (const auto &msg : msgs) {
                 try {
                         OlmMessage olm_msg = msg;
                         handle_olm_message(std::move(olm_msg));
                 } catch (const nlohmann::json::exception &e) {
-                        log::crypto()->warn(
+                        nhlog::crypto()->warn(
                           "parsing error for olm message: {} {}", e.what(), msg.dump(2));
                 } catch (const std::invalid_argument &e) {
-                        log::crypto()->warn(
+                        nhlog::crypto()->warn(
                           "validation error for olm message: {} {}", e.what(), msg.dump(2));
                 }
         }
@@ -42,8 +42,8 @@ handle_to_device_messages(const std::vector<nlohmann::json> &msgs)
 void
 handle_olm_message(const OlmMessage &msg)
 {
-        log::crypto()->info("sender    : {}", msg.sender);
-        log::crypto()->info("sender_key: {}", msg.sender_key);
+        nhlog::crypto()->info("sender    : {}", msg.sender);
+        nhlog::crypto()->info("sender_key: {}", msg.sender_key);
 
         const auto my_key = olm::client()->identity_keys().curve25519;
 
@@ -53,7 +53,7 @@ handle_olm_message(const OlmMessage &msg)
                         continue;
 
                 const auto type = cipher.second.type;
-                log::crypto()->info("type: {}", type == 0 ? "OLM_PRE_KEY" : "OLM_MESSAGE");
+                nhlog::crypto()->info("type: {}", type == 0 ? "OLM_PRE_KEY" : "OLM_MESSAGE");
 
                 if (type == OLM_MESSAGE_TYPE_PRE_KEY)
                         handle_pre_key_olm_message(msg.sender, msg.sender_key, cipher.second);
@@ -67,19 +67,20 @@ handle_pre_key_olm_message(const std::string &sender,
                            const std::string &sender_key,
                            const OlmCipherContent &content)
 {
-        log::crypto()->info("opening olm session with {}", sender);
+        nhlog::crypto()->info("opening olm session with {}", sender);
 
         OlmSessionPtr inbound_session = nullptr;
         try {
                 inbound_session = olm::client()->create_inbound_session(content.body);
         } catch (const olm_exception &e) {
-                log::crypto()->critical(
+                nhlog::crypto()->critical(
                   "failed to create inbound session with {}: {}", sender, e.what());
                 return;
         }
 
         if (!matches_inbound_session_from(inbound_session.get(), sender_key, content.body)) {
-                log::crypto()->warn("inbound olm session doesn't match sender's key ({})", sender);
+                nhlog::crypto()->warn("inbound olm session doesn't match sender's key ({})",
+                                      sender);
                 return;
         }
 
@@ -88,13 +89,13 @@ handle_pre_key_olm_message(const std::string &sender,
                 output = olm::client()->decrypt_message(
                   inbound_session.get(), OLM_MESSAGE_TYPE_PRE_KEY, content.body);
         } catch (const olm_exception &e) {
-                log::crypto()->critical(
+                nhlog::crypto()->critical(
                   "failed to decrypt olm message {}: {}", content.body, e.what());
                 return;
         }
 
         auto plaintext = json::parse(std::string((char *)output.data(), output.size()));
-        log::crypto()->info("decrypted message: \n {}", plaintext.dump(2));
+        nhlog::crypto()->info("decrypted message: \n {}", plaintext.dump(2));
 
         std::string room_id, session_id, session_key;
         try {
@@ -102,7 +103,7 @@ handle_pre_key_olm_message(const std::string &sender,
                 session_id  = plaintext.at("content").at("session_id");
                 session_key = plaintext.at("content").at("session_key");
         } catch (const nlohmann::json::exception &e) {
-                log::crypto()->critical(
+                nhlog::crypto()->critical(
                   "failed to parse plaintext olm message: {} {}", e.what(), plaintext.dump(2));
                 return;
         }
@@ -118,14 +119,15 @@ handle_pre_key_olm_message(const std::string &sender,
                 try {
                         cache::client()->saveInboundMegolmSession(index, std::move(megolm_session));
                 } catch (const lmdb::error &e) {
-                        log::crypto()->critical("failed to save inbound megolm session: {}",
-                                                e.what());
+                        nhlog::crypto()->critical("failed to save inbound megolm session: {}",
+                                                  e.what());
                         return;
                 }
 
-                log::crypto()->info("established inbound megolm session ({}, {})", room_id, sender);
+                nhlog::crypto()->info(
+                  "established inbound megolm session ({}, {})", room_id, sender);
         } else {
-                log::crypto()->warn(
+                nhlog::crypto()->warn(
                   "inbound megolm session already exists ({}, {})", room_id, sender);
         }
 }
@@ -133,7 +135,7 @@ handle_pre_key_olm_message(const std::string &sender,
 void
 handle_olm_normal_message(const std::string &, const std::string &, const OlmCipherContent &)
 {
-        log::crypto()->warn("olm(1) not implemeted yet");
+        nhlog::crypto()->warn("olm(1) not implemeted yet");
 }
 
 mtx::events::msg::Encrypted
@@ -155,7 +157,7 @@ encrypt_group_message(const std::string &room_id,
         data.device_id  = device_id;
 
         auto message_index = olm_outbound_group_session_message_index(res.session);
-        log::crypto()->info("next message_index {}", message_index);
+        nhlog::crypto()->info("next message_index {}", message_index);
 
         // We need to re-pickle the session after we send a message to save the new message_index.
         cache::client()->updateOutboundMegolmSession(room_id, message_index);
diff --git a/src/RegisterPage.cc b/src/RegisterPage.cc
index a5960b83..f56cd663 100644
--- a/src/RegisterPage.cc
+++ b/src/RegisterPage.cc
@@ -153,7 +153,7 @@ RegisterPage::RegisterPage(QWidget *parent)
                                       [this](const mtx::responses::Register &res,
                                              mtx::http::RequestErr err) {
                                               if (err) {
-                                                      log::net()->warn(
+                                                      nhlog::net()->warn(
                                                         "failed to retrieve registration flows: {}",
                                                         err->matrix_error.error);
                                                       emit errorOccurred();
@@ -231,7 +231,7 @@ RegisterPage::onRegisterButtonClicked()
                                       const mtx::responses::RegistrationFlows &res,
                                       mtx::http::RequestErr err) {
                                             if (res.session.empty() && err) {
-                                                    log::net()->warn(
+                                                    nhlog::net()->warn(
                                                       "failed to retrieve registration flows: ({}) "
                                                       "{}",
                                                       static_cast<int>(err->status_code),
@@ -247,7 +247,7 @@ RegisterPage::onRegisterButtonClicked()
                                   return;
                           }
 
-                          log::net()->warn("failed to register: status_code ({})",
+                          nhlog::net()->warn("failed to register: status_code ({})",
                                            static_cast<int>(err->status_code));
 
                           emit registerErrorCb(QString::fromStdString(err->matrix_error.error));
diff --git a/src/RoomList.cc b/src/RoomList.cc
index 4891f746..b5bcdad6 100644
--- a/src/RoomList.cc
+++ b/src/RoomList.cc
@@ -95,7 +95,7 @@ RoomList::updateAvatar(const QString &room_id, const QString &url)
                 http::v2::client()->get_thumbnail(
                   opts, [room_id, opts, this](const std::string &res, mtx::http::RequestErr err) {
                           if (err) {
-                                  log::net()->warn(
+                                  nhlog::net()->warn(
                                     "failed to download room avatar: {} {} {}",
                                     opts.mxc_url,
                                     mtx::errors::to_string(err->matrix_error.errcode),
@@ -141,7 +141,7 @@ void
 RoomList::updateUnreadMessageCount(const QString &roomid, int count)
 {
         if (!roomExists(roomid)) {
-                log::main()->warn("updateUnreadMessageCount: unknown room_id {}",
+                nhlog::ui()->warn("updateUnreadMessageCount: unknown room_id {}",
                                   roomid.toStdString());
                 return;
         }
@@ -167,7 +167,7 @@ RoomList::calculateUnreadMessageCount()
 void
 RoomList::initialize(const QMap<QString, RoomInfo> &info)
 {
-        log::main()->info("initialize room list");
+        nhlog::ui()->info("initialize room list");
 
         rooms_.clear();
 
@@ -220,7 +220,7 @@ RoomList::highlightSelectedRoom(const QString &room_id)
         emit roomChanged(room_id);
 
         if (!roomExists(room_id)) {
-                log::main()->warn("roomlist: clicked unknown room_id");
+                nhlog::ui()->warn("roomlist: clicked unknown room_id");
                 return;
         }
 
@@ -243,7 +243,7 @@ void
 RoomList::updateRoomAvatar(const QString &roomid, const QPixmap &img)
 {
         if (!roomExists(roomid)) {
-                log::main()->warn("avatar update on non-existent room_id: {}",
+                nhlog::ui()->warn("avatar update on non-existent room_id: {}",
                                   roomid.toStdString());
                 return;
         }
@@ -258,7 +258,7 @@ void
 RoomList::updateRoomDescription(const QString &roomid, const DescInfo &info)
 {
         if (!roomExists(roomid)) {
-                log::main()->warn("description update on non-existent room_id: {}, {}",
+                nhlog::ui()->warn("description update on non-existent room_id: {}, {}",
                                   roomid.toStdString(),
                                   info.body.toStdString());
                 return;
diff --git a/src/dialogs/PreviewUploadOverlay.cc b/src/dialogs/PreviewUploadOverlay.cc
index 3c44e911..db1e31f2 100644
--- a/src/dialogs/PreviewUploadOverlay.cc
+++ b/src/dialogs/PreviewUploadOverlay.cc
@@ -17,7 +17,6 @@
 
 #include <QApplication>
 #include <QBuffer>
-#include <QDebug>
 #include <QFile>
 #include <QFileInfo>
 #include <QHBoxLayout>
@@ -25,6 +24,7 @@
 #include <QVBoxLayout>
 
 #include "Config.h"
+#include "Logging.hpp"
 #include "Utils.h"
 
 #include "dialogs/PreviewUploadOverlay.h"
@@ -142,8 +142,9 @@ PreviewUploadOverlay::setPreview(const QString &path)
         QFile file{path};
 
         if (!file.open(QIODevice::ReadOnly)) {
-                qWarning() << "Failed to open file from:" << path;
-                qWarning() << "Reason:" << file.errorString();
+                nhlog::ui()->warn("Failed to open file ({}): {}",
+                                  path.toStdString(),
+                                  file.errorString().toStdString());
                 close();
                 return;
         }
@@ -152,7 +153,7 @@ PreviewUploadOverlay::setPreview(const QString &path)
         auto mime = db.mimeTypeForFileNameAndData(path, &file);
 
         if ((data_ = file.readAll()).isEmpty()) {
-                qWarning() << "Failed to read media:" << file.errorString();
+                nhlog::ui()->warn("Failed to read media: {}", file.errorString().toStdString());
                 close();
                 return;
         }
diff --git a/src/dialogs/RoomSettings.cpp b/src/dialogs/RoomSettings.cpp
index a091c8bc..74d08478 100644
--- a/src/dialogs/RoomSettings.cpp
+++ b/src/dialogs/RoomSettings.cpp
@@ -338,7 +338,7 @@ RoomSettings::setupEditButton()
                 hasEditRights_ = cache::client()->hasEnoughPowerLevel(
                   {EventType::RoomName, EventType::RoomTopic}, room_id_.toStdString(), userId);
         } catch (const lmdb::error &e) {
-                qWarning() << "lmdb error" << e.what();
+                nhlog::db()->warn("lmdb error: {}", e.what());
         }
 
         constexpr int buttonSize = 36;
@@ -379,7 +379,8 @@ RoomSettings::retrieveRoomInfo()
                 info_           = cache::client()->singleRoomInfo(room_id_.toStdString());
                 setAvatar(QImage::fromData(cache::client()->image(info_.avatar_url)));
         } catch (const lmdb::error &e) {
-                qWarning() << "failed to retrieve room info from cache" << room_id_;
+                nhlog::db()->warn("failed to retrieve room info from cache: {}",
+                                  room_id_.toStdString());
         }
 }
 
@@ -415,17 +416,17 @@ RoomSettings::enableEncryption()
           room_id, [room_id, this](const mtx::responses::EventId &, mtx::http::RequestErr err) {
                   if (err) {
                           int status_code = static_cast<int>(err->status_code);
-                          log::net()->warn("failed to enable encryption in room ({}): {} {}",
-                                           room_id,
-                                           err->matrix_error.error,
-                                           status_code);
+                          nhlog::net()->warn("failed to enable encryption in room ({}): {} {}",
+                                             room_id,
+                                             err->matrix_error.error,
+                                             status_code);
                           emit enableEncryptionError(
                             tr("Failed to enable encryption: %1")
                               .arg(QString::fromStdString(err->matrix_error.error)));
                           return;
                   }
 
-                  log::net()->info("enabled encryption on room ({})", room_id);
+                  nhlog::net()->info("enabled encryption on room ({})", room_id);
           });
 }
 
diff --git a/src/main.cc b/src/main.cc
index 0a127962..24524c2c 100644
--- a/src/main.cc
+++ b/src/main.cc
@@ -127,9 +127,9 @@ main(int argc, char *argv[])
         createCacheDirectory();
 
         try {
-                log::init(QString("%1/nheko.log")
-                            .arg(QStandardPaths::writableLocation(QStandardPaths::CacheLocation))
-                            .toStdString());
+                nhlog::init(QString("%1/nheko.log")
+                              .arg(QStandardPaths::writableLocation(QStandardPaths::CacheLocation))
+                              .toStdString());
         } catch (const spdlog::spdlog_ex &ex) {
                 std::cout << "Log initialization failed: " << ex.what() << std::endl;
                 std::exit(1);
@@ -171,7 +171,7 @@ main(int argc, char *argv[])
                 }
         });
 
-        log::main()->info("starting nheko {}", nheko::version);
+        nhlog::ui()->info("starting nheko {}", nheko::version);
 
         return app.exec();
 }
diff --git a/src/timeline/TimelineItem.cc b/src/timeline/TimelineItem.cc
index 83a0aaed..3505d347 100644
--- a/src/timeline/TimelineItem.cc
+++ b/src/timeline/TimelineItem.cc
@@ -23,6 +23,7 @@
 #include "Avatar.h"
 #include "ChatPage.h"
 #include "Config.h"
+#include "Logging.hpp"
 
 #include "timeline/TimelineItem.h"
 #include "timeline/widgets/AudioItem.h"
@@ -653,3 +654,19 @@ TimelineItem::addAvatar()
         AvatarProvider::resolve(
           room_id_, userid, this, [this](const QImage &img) { setUserAvatar(img); });
 }
+
+void
+TimelineItem::sendReadReceipt() const
+{
+        if (!event_id_.isEmpty())
+                http::v2::client()->read_event(room_id_.toStdString(),
+                                               event_id_.toStdString(),
+                                               [this](mtx::http::RequestErr err) {
+                                                       if (err) {
+                                                               nhlog::net()->warn(
+                                                                 "failed to read_event ({}, {})",
+                                                                 room_id_.toStdString(),
+                                                                 event_id_.toStdString());
+                                                       }
+                                               });
+}
diff --git a/src/timeline/TimelineView.cc b/src/timeline/TimelineView.cc
index 9276a7bc..8f3ad1a7 100644
--- a/src/timeline/TimelineView.cc
+++ b/src/timeline/TimelineView.cc
@@ -301,8 +301,8 @@ TimelineView::parseMessageEvent(const mtx::events::collections::TimelineEvents &
                 try {
                         cache::client()->setEncryptedRoom(room_id_.toStdString());
                 } catch (const lmdb::error &e) {
-                        log::db()->critical("failed to save room {} as encrypted",
-                                            room_id_.toStdString());
+                        nhlog::db()->critical("failed to save room {} as encrypted",
+                                              room_id_.toStdString());
                 }
         }
 
@@ -324,10 +324,10 @@ TimelineView::parseEncryptedEvent(const mtx::events::EncryptedEvent<mtx::events:
         dummy.content.body     = "-- Encrypted Event (No keys found for decryption) --";
 
         if (!cache::client()->inboundMegolmSessionExists(index)) {
-                log::crypto()->info("Could not find inbound megolm session ({}, {}, {})",
-                                    index.room_id,
-                                    index.session_id,
-                                    e.sender);
+                nhlog::crypto()->info("Could not find inbound megolm session ({}, {}, {})",
+                                      index.room_id,
+                                      index.session_id,
+                                      e.sender);
                 // TODO: request megolm session_id & session_key from the sender.
                 return dummy;
         }
@@ -344,7 +344,7 @@ TimelineView::parseEncryptedEvent(const mtx::events::EncryptedEvent<mtx::events:
         body["origin_server_ts"] = e.origin_server_ts;
         body["unsigned"]         = e.unsigned_data;
 
-        log::crypto()->info("decrypted data: \n {}", body.dump(2));
+        nhlog::crypto()->info("decrypted data: \n {}", body.dump(2));
 
         json event_array = json::array();
         event_array.push_back(body);
@@ -523,10 +523,10 @@ TimelineView::getMessages()
         http::v2::client()->messages(
           opts, [this, opts](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
                   if (err) {
-                          log::net()->error("failed to call /messages ({}): {} - {}",
-                                            opts.room_id,
-                                            mtx::errors::to_string(err->matrix_error.errcode),
-                                            err->matrix_error.error);
+                          nhlog::net()->error("failed to call /messages ({}): {} - {}",
+                                              opts.room_id,
+                                              mtx::errors::to_string(err->matrix_error.errcode),
+                                              err->matrix_error.error);
                           return;
                   }
 
@@ -607,7 +607,7 @@ TimelineView::addTimelineItem(TimelineItem *item, TimelineDirection direction)
 void
 TimelineView::updatePendingMessage(const std::string &txn_id, const QString &event_id)
 {
-        log::main()->info("[{}] message was received by the server", txn_id);
+        nhlog::ui()->info("[{}] message was received by the server", txn_id);
         if (!pending_msgs_.isEmpty() &&
             pending_msgs_.head().txn_id == txn_id) { // We haven't received it yet
                 auto msg     = pending_msgs_.dequeue();
@@ -642,7 +642,7 @@ TimelineView::addUserMessage(mtx::events::MessageType ty, const QString &body)
         try {
                 message.is_encrypted = cache::client()->isRoomEncrypted(room_id_.toStdString());
         } catch (const lmdb::error &e) {
-                log::db()->critical("failed to check encryption status of room {}", e.what());
+                nhlog::db()->critical("failed to check encryption status of room {}", e.what());
                 view_item->deleteLater();
 
                 // TODO: Send a notification to the user.
@@ -676,11 +676,11 @@ TimelineView::sendNextPendingMessage()
 
         PendingMessage &m = pending_msgs_.head();
 
-        log::main()->info("[{}] sending next queued message", m.txn_id);
+        nhlog::ui()->info("[{}] sending next queued message", m.txn_id);
 
         if (m.is_encrypted) {
                 prepareEncryptedMessage(std::move(m));
-                log::main()->info("[{}] sending encrypted event", m.txn_id);
+                nhlog::ui()->info("[{}] sending encrypted event", m.txn_id);
                 return;
         }
 
@@ -763,7 +763,7 @@ TimelineView::sendNextPendingMessage()
                 break;
         }
         default:
-                log::main()->warn("cannot send unknown message type: {}", m.body.toStdString());
+                nhlog::ui()->warn("cannot send unknown message type: {}", m.body.toStdString());
                 break;
         }
 }
@@ -777,7 +777,7 @@ TimelineView::notifyForLastEvent()
         if (lastTimelineItem)
                 emit updateLastTimelineMessage(room_id_, lastTimelineItem->descriptionMessage());
         else
-                log::main()->warn("cast to TimelineView failed: {}", room_id_.toStdString());
+                nhlog::ui()->warn("cast to TimelineView failed: {}", room_id_.toStdString());
 }
 
 void
@@ -817,7 +817,7 @@ TimelineView::removePendingMessage(const std::string &txn_id)
                         if (pending_sent_msgs_.isEmpty())
                                 sendNextPendingMessage();
 
-                        log::main()->info("[{}] removed message with sync", txn_id);
+                        nhlog::ui()->info("[{}] removed message with sync", txn_id);
                 }
         }
         for (auto it = pending_msgs_.begin(); it != pending_msgs_.end(); ++it) {
@@ -825,7 +825,7 @@ TimelineView::removePendingMessage(const std::string &txn_id)
                         int index = std::distance(pending_msgs_.begin(), it);
                         pending_msgs_.removeAt(index);
 
-                        log::main()->info("[{}] removed message before sync", txn_id);
+                        nhlog::ui()->info("[{}] removed message before sync", txn_id);
                         return;
                 }
         }
@@ -861,7 +861,7 @@ TimelineView::readLastEvent() const
                                                eventId.toStdString(),
                                                [this, eventId](mtx::http::RequestErr err) {
                                                        if (err) {
-                                                               log::net()->warn(
+                                                               nhlog::net()->warn(
                                                                  "failed to read event ({}, {})",
                                                                  room_id_.toStdString(),
                                                                  eventId.toStdString());
@@ -936,7 +936,7 @@ void
 TimelineView::removeEvent(const QString &event_id)
 {
         if (!eventIds_.contains(event_id)) {
-                log::main()->warn("cannot remove widget with unknown event_id: {}",
+                nhlog::ui()->warn("cannot remove widget with unknown event_id: {}",
                                   event_id.toStdString());
                 return;
         }
@@ -1062,10 +1062,10 @@ TimelineView::sendRoomMessageHandler(const std::string &txn_id,
 {
         if (err) {
                 const int status_code = static_cast<int>(err->status_code);
-                log::net()->warn("[{}] failed to send message: {} {}",
-                                 txn_id,
-                                 err->matrix_error.error,
-                                 status_code);
+                nhlog::net()->warn("[{}] failed to send message: {} {}",
+                                   txn_id,
+                                   err->matrix_error.error,
+                                   status_code);
                 emit messageFailed(txn_id);
                 return;
         }
@@ -1200,7 +1200,7 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
                         return;
                 }
 
-                log::main()->info("creating new outbound megolm session");
+                nhlog::ui()->info("creating new outbound megolm session");
 
                 // Create a new outbound megolm session.
                 auto outbound_session  = olm::client()->init_outbound_group_session();
@@ -1223,7 +1223,7 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
                   room_id, session_data, std::move(outbound_session));
 
                 const auto members = cache::client()->roomMembers(room_id);
-                log::main()->info("retrieved {} members for {}", members.size(), room_id);
+                nhlog::ui()->info("retrieved {} members for {}", members.size(), room_id);
 
                 auto keeper = std::make_shared<StateKeeper>(
                   [megolm_payload, room_id, doc, txn_id = msg.txn_id, this]() {
@@ -1243,8 +1243,8 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
                                                 std::placeholders::_2));
 
                           } catch (const lmdb::error &e) {
-                                  log::db()->critical("failed to save megolm outbound session: {}",
-                                                      e.what());
+                                  nhlog::db()->critical(
+                                    "failed to save megolm outbound session: {}", e.what());
                           }
                   });
 
@@ -1257,16 +1257,16 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
                   [keeper = std::move(keeper), megolm_payload](const mtx::responses::QueryKeys &res,
                                                                mtx::http::RequestErr err) {
                           if (err) {
-                                  log::net()->warn("failed to query device keys: {} {}",
-                                                   err->matrix_error.error,
-                                                   static_cast<int>(err->status_code));
+                                  nhlog::net()->warn("failed to query device keys: {} {}",
+                                                     err->matrix_error.error,
+                                                     static_cast<int>(err->status_code));
                                   // TODO: Mark the event as failed. Communicate with the UI.
                                   return;
                           }
 
                           for (const auto &entry : res.device_keys) {
                                   for (const auto &dev : entry.second) {
-                                          log::net()->info("received device {}", dev.first);
+                                          nhlog::net()->info("received device {}", dev.first);
 
                                           const auto device_keys = dev.second.keys;
                                           const auto curveKey    = "curve25519:" + dev.first;
@@ -1274,7 +1274,7 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
 
                                           if ((device_keys.find(curveKey) == device_keys.end()) ||
                                               (device_keys.find(edKey) == device_keys.end())) {
-                                                  log::net()->info(
+                                                  nhlog::net()->info(
                                                     "ignoring malformed keys for device {}",
                                                     dev.first);
                                                   continue;
@@ -1286,7 +1286,7 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
 
                                           // Validate signatures
                                           for (const auto &algo : dev.second.keys) {
-                                                  log::net()->info(
+                                                  nhlog::net()->info(
                                                     "dev keys {} {}", algo.first, algo.second);
                                           }
 
@@ -1308,22 +1308,22 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
                                               const mtx::responses::ClaimKeys &res,
                                               mtx::http::RequestErr err) {
                                                     if (err) {
-                                                            log::net()->warn(
+                                                            nhlog::net()->warn(
                                                               "claim keys error: {}",
                                                               err->matrix_error.error);
                                                             return;
                                                     }
 
-                                                    log::net()->info("claimed keys for {} - {}",
-                                                                     user_id,
-                                                                     device_id);
+                                                    nhlog::net()->info("claimed keys for {} - {}",
+                                                                       user_id,
+                                                                       device_id);
 
                                                     auto retrieved_devices =
                                                       res.one_time_keys.at(user_id);
                                                     for (const auto &rd : retrieved_devices) {
-                                                            log::net()->info("{} : \n {}",
-                                                                             rd.first,
-                                                                             rd.second.dump(2));
+                                                            nhlog::net()->info("{} : \n {}",
+                                                                               rd.first,
+                                                                               rd.second.dump(2));
 
                                                             // TODO: Verify signatures
                                                             auto otk = rd.second.begin()->at("key");
@@ -1351,7 +1351,7 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
                                                               body,
                                                               [keeper](mtx::http::RequestErr err) {
                                                                       if (err) {
-                                                                              log::net()->warn(
+                                                                              nhlog::net()->warn(
                                                                                 "failed to send "
                                                                                 "send_to_device "
                                                                                 "message: {}",
@@ -1366,7 +1366,7 @@ TimelineView::prepareEncryptedMessage(const PendingMessage &msg)
                   });
 
         } catch (const lmdb::error &e) {
-                log::db()->critical(
+                nhlog::db()->critical(
                   "failed to open outbound megolm session ({}): {}", room_id, e.what());
                 return;
         }
diff --git a/src/timeline/TimelineViewManager.cc b/src/timeline/TimelineViewManager.cc
index b6e7d50d..7ea1ee4a 100644
--- a/src/timeline/TimelineViewManager.cc
+++ b/src/timeline/TimelineViewManager.cc
@@ -18,10 +18,10 @@
 #include <random>
 
 #include <QApplication>
-#include <QDebug>
 #include <QFileInfo>
 #include <QSettings>
 
+#include "Logging.hpp"
 #include "timeline/TimelineView.h"
 #include "timeline/TimelineViewManager.h"
 #include "timeline/widgets/AudioItem.h"
@@ -76,7 +76,7 @@ TimelineViewManager::queueImageMessage(const QString &roomid,
                                        uint64_t size)
 {
         if (!timelineViewExists(roomid)) {
-                qDebug() << "Cannot send m.image message to a non-managed view";
+                nhlog::ui()->warn("Cannot send m.image message to a non-managed view");
                 return;
         }
 
@@ -93,7 +93,7 @@ TimelineViewManager::queueFileMessage(const QString &roomid,
                                       uint64_t size)
 {
         if (!timelineViewExists(roomid)) {
-                qDebug() << "Cannot send m.file message to a non-managed view";
+                nhlog::ui()->warn("cannot send m.file message to a non-managed view");
                 return;
         }
 
@@ -110,7 +110,7 @@ TimelineViewManager::queueAudioMessage(const QString &roomid,
                                        uint64_t size)
 {
         if (!timelineViewExists(roomid)) {
-                qDebug() << "Cannot send m.audio message to a non-managed view";
+                nhlog::ui()->warn("cannot send m.audio message to a non-managed view");
                 return;
         }
 
@@ -127,7 +127,7 @@ TimelineViewManager::queueVideoMessage(const QString &roomid,
                                        uint64_t size)
 {
         if (!timelineViewExists(roomid)) {
-                qDebug() << "Cannot send m.video message to a non-managed view";
+                nhlog::ui()->warn("cannot send m.video message to a non-managed view");
                 return;
         }
 
@@ -198,7 +198,8 @@ TimelineViewManager::sync(const mtx::responses::Rooms &rooms)
                 auto roomid = QString::fromStdString(room.first);
 
                 if (!timelineViewExists(roomid)) {
-                        qDebug() << "Ignoring event from unknown room" << roomid;
+                        nhlog::ui()->warn("ignoring event from unknown room: {}",
+                                          roomid.toStdString());
                         continue;
                 }
 
@@ -212,7 +213,8 @@ void
 TimelineViewManager::setHistoryView(const QString &room_id)
 {
         if (!timelineViewExists(room_id)) {
-                qDebug() << "Room ID from RoomList is not present in ViewManager" << room_id;
+                nhlog::ui()->warn("room from RoomList is not present in ViewManager: {}",
+                                  room_id.toStdString());
                 return;
         }
 
diff --git a/src/timeline/widgets/AudioItem.cc b/src/timeline/widgets/AudioItem.cc
index 1ad47747..7cbbed28 100644
--- a/src/timeline/widgets/AudioItem.cc
+++ b/src/timeline/widgets/AudioItem.cc
@@ -16,13 +16,13 @@
  */
 
 #include <QBrush>
-#include <QDebug>
 #include <QDesktopServices>
 #include <QFile>
 #include <QFileDialog>
 #include <QPainter>
 #include <QPixmap>
 
+#include "Logging.hpp"
 #include "MatrixClient.h"
 #include "Utils.h"
 
@@ -127,7 +127,8 @@ AudioItem::mousePressEvent(QMouseEvent *event)
                          const std::string &,
                          mtx::http::RequestErr err) {
                           if (err) {
-                                  qWarning() << "failed to retrieve m.audio content:" << url_;
+                                  nhlog::net()->info("failed to retrieve m.audio content: {}",
+                                                     url_.toString().toStdString());
                                   return;
                           }
 
@@ -147,8 +148,8 @@ AudioItem::fileDownloaded(const QByteArray &data)
 
                 file.write(data);
                 file.close();
-        } catch (const std::exception &ex) {
-                qDebug() << "Error while saving file to:" << ex.what();
+        } catch (const std::exception &e) {
+                nhlog::ui()->warn("error while saving file: {}", e.what());
         }
 }
 
diff --git a/src/timeline/widgets/FileItem.cc b/src/timeline/widgets/FileItem.cc
index 43689243..4ce4d256 100644
--- a/src/timeline/widgets/FileItem.cc
+++ b/src/timeline/widgets/FileItem.cc
@@ -16,13 +16,13 @@
  */
 
 #include <QBrush>
-#include <QDebug>
 #include <QDesktopServices>
 #include <QFile>
 #include <QFileDialog>
 #include <QPainter>
 #include <QPixmap>
 
+#include "Logging.hpp"
 #include "MatrixClient.h"
 #include "Utils.h"
 
@@ -89,7 +89,7 @@ FileItem::openUrl()
                            .arg(QString::fromStdString(mxc_parts.media_id));
 
         if (!QDesktopServices::openUrl(urlToOpen))
-                qWarning() << "Could not open url" << urlToOpen;
+                nhlog::ui()->warn("Could not open url: {}", urlToOpen.toStdString());
 }
 
 QSize
@@ -121,7 +121,8 @@ FileItem::mousePressEvent(QMouseEvent *event)
                          const std::string &,
                          mtx::http::RequestErr err) {
                           if (err) {
-                                  qWarning() << "failed to retrieve m.file content:" << url_;
+                                  nhlog::ui()->warn("failed to retrieve m.file content: {}",
+                                                    url_.toString().toStdString());
                                   return;
                           }
 
@@ -143,8 +144,8 @@ FileItem::fileDownloaded(const QByteArray &data)
 
                 file.write(data);
                 file.close();
-        } catch (const std::exception &ex) {
-                qDebug() << "Error while saving file to:" << ex.what();
+        } catch (const std::exception &e) {
+                nhlog::ui()->warn("Error while saving file to: {}", e.what());
         }
 }
 
diff --git a/src/timeline/widgets/ImageItem.cc b/src/timeline/widgets/ImageItem.cc
index 6aa010a4..bf1c05d6 100644
--- a/src/timeline/widgets/ImageItem.cc
+++ b/src/timeline/widgets/ImageItem.cc
@@ -16,7 +16,6 @@
  */
 
 #include <QBrush>
-#include <QDebug>
 #include <QDesktopServices>
 #include <QFileDialog>
 #include <QFileInfo>
@@ -25,6 +24,7 @@
 #include <QUuid>
 
 #include "Config.h"
+#include "Logging.hpp"
 #include "MatrixClient.h"
 #include "Utils.h"
 #include "dialogs/ImageOverlay.h"
@@ -39,8 +39,11 @@ ImageItem::downloadMedia(const QUrl &url)
                                                  const std::string &,
                                                  mtx::http::RequestErr err) {
                                              if (err) {
-                                                     qWarning()
-                                                       << "failed to retrieve image:" << url;
+                                                     nhlog::net()->warn(
+                                                       "failed to retrieve image {}: {} {}",
+                                                       url.toString().toStdString(),
+                                                       err->matrix_error.error,
+                                                       static_cast<int>(err->status_code));
                                                      return;
                                              }
 
@@ -61,8 +64,8 @@ ImageItem::saveImage(const QString &filename, const QByteArray &data)
 
                 file.write(data);
                 file.close();
-        } catch (const std::exception &ex) {
-                qDebug() << "Error while saving file to:" << ex.what();
+        } catch (const std::exception &e) {
+                nhlog::ui()->warn("Error while saving file to: {}", e.what());
         }
 }
 
@@ -111,7 +114,7 @@ ImageItem::openUrl()
                            .arg(QString::fromStdString(mxc_parts.media_id));
 
         if (!QDesktopServices::openUrl(urlToOpen))
-                qWarning() << "Could not open url" << urlToOpen;
+                nhlog::ui()->warn("could not open url: {}", urlToOpen.toStdString());
 }
 
 QSize
@@ -239,14 +242,19 @@ ImageItem::saveAs()
         if (filename.isEmpty())
                 return;
 
+        const auto url = url_.toString().toStdString();
+
         http::v2::client()->download(
-          url_.toString().toStdString(),
-          [this, filename](const std::string &data,
-                           const std::string &,
-                           const std::string &,
-                           mtx::http::RequestErr err) {
+          url,
+          [this, filename, url](const std::string &data,
+                                const std::string &,
+                                const std::string &,
+                                mtx::http::RequestErr err) {
                   if (err) {
-                          qWarning() << "failed to retrieve image:" << url_;
+                          nhlog::net()->warn("failed to retrieve image {}: {} {}",
+                                             url,
+                                             err->matrix_error.error,
+                                             static_cast<int>(err->status_code));
                           return;
                   }
 
diff --git a/src/timeline/widgets/VideoItem.cc b/src/timeline/widgets/VideoItem.cc
index c1f68847..34d963a9 100644
--- a/src/timeline/widgets/VideoItem.cc
+++ b/src/timeline/widgets/VideoItem.cc
@@ -15,7 +15,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QDebug>
 #include <QLabel>
 #include <QVBoxLayout>