diff --git a/vcl/qt5/QtInstance.cxx b/vcl/qt5/QtInstance.cxx
index 089ec9dc74886..4587ef6c7933f 100644
--- a/vcl/qt5/QtInstance.cxx
+++ b/vcl/qt5/QtInstance.cxx
@@ -801,6 +801,16 @@ weld::MessageDialog* QtInstance::CreateMessageDialog(weld::Widget* pParent,
                                                      VclButtonsType eButtonsType,
                                                      const OUString& rPrimaryMessage)
 {
+    SolarMutexGuard g;
+    if (!IsMainThread())
+    {
+        weld::MessageDialog* pDialog;
+        RunInMainThread([&] {
+            pDialog = CreateMessageDialog(pParent, eMessageType, eButtonsType, rPrimaryMessage);
+        });
+        return pDialog;
+    }
+
     if (QtData::noWeldedWidgets())
     {
         return SalInstance::CreateMessageDialog(pParent, eMessageType, eButtonsType,
diff --git a/vcl/qt5/QtInstanceButton.cxx b/vcl/qt5/QtInstanceButton.cxx
index a3a08c729adfc..0bc79fd2478fd 100644
--- a/vcl/qt5/QtInstanceButton.cxx
+++ b/vcl/qt5/QtInstanceButton.cxx
@@ -20,6 +20,14 @@ QtInstanceButton::QtInstanceButton(QPushButton* pButton)
 
 void QtInstanceButton::set_label(const OUString& rText)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_label(rText); });
+        return;
+    }
+
     assert(m_pButton);
     m_pButton->setText(toQString(rText));
 }
@@ -41,6 +49,15 @@ void QtInstanceButton::set_from_icon_name(const OUString& /*rIconName*/)
 
 OUString QtInstanceButton::get_label() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        OUString sLabel;
+        pQtInstance->RunInMainThread([&] { sLabel = get_label(); });
+        return sLabel;
+    }
+
     assert(m_pButton);
     return toOUString(m_pButton->text());
 }
diff --git a/vcl/qt5/QtInstanceDialog.cxx b/vcl/qt5/QtInstanceDialog.cxx
index cdd75cd9675fe..14a4774c86711 100644
--- a/vcl/qt5/QtInstanceDialog.cxx
+++ b/vcl/qt5/QtInstanceDialog.cxx
@@ -35,15 +35,50 @@ void QtInstanceDialog::SetInstallLOKNotifierHdl(const Link<void*, vcl::ILibreOff
 {
 }
 
-int QtInstanceDialog::run() { return qtResponseTypeToVclResponseType(m_pDialog->exec()); }
+int QtInstanceDialog::run()
+{
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        int nResult = 0;
+        pQtInstance->RunInMainThread([&] { nResult = run(); });
+        return nResult;
+    }
+
+    return qtResponseTypeToVclResponseType(m_pDialog->exec());
+}
 
 void QtInstanceDialog::response(int) {}
 
 void QtInstanceDialog::add_button(const OUString&, int, const OUString&) {}
 
-void QtInstanceDialog::set_modal(bool bModal) { m_pDialog->setModal(bModal); }
+void QtInstanceDialog::set_modal(bool bModal)
+{
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_modal(bModal); });
+        return;
+    }
+
+    m_pDialog->setModal(bModal);
+}
 
-bool QtInstanceDialog::get_modal() const { return m_pDialog->isModal(); }
+bool QtInstanceDialog::get_modal() const
+{
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        bool bModal = false;
+        pQtInstance->RunInMainThread([&] { bModal = get_modal(); });
+        return bModal;
+    }
+
+    return m_pDialog->isModal();
+}
 
 weld::Button* QtInstanceDialog::weld_widget_for_response(int) { return nullptr; }
 
diff --git a/vcl/qt5/QtInstanceMessageDialog.cxx b/vcl/qt5/QtInstanceMessageDialog.cxx
index b9e458c502ac4..76903fc5c63c1 100644
--- a/vcl/qt5/QtInstanceMessageDialog.cxx
+++ b/vcl/qt5/QtInstanceMessageDialog.cxx
@@ -28,11 +28,27 @@ QtInstanceMessageDialog::QtInstanceMessageDialog(QMessageBox* pMessageDialog)
 
 void QtInstanceMessageDialog::set_primary_text(const rtl::OUString& rText)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_primary_text(rText); });
+        return;
+    }
+
     m_pMessageDialog->setText(toQString(rText));
 }
 
 void QtInstanceMessageDialog::set_secondary_text(const rtl::OUString& rText)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_secondary_text(rText); });
+        return;
+    }
+
     m_pMessageDialog->setInformativeText(toQString(rText));
 }
 
@@ -40,18 +56,44 @@ weld::Container* QtInstanceMessageDialog::weld_message_area() { return nullptr;
 
 OUString QtInstanceMessageDialog::get_primary_text() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    OUString sText;
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { sText = get_primary_text(); });
+        return sText;
+    }
+
     assert(m_pMessageDialog);
     return toOUString(m_pMessageDialog->text());
 }
 
 OUString QtInstanceMessageDialog::get_secondary_text() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    OUString sText;
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { sText = get_secondary_text(); });
+        return sText;
+    }
+
     assert(m_pMessageDialog);
     return toOUString(m_pMessageDialog->informativeText());
 }
 
 void QtInstanceMessageDialog::add_button(const OUString& rText, int nResponse, const OUString&)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { add_button(rText, nResponse); });
+        return;
+    }
+
     assert(m_pMessageDialog);
     QPushButton* pButton = m_pMessageDialog->addButton(vclToQtStringWithAccelerator(rText),
                                                        QMessageBox::ButtonRole::ActionRole);
@@ -60,6 +102,14 @@ void QtInstanceMessageDialog::add_button(const OUString& rText, int nResponse, c
 
 void QtInstanceMessageDialog::set_default_response(int nResponse)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_default_response(nResponse); });
+        return;
+    }
+
     assert(m_pMessageDialog);
 
     QPushButton* pButton = buttonForResponseCode(nResponse);
@@ -69,6 +119,15 @@ void QtInstanceMessageDialog::set_default_response(int nResponse)
 
 QtInstanceButton* QtInstanceMessageDialog::weld_widget_for_response(int nResponse)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        QtInstanceButton* pButton;
+        pQtInstance->RunInMainThread([&] { pButton = weld_widget_for_response(nResponse); });
+        return pButton;
+    }
+
     if (QPushButton* pButton = buttonForResponseCode(nResponse))
         return new QtInstanceButton(pButton);
 
@@ -77,6 +136,15 @@ QtInstanceButton* QtInstanceMessageDialog::weld_widget_for_response(int nRespons
 
 int QtInstanceMessageDialog::run()
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        int nRet = 0;
+        pQtInstance->RunInMainThread([&] { nRet = run(); });
+        return nRet;
+    }
+
     m_pMessageDialog->exec();
     QAbstractButton* pClickedButton = m_pMessageDialog->clickedButton();
     if (!pClickedButton)
@@ -87,6 +155,15 @@ int QtInstanceMessageDialog::run()
 bool QtInstanceMessageDialog::runAsync(const std::shared_ptr<weld::DialogController>& rxOwner,
                                        const std::function<void(sal_Int32)>& func)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        bool bRet = false;
+        pQtInstance->RunInMainThread([&] { bRet = runAsync(rxOwner, func); });
+        return bRet;
+    }
+
     assert(m_pMessageDialog);
 
     m_xRunAsyncDialogController = rxOwner;
@@ -100,6 +177,15 @@ bool QtInstanceMessageDialog::runAsync(const std::shared_ptr<weld::DialogControl
 bool QtInstanceMessageDialog::runAsync(std::shared_ptr<Dialog> const& rxSelf,
                                        const std::function<void(sal_Int32)>& func)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        bool bRet;
+        pQtInstance->RunInMainThread([&] { bRet = runAsync(rxSelf, func); });
+        return bRet;
+    }
+
     assert(m_pMessageDialog);
     assert(rxSelf.get() == this);
 
@@ -113,12 +199,28 @@ bool QtInstanceMessageDialog::runAsync(std::shared_ptr<Dialog> const& rxSelf,
 
 void QtInstanceMessageDialog::response(int nResponse)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { response(nResponse); });
+        return;
+    }
+
     assert(m_pMessageDialog);
     m_pMessageDialog->done(nResponse);
 }
 
 void QtInstanceMessageDialog::dialogFinished(int nResult)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { dialogFinished(nResult); });
+        return;
+    }
+
     assert(m_aRunAsyncFunc);
 
     disconnect(m_pMessageDialog, &QDialog::finished, this,
@@ -137,7 +239,6 @@ void QtInstanceMessageDialog::dialogFinished(int nResult)
     if (QAbstractButton* pClickedButton = m_pMessageDialog->clickedButton())
         nRet = pClickedButton->property(PROPERTY_VCL_RESPONSE_CODE).toInt();
 
-    SolarMutexGuard g;
     aFunc(nRet);
 
     xRunAsyncDialogController.reset();
@@ -146,6 +247,15 @@ void QtInstanceMessageDialog::dialogFinished(int nResult)
 
 QPushButton* QtInstanceMessageDialog::buttonForResponseCode(int nResponse)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        QPushButton* pButton;
+        pQtInstance->RunInMainThread([&] { pButton = buttonForResponseCode(nResponse); });
+        return pButton;
+    }
+
     assert(m_pMessageDialog);
 
     const QList<QAbstractButton*> aButtons = m_pMessageDialog->buttons();
diff --git a/vcl/qt5/QtInstanceWidget.cxx b/vcl/qt5/QtInstanceWidget.cxx
index 3d377df182023..2f74e2eff8298 100644
--- a/vcl/qt5/QtInstanceWidget.cxx
+++ b/vcl/qt5/QtInstanceWidget.cxx
@@ -19,24 +19,59 @@ QtInstanceWidget::QtInstanceWidget(QWidget* pWidget)
 
 void QtInstanceWidget::set_sensitive(bool bSensitive)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_sensitive(bSensitive); });
+        return;
+    }
+
     assert(m_pWidget);
     m_pWidget->setEnabled(bSensitive);
 }
 
 bool QtInstanceWidget::get_sensitive() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        bool bSensitive = false;
+        pQtInstance->RunInMainThread([&] { bSensitive = get_sensitive(); });
+        return bSensitive;
+    }
+
     assert(m_pWidget);
     return m_pWidget->isEnabled();
 }
 
 bool QtInstanceWidget::get_visible() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        bool bVisible = false;
+        pQtInstance->RunInMainThread([&] { bVisible = get_visible(); });
+        return bVisible;
+    }
+
     assert(m_pWidget);
     return m_pWidget->isVisible();
 }
 
 bool QtInstanceWidget::is_visible() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        bool bVisible = false;
+        pQtInstance->RunInMainThread([&] { bVisible = is_visible(); });
+        return bVisible;
+    }
+
     assert(m_pWidget);
 
     QWidget* pTopLevel = m_pWidget->topLevelWidget();
@@ -46,6 +81,14 @@ bool QtInstanceWidget::is_visible() const
 
 void QtInstanceWidget::set_can_focus(bool bCanFocus)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_can_focus(bCanFocus); });
+        return;
+    }
+
     assert(m_pWidget);
     if (bCanFocus)
         m_pWidget->setFocusPolicy(Qt::FocusPolicy::StrongFocus);
@@ -55,12 +98,29 @@ void QtInstanceWidget::set_can_focus(bool bCanFocus)
 
 void QtInstanceWidget::grab_focus()
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { grab_focus(); });
+        return;
+    }
+
     assert(m_pWidget);
     m_pWidget->setFocus();
 }
 
 bool QtInstanceWidget::has_focus() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        bool bFocus = false;
+        pQtInstance->RunInMainThread([&] { bFocus = has_focus(); });
+        return bFocus;
+    }
+
     assert(m_pWidget);
     return m_pWidget->hasFocus();
 }
@@ -69,6 +129,15 @@ bool QtInstanceWidget::is_active() const { return has_focus(); }
 
 bool QtInstanceWidget::has_child_focus() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        bool bChildFocus = false;
+        pQtInstance->RunInMainThread([&] { bChildFocus = has_child_focus(); });
+        return bChildFocus;
+    }
+
     QWidget* pFocusWidget = QApplication::focusWidget();
     if (!pFocusWidget)
         return false;
@@ -84,12 +153,28 @@ bool QtInstanceWidget::has_child_focus() const
 
 void QtInstanceWidget::show()
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { show(); });
+        return;
+    }
+
     assert(m_pWidget);
     m_pWidget->show();
 }
 
 void QtInstanceWidget::hide()
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { hide(); });
+        return;
+    }
+
     assert(m_pWidget);
     m_pWidget->hide();
 }
@@ -152,30 +237,73 @@ int QtInstanceWidget::get_margin_end() const { return 1; }
 
 void QtInstanceWidget::set_accessible_name(const OUString& rName)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_accessible_name(rName); });
+        return;
+    }
+
     assert(m_pWidget);
     m_pWidget->setAccessibleName(toQString(rName));
 }
 
 void QtInstanceWidget::set_accessible_description(const OUString& rDescription)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_accessible_description(rDescription); });
+        return;
+    }
+
     assert(m_pWidget);
     m_pWidget->setAccessibleDescription(toQString(rDescription));
 }
 
 OUString QtInstanceWidget::get_accessible_name() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        OUString sName;
+        pQtInstance->RunInMainThread([&] { sName = get_accessible_name(); });
+        return sName;
+    }
+
     assert(m_pWidget);
     return toOUString(m_pWidget->accessibleName());
 }
 
 OUString QtInstanceWidget::get_accessible_description() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        OUString sDescription;
+        pQtInstance->RunInMainThread([&] { sDescription = get_accessible_description(); });
+        return sDescription;
+    }
+
     assert(m_pWidget);
     return toOUString(m_pWidget->accessibleDescription());
 }
 
 OUString QtInstanceWidget::get_accessible_id() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        OUString sId;
+        pQtInstance->RunInMainThread([&] { sId = get_accessible_id(); });
+        return sId;
+    }
+
     assert(m_pWidget);
 #if QT_VERSION >= QT_VERSION_CHECK(6, 9, 0)
     return toOUString(m_pWidget->accessibleIdentifier());
@@ -188,12 +316,29 @@ void QtInstanceWidget::set_accessible_relation_labeled_by(weld::Widget*) {}
 
 void QtInstanceWidget::set_tooltip_text(const OUString& rTip)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_tooltip_text(rTip); });
+        return;
+    }
+
     assert(m_pWidget);
     m_pWidget->setToolTip(toQString(rTip));
 }
 
 OUString QtInstanceWidget::get_tooltip_text() const
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        OUString sToolTipText;
+        pQtInstance->RunInMainThread([&] { sToolTipText = get_tooltip_text(); });
+        return sToolTipText;
+    }
+
     assert(m_pWidget);
     return toOUString(m_pWidget->toolTip());
 }
diff --git a/vcl/qt5/QtInstanceWindow.cxx b/vcl/qt5/QtInstanceWindow.cxx
index 05dfec57a973f..bf2d713e14824 100644
--- a/vcl/qt5/QtInstanceWindow.cxx
+++ b/vcl/qt5/QtInstanceWindow.cxx
@@ -16,10 +16,30 @@ QtInstanceWindow::QtInstanceWindow(QWidget* pWidget)
 
 void QtInstanceWindow::set_title(const OUString& rTitle)
 {
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        pQtInstance->RunInMainThread([&] { set_title(rTitle); });
+        return;
+    }
+
     getQWidget()->setWindowTitle(toQString(rTitle));
 }
 
-OUString QtInstanceWindow::get_title() const { return toOUString(getQWidget()->windowTitle()); }
+OUString QtInstanceWindow::get_title() const
+{
+    SolarMutexGuard g;
+    QtInstance* pQtInstance = GetQtInstance();
+    if (!pQtInstance->IsMainThread())
+    {
+        OUString sTitle;
+        pQtInstance->RunInMainThread([&] { sTitle = get_title(); });
+        return sTitle;
+    }
+
+    return toOUString(getQWidget()->windowTitle());
+}
 
 void QtInstanceWindow::window_move(int, int) {}