diff --git a/meta-openembedded/meta-xfce/recipes-xfce/exo/exo_0.12.11.bb b/meta-openembedded/meta-xfce/recipes-xfce/exo/exo_0.12.11.bb
deleted file mode 100644
index 4a5a772..0000000
--- a/meta-openembedded/meta-xfce/recipes-xfce/exo/exo_0.12.11.bb
+++ /dev/null
@@ -1,41 +0,0 @@
-DESCRIPTION = "Application library for the Xfce desktop environment"
-SECTION = "x11"
-LICENSE = "GPLv2"
-LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263"
-DEPENDS = "gtk+3 libxfce4ui virtual/libx11 liburi-perl-native cairo"
-DEPENDS_class-native = "glib-2.0-native xfce4-dev-tools-native intltool-native"
-
-inherit xfce perlnative gtk-doc features_check mime-xdg
-
-REQUIRED_DISTRO_FEATURES = "x11"
-REQUIRED_DISTRO_FEATURES_class-native = ""
-
-# SRC_URI must follow inherited one
-SRC_URI += " \
-    file://exo-no-tests-0.8.patch \
-    file://configure.patch \
-"
-
-SRC_URI_append_class-native = " \
-    file://reduce-build-to-exo-csource-only.patch \
-"
-
-SRC_URI[md5sum] = "efeb039d64b3257e39a1a38e75eb19b1"
-SRC_URI[sha256sum] = "ec892519c08a67f3e0a1f0f8d43446e26871183e5aa6be7f82e214f388d1e5b6"
-
-PACKAGECONFIG ??= ""
-PACKAGECONFIG_class-target ??= "gtk"
-PACKAGECONFIG[gtk] = "--enable-gtk2,--disable-gtk2,gtk+"
-
-PACKAGES =+ "exo-csource"
-
-# Note: python bindings did not work in oe-dev and are about to be moved to
-# pyxfce see http://comments.gmane.org/gmane.comp.desktop.xfce.devel.version4/19560
-FILES_${PN} += " \
-    ${datadir}/xfce4/ \
-    ${libdir}/xfce4/exo* \
-"
-
-FILES_exo-csource += "${bindir}/exo-csource"
-
-BBCLASSEXTEND = "native"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/exo/exo_4.16.0.bb b/meta-openembedded/meta-xfce/recipes-xfce/exo/exo_4.16.0.bb
new file mode 100644
index 0000000..5b91b8b
--- /dev/null
+++ b/meta-openembedded/meta-xfce/recipes-xfce/exo/exo_4.16.0.bb
@@ -0,0 +1,24 @@
+DESCRIPTION = "Application library for the Xfce desktop environment"
+SECTION = "x11"
+LICENSE = "GPLv2"
+LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263"
+DEPENDS = "gtk+3 libxfce4ui virtual/libx11 liburi-perl-native cairo"
+
+inherit xfce perlnative gtk-doc features_check mime-xdg
+
+REQUIRED_DISTRO_FEATURES = "x11"
+
+# SRC_URI must follow inherited one
+SRC_URI += " \
+    file://exo-no-tests-0.8.patch \
+    file://configure.patch \
+"
+
+SRC_URI[sha256sum] = "1975b00eed9a8aa1f899eab2efaea593731c19138b83fdff2f13bdca5275bacc"
+
+# Note: python bindings did not work in oe-dev and are about to be moved to
+# pyxfce see http://comments.gmane.org/gmane.comp.desktop.xfce.devel.version4/19560
+FILES_${PN} += " \
+    ${datadir}/xfce4/ \
+    ${libdir}/xfce4/exo* \
+"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/garcon/garcon_0.7.0.bb b/meta-openembedded/meta-xfce/recipes-xfce/garcon/garcon_0.8.0.bb
similarity index 65%
rename from meta-openembedded/meta-xfce/recipes-xfce/garcon/garcon_0.7.0.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/garcon/garcon_0.8.0.bb
index c4b858f..bbaa6fd 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/garcon/garcon_0.7.0.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/garcon/garcon_0.8.0.bb
@@ -4,14 +4,17 @@
 LIC_FILES_CHKSUM = "file://COPYING;md5=04a01abcbdabffae1ca26335a293276b"
 DEPENDS = "xfce4-dev-tools-native libxfce4ui intltool-native"
 
-inherit xfce gtk-doc features_check
+inherit xfce gtk-doc gobject-introspection features_check
 
 REQUIRED_DISTRO_FEATURES = "x11"
 
 SRC_URI += "file://0001-xfce-applications.menu-don-t-bloat-settings-menu-by-.patch"
-SRC_URI[md5sum] = "2964c7a7e5d4aac58b4afef9b8602914"
-SRC_URI[sha256sum] = "82c3b61b508011642b09e6fb01b1d3f22c4e4de0fc54a9244327d0ddb66b2423"
+SRC_URI[sha256sum] = "4811d89ee5bc48dbdeffd69fc3eec6c112bbf01fde98a9e848335b374a4aa1bb"
 
 EXTRA_OECONF = "--disable-gtk-doc"
 
+do_compile_prepend() {
+    export GIR_EXTRA_LIBS_PATH="${B}/garcon/.libs"
+}
+
 FILES_${PN} += "${datadir}/desktop-directories"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/files/0001-libxfce4kbd-private-xfce4-keyboard-shortcuts.xml-fix.patch b/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/files/0001-libxfce4kbd-private-xfce4-keyboard-shortcuts.xml-fix.patch
index 6d107b1..6161427 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/files/0001-libxfce4kbd-private-xfce4-keyboard-shortcuts.xml-fix.patch
+++ b/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/files/0001-libxfce4kbd-private-xfce4-keyboard-shortcuts.xml-fix.patch
@@ -19,7 +19,7 @@
 --- a/libxfce4kbd-private/xfce4-keyboard-shortcuts.xml
 +++ b/libxfce4kbd-private/xfce4-keyboard-shortcuts.xml
 @@ -75,4 +75,8 @@
-       <property name="&lt;Primary&gt;F12" type="string" value="workspace_12_key"/>
+       <property name="<Super>KP_Next" type="string" value="tile_down_right_key"/>
      </property>
    </property>
 +  <property name="providers" type="array">
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/libxfce4ui_4.14.1.bb b/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/libxfce4ui_4.14.1.bb
deleted file mode 100644
index 348b685..0000000
--- a/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/libxfce4ui_4.14.1.bb
+++ /dev/null
@@ -1,34 +0,0 @@
-SUMMARY = "Xfce4 Widget library and X Window System interaction"
-SECTION = "x11/libs"
-LICENSE = "GPLv2"
-LIC_FILES_CHKSUM = "file://COPYING;md5=252890d9eee26aab7b432e8b8a616475"
-DEPENDS = "intltool-native perl-native gtk+ gtk+3 libice libsm libxfce4util xfce4-dev-tools xfconf virtual/libx11"
-
-inherit xfce gtk-doc gobject-introspection features_check
-
-REQUIRED_DISTRO_FEATURES = "x11"
-
-SRC_URI += " \
-    file://0001-libxfce4kbd-private-xfce4-keyboard-shortcuts.xml-fix.patch \
-"
-SRC_URI[md5sum] = "50eae4bab5eeced186bce16fb5f802ac"
-SRC_URI[sha256sum] = "c449075eaeae4d1138d22eeed3d2ad7032b87fb8878eada9b770325bed87f2da"
-
-EXTRA_OECONF += "--with-vendor-info=${DISTRO}"
-
-PACKAGECONFIG ??= ""
-PACKAGECONFIG[gladeui2] = "--enable-gladeui2,--disable-gladeui2,glade"
-PACKAGECONFIG[startup-notification] = "--enable-startup-notification,--disable-startup-notification,startup-notification"
-
-PACKAGES =+ "${PN}-gtk2 ${PN}-gtk3"
-FILES_${PN}-gtk2 += "${libdir}/libxfce4ui-1.so.* ${libdir}/libxfce4kbd-private-2.so.*"
-FILES_${PN}-gtk3 += "${libdir}/libxfce4ui-2.so.* ${libdir}/libxfce4kbd-private-3.so.*"
-
-PACKAGES += "${PN}-glade"
-FILES_${PN}-glade = " \
-    ${libdir}/glade \
-    ${datadir}/glade \
-"
-
-RDEPENDS_${PN}-gtk2 = "${PN}"
-RDEPENDS_${PN}-gtk3 = "${PN}"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/libxfce4ui_4.16.0.bb b/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/libxfce4ui_4.16.0.bb
new file mode 100644
index 0000000..7a269ad
--- /dev/null
+++ b/meta-openembedded/meta-xfce/recipes-xfce/libxfce4ui/libxfce4ui_4.16.0.bb
@@ -0,0 +1,25 @@
+SUMMARY = "Xfce4 Widget library and X Window System interaction"
+SECTION = "x11/libs"
+LICENSE = "GPLv2"
+LIC_FILES_CHKSUM = "file://COPYING;md5=252890d9eee26aab7b432e8b8a616475"
+DEPENDS = "intltool-native perl-native gtk+3 libice libsm libxfce4util xfce4-dev-tools xfconf virtual/libx11"
+
+inherit xfce gtk-doc gobject-introspection features_check
+
+REQUIRED_DISTRO_FEATURES = "x11"
+
+# TODO: Check if this can go
+SRC_URI += "file://0001-libxfce4kbd-private-xfce4-keyboard-shortcuts.xml-fix.patch"
+SRC_URI[sha256sum] = "8b06c9e94f4be88a9d87c47592411b6cbc32073e7af9cbd64c7b2924ec90ceaa"
+
+EXTRA_OECONF += "--with-vendor-info=${DISTRO}"
+
+PACKAGECONFIG ??= ""
+PACKAGECONFIG[gladeui2] = "--enable-gladeui2,--disable-gladeui2,glade"
+PACKAGECONFIG[startup-notification] = "--enable-startup-notification,--disable-startup-notification,startup-notification"
+
+PACKAGES += "${PN}-glade"
+FILES_${PN}-glade = " \
+    ${libdir}/glade \
+    ${datadir}/glade \
+"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/libxfce4util/libxfce4util_4.14.0.bb b/meta-openembedded/meta-xfce/recipes-xfce/libxfce4util/libxfce4util_4.16.0.bb
similarity index 64%
rename from meta-openembedded/meta-xfce/recipes-xfce/libxfce4util/libxfce4util_4.14.0.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/libxfce4util/libxfce4util_4.16.0.bb
index 1bb5007..1a0b718 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/libxfce4util/libxfce4util_4.14.0.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/libxfce4util/libxfce4util_4.16.0.bb
@@ -6,5 +6,4 @@
 
 inherit xfce gtk-doc gobject-introspection
 
-SRC_URI[md5sum] = "46f44e36acc3abf1a5ba814c22a773cb"
-SRC_URI[sha256sum] = "32ad79b7992ec3fd863e8ff2f03eebda8740363ef9d7d910a35963ac1c1a6324"
+SRC_URI[sha256sum] = "60598d745d1fc81ff5ad3cecc3a8d1b85990dd22023e7743f55abd87d8b55b83"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/packagegroups/packagegroup-xfce-extended.bb b/meta-openembedded/meta-xfce/recipes-xfce/packagegroups/packagegroup-xfce-extended.bb
index 255d2b5..cd3fa26 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/packagegroups/packagegroup-xfce-extended.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/packagegroups/packagegroup-xfce-extended.bb
@@ -34,19 +34,15 @@
     xfce4-systemload-plugin \
     xfce4-time-out-plugin \
     xfce4-timer-plugin \
-    xfce4-embed-plugin \
     xfce4-weather-plugin \
     xfce4-fsguard-plugin \
     xfce4-battery-plugin \
     xfce4-mount-plugin \
     xfce4-powermanager-plugin \
     xfce4-closebutton-plugin \
-    xfce4-equake-plugin \
-    xfce4-notes-plugin \
     xfce4-whiskermenu-plugin \
     xfce4-mailwatch-plugin \
     xfce4-smartbookmark-plugin \
-    xfce4-hotcorner-plugin \
     ${@bb.utils.contains('DISTRO_FEATURES', 'pulseaudio', 'xfce4-pulseaudio-plugin', '', d)} \
     xfce4-sensors-plugin \
     xfce4-calculator-plugin \
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/thunar-volman/thunar-volman_0.9.5.bb b/meta-openembedded/meta-xfce/recipes-xfce/thunar-volman/thunar-volman_4.16.0.bb
similarity index 74%
rename from meta-openembedded/meta-xfce/recipes-xfce/thunar-volman/thunar-volman_0.9.5.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/thunar-volman/thunar-volman_4.16.0.bb
index d499e22..138796e 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/thunar-volman/thunar-volman_0.9.5.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/thunar-volman/thunar-volman_4.16.0.bb
@@ -8,8 +8,7 @@
 
 REQUIRED_DISTRO_FEATURES = "x11"
 
-SRC_URI[md5sum] = "f9ef39ed4bbff05eb74058dfff24dd84"
-SRC_URI[sha256sum] = "7ea7c6693334f2248cf399586af8974dfb7db9aad685ee31ac100e62e19a1837"
+SRC_URI[sha256sum] = "d2c0e719b242b7fd3db70bc6678a2df1abf2cfaa899b775a1591a5efa08a547d"
 
 PACKAGECONFIG ??= ""
 PACKAGECONFIG[notify] = "--enable-notifications,--disable-notifications,libnotify"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/thunar/thunar_1.8.15.bb b/meta-openembedded/meta-xfce/recipes-xfce/thunar/thunar_4.16.0.bb
similarity index 84%
rename from meta-openembedded/meta-xfce/recipes-xfce/thunar/thunar_1.8.15.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/thunar/thunar_4.16.0.bb
index b1f1c96..ae05f86 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/thunar/thunar_1.8.15.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/thunar/thunar_4.16.0.bb
@@ -8,8 +8,7 @@
 
 REQUIRED_DISTRO_FEATURES = "x11"
 
-SRC_URI[md5sum] = "303010f4959fa23f7c13c0ccd9b8527e"
-SRC_URI[sha256sum] = "7624560cf21f13869804947042610aab22075146b711593f11ceb9e494277c93"
+SRC_URI[sha256sum] = "6277c448116a91ebfa564972645d8d79ef69864992a02bb164b7b13f98fdfd9b"
 
 PACKAGECONFIG ??= ""
 PACKAGECONFIG[pcre] = "--enable-pcre,--disable-pcre,libpcre"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/tumbler/tumbler_0.3.1.bb b/meta-openembedded/meta-xfce/recipes-xfce/tumbler/tumbler_4.16.0.bb
similarity index 91%
rename from meta-openembedded/meta-xfce/recipes-xfce/tumbler/tumbler_0.3.1.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/tumbler/tumbler_4.16.0.bb
index c9f2ddc..fcc39fd 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/tumbler/tumbler_0.3.1.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/tumbler/tumbler_4.16.0.bb
@@ -6,7 +6,7 @@
 
 inherit xfce gtk-doc
 
-SRC_URI[sha256sum] = "e4a30f3c0656b5b29fcd4a2450293f20f283a95b7fb0754a947c55427784c454"
+SRC_URI[sha256sum] = "9b0b7fed0c64041733d490b1b307297984629d0dd85369749617a8766850af66"
 
 INSANE_SKIP_${PN} = "dev-so"
 
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-appfinder/xfce4-appfinder_4.14.0.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-appfinder/xfce4-appfinder_4.16.0.bb
similarity index 68%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfce4-appfinder/xfce4-appfinder_4.14.0.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfce4-appfinder/xfce4-appfinder_4.16.0.bb
index e4f35b0..3919830 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-appfinder/xfce4-appfinder_4.14.0.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-appfinder/xfce4-appfinder_4.16.0.bb
@@ -8,7 +8,6 @@
 
 REQUIRED_DISTRO_FEATURES = "x11"
 
-SRC_URI[md5sum] = "03b226a2ee20f95243e74d1868e94e0e"
-SRC_URI[sha256sum] = "7ec175d4954fceb2e76cbfbca76ac4a4f53fe799d097a14117e7de68e88a4d98"
+SRC_URI[sha256sum] = "37b92aaaeeec8220ed23163cf89321168d3b49e0c48b4c10f12dc4a21fdf0954"
 
 FILES_${PN} += "${datadir}/metainfo"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools/0001-Run-native-xdt-csource-on-tests.patch b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools/0001-Run-native-xdt-csource-on-tests.patch
new file mode 100644
index 0000000..74b1679
--- /dev/null
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools/0001-Run-native-xdt-csource-on-tests.patch
@@ -0,0 +1,33 @@
+From b2fcd5c09ee6b4ad03f93ee5e1dd32f2f062cf07 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Andreas=20M=C3=BCller?= <schnitzeltony@gmail.com>
+Date: Sun, 3 Jan 2021 15:36:07 +0100
+Subject: [PATCH] Run native xdt-csource on tests
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Tests cannot be opted out so let them pass.
+
+Upstream-Status: Inappropriate [OE specific]
+
+Signed-off-by: Andreas Müller <schnitzeltony@gmail.com>
+---
+ tests/Makefile.am | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/tests/Makefile.am b/tests/Makefile.am
+index fa0832c..7c46bbf 100644
+--- a/tests/Makefile.am
++++ b/tests/Makefile.am
+@@ -26,7 +26,7 @@ DISTCLEANFILES = test-xdt-csource-data.c
+ BUILT_SOURCES = test-xdt-csource-data.c
+ 
+ test-xdt-csource-data.c: Makefile $(srcdir)/data/data.bin $(srcdir)/data/data.txt
+-	$(top_builddir)/xdt-csource/xdt-csource --extern --build-list data_bin $(srcdir)/data/data.bin data_txt $(srcdir)/data/data.txt > test-xdt-csource-data.c
++	xdt-csource --extern --build-list data_bin $(srcdir)/data/data.bin data_txt $(srcdir)/data/data.txt > test-xdt-csource-data.c
+ 
+ clean-local:
+ 	rm -f *.core core core.*
+-- 
+2.26.2
+
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools_4.14.0.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools_4.16.0.bb
similarity index 71%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools_4.14.0.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools_4.16.0.bb
index 0b11966..143a0a5 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools_4.14.0.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-dev-tools/xfce4-dev-tools_4.16.0.bb
@@ -3,15 +3,17 @@
 SECTION = "x11/libs"
 LICENSE = "GPLv2"
 LIC_FILES_CHKSUM = "file://COPYING;md5=9ac2e7cff1ddaf48b6eab6028f23ef88"
+
 DEPENDS = "glib-2.0"
+DEPENDS_append_class-target = " ${BPN}-native"
 
 inherit autotools pkgconfig
 
 BBCLASSEXTEND = "native"
 
 SRC_URI = "http://archive.xfce.org/src/xfce/${BPN}/${@'${PV}'[0:4]}/${BPN}-${PV}.tar.bz2"
-SRC_URI[md5sum] = "5f8fc8af73819c08d9e4c26a3ac457e7"
-SRC_URI[sha256sum] = "2c9eb8e0fe23e47dc31411a93b683fd1b7a49140e9163f0aab9e94a3d8a0b5fd"
+SRC_URI_append_class-target = " file://0001-Run-native-xdt-csource-on-tests.patch"
+SRC_URI[sha256sum] = "f50b3070e66f3ebdf331744dd1ec5e1af5de333965d491e15ce05545e8eb4f04"
 
 do_install_append() {
     install -d ${D}${datadir}/aclocal
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-panel/xfce4-panel_4.14.4.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-panel/xfce4-panel_4.16.0.bb
similarity index 90%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfce4-panel/xfce4-panel_4.14.4.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfce4-panel/xfce4-panel_4.16.0.bb
index 73cb82a..0b210ff 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-panel/xfce4-panel_4.14.4.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-panel/xfce4-panel_4.16.0.bb
@@ -8,8 +8,7 @@
 
 REQUIRED_DISTRO_FEATURES = "x11"
 
-SRC_URI[md5sum] = "76efdbf7fb461f3058919c1309da67ca"
-SRC_URI[sha256sum] = "8e5ea79412ba84cfada897ff309cbe2cd4aca16b9bd4f93df060229528576fd5"
+SRC_URI[sha256sum] = "5e979aeeb37d306d72858b1bc67448222ea7a68de01409055b846cd31f3cc53d"
 SRC_URI += " \
     file://0001-windowmenu-do-not-display-desktop-icon-when-no-windo.patch \
     file://0002-use-lxdm-to-replace-dm-tool.patch \
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-power-manager/xfce4-power-manager_1.6.6.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-power-manager/xfce4-power-manager_4.16.0.bb
similarity index 89%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfce4-power-manager/xfce4-power-manager_1.6.6.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfce4-power-manager/xfce4-power-manager_4.16.0.bb
index 608990a..7a778bd 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-power-manager/xfce4-power-manager_1.6.6.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-power-manager/xfce4-power-manager_4.16.0.bb
@@ -11,8 +11,7 @@
 
 DEPENDS += "libnotify libxrandr virtual/libx11 libxext xfce4-panel upower libxscrnsaver"
 
-SRC_URI[md5sum] = "19873fc8a6de5e37ed57036a0002a5ce"
-SRC_URI[sha256sum] = "1b7bf0d3e8af69b10f7b6a518451e01fc7888e0d9d360bc33f6c89179bb6080b"
+SRC_URI[sha256sum] = "eb9c587c01b502fa45a32e7fc2aba98fa6d8391475133883654f77e562c43bf3"
 
 EXTRA_OECONF = " \
     --enable-network-manager \
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-session/xfce4-session_4.14.2.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-session/xfce4-session_4.16.0.bb
similarity index 79%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfce4-session/xfce4-session_4.14.2.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfce4-session/xfce4-session_4.16.0.bb
index f497b76..36b5bc2 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-session/xfce4-session_4.14.2.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-session/xfce4-session_4.16.0.bb
@@ -12,11 +12,8 @@
 PACKAGECONFIG ??= "${@bb.utils.filter('DISTRO_FEATURES', 'polkit', d)}"
 PACKAGECONFIG[polkit] = "--enable-polkit, --disable-polkit, polkit"
 
-SRC_URI += " \
-    file://0001-configure.in-hard-code-path-to-iceauth.patch \
-"
-SRC_URI[md5sum] = "5ad23062fd08ef5f5ad9b4389c7b54c6"
-SRC_URI[sha256sum] = "fbe3a4a60c91589a2024ce12b2d2667625a8fedcbc90ef031831f56319f597af"
+SRC_URI += "file://0001-configure.in-hard-code-path-to-iceauth.patch"
+SRC_URI[sha256sum] = "22f273f212481d71e0b5618c62710cd85f69aea74f5ea5c0093f7918b07d17b7"
 
 ALTERNATIVE_${PN} = "x-session-manager"
 ALTERNATIVE_TARGET[x-session-manager] = "${bindir}/xfce4-session"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-settings/xfce4-settings_4.14.3.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-settings/xfce4-settings_4.16.0.bb
similarity index 75%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfce4-settings/xfce4-settings_4.14.3.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfce4-settings/xfce4-settings_4.16.0.bb
index 08c612a..47de8c5 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfce4-settings/xfce4-settings_4.14.3.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfce4-settings/xfce4-settings_4.16.0.bb
@@ -2,17 +2,14 @@
 SECTION = "x11/wm"
 LICENSE = "GPLv2"
 LIC_FILES_CHKSUM = "file://COPYING;md5=94d55d512a9ba36caa9b7df079bae19f"
-DEPENDS = "exo exo-native garcon libxi virtual/libx11 xrandr libxcursor libxklavier upower"
+DEPENDS = "exo garcon libxi virtual/libx11 xrandr libxcursor libxklavier upower"
 
-inherit xfce features_check
+inherit xfce features_check mime-xdg
 
 REQUIRED_DISTRO_FEATURES = "x11"
 
-SRC_URI += " \
-    file://0001-xsettings.xml-Set-default-themes.patch \
-"
-SRC_URI[md5sum] = "fe8f7d4221be1467b85c8539344c3f07"
-SRC_URI[sha256sum] = "cab1a4d5351f9871533700523570f86f92bbe6e4055f44e5df950eb4b4f48bb3"
+SRC_URI += "file://0001-xsettings.xml-Set-default-themes.patch"
+SRC_URI[sha256sum] = "67a1404fc754c675c6431e22a8fe0e5d79644fdfadbfe25a4523d68e1442ddc2"
 
 EXTRA_OECONF += "--enable-maintainer-mode --disable-debug"
 
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfconf/xfconf_4.14.3.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfconf/xfconf_4.16.0.bb
similarity index 77%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfconf/xfconf_4.14.3.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfconf/xfconf_4.16.0.bb
index 792f8b1..9b341bb 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfconf/xfconf_4.14.3.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfconf/xfconf_4.16.0.bb
@@ -4,12 +4,11 @@
 LIC_FILES_CHKSUM = "file://COPYING;md5=59530bdf33659b29e73d4adb9f9f6552"
 DEPENDS = "libxfce4util perl intltool-native xfce4-dev-tools-native"
 
-inherit xfce gtk-doc gobject-introspection
+inherit xfce gtk-doc gobject-introspection bash-completion
 
 EXTRA_OECONF += "PERL=${STAGING_DIR_TARGET}/usr/bin/perl"
 
-SRC_URI[md5sum] = "25c32ed08a43e81f7900c03601dffc02"
-SRC_URI[sha256sum] = "589052a0efc6151c5fb5f438da463502a4fd91848cae7b9376d417be4c5a0c02"
+SRC_URI[sha256sum] = "652a119007c67d9ba6c0bc7a740c923d33f32d03dc76dfc7ba682584e72a5425"
 
 FILES_${PN} += "${libdir}/xfce4/xfconf/xfconfd \
                 ${libdir}/gio/modules/libxfconfgsettingsbackend.so \
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfdesktop/xfdesktop_4.14.2.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfdesktop/xfdesktop_4.16.0.bb
similarity index 73%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfdesktop/xfdesktop_4.14.2.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfdesktop/xfdesktop_4.16.0.bb
index a512a62..e8b2b72 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfdesktop/xfdesktop_4.14.2.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfdesktop/xfdesktop_4.16.0.bb
@@ -8,8 +8,7 @@
 
 REQUIRED_DISTRO_FEATURES = "x11"
 
-SRC_URI[md5sum] = "5db09df39b0808f25bd3a3128f8c9e77"
-SRC_URI[sha256sum] = "a30534461fea907f969f608a11c84be0b1aaad687c591c32cd56a9d274ea3e74"
+SRC_URI[sha256sum] = "934ba5affecff21e62d9fac1dd50c50cd94b3a807fefa5f5bff59f3d6f155bae"
 
 PACKAGECONFIG ??= ""
 PACKAGECONFIG[notify] = "--enable-notifications,--disable-notifications,libnotify"
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfwm4/files/0001-Revert-compositor-Revert-to-GLX-as-default-vblank-me.patch b/meta-openembedded/meta-xfce/recipes-xfce/xfwm4/files/0001-Revert-compositor-Revert-to-GLX-as-default-vblank-me.patch
deleted file mode 100644
index 04fd623..0000000
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfwm4/files/0001-Revert-compositor-Revert-to-GLX-as-default-vblank-me.patch
+++ /dev/null
@@ -1,92 +0,0 @@
-From acdceb0b28d86199b8c2233880fa8a04cb24d4d4 Mon Sep 17 00:00:00 2001
-From: Kai Kang <kai.kang@windriver.com>
-Date: Wed, 24 Jul 2019 09:48:04 +0800
-Subject: [PATCH] Revert "compositor: Revert to GLX as default vblank method
- (again)"
-
-This reverts commit e07574d6e7a2dbaa08c3ba4765c6306073d9493e.
-
-It sets the default vblank method (auto) to GLX from 4.13.2. But it
-fails to start xfwm4 on intel-x86-64 boards with error:
-
-| xfwm4: ../mesa-19.1.1/src/mesa/drivers/dri/i965/intel_mipmap_tree.c:1293:
-| intel_miptree_match_image: Assertion `image->TexObject->Target == mt->target' failed.
-| Aborted
-
-There is also a RHEL defect:
-https://bugzilla.redhat.com/show_bug.cgi?id=1678334
-
-Revert the commit to fix the issue.
-
-Upstream-Status: Inappropriate [workaround]
-
-Signed-off-by: Kai Kang <kai.kang@windriver.com>
----
- src/compositor.c | 41 +++++++++++++++++++----------------------
- 1 file changed, 19 insertions(+), 22 deletions(-)
-
-diff --git a/src/compositor.c b/src/compositor.c
-index 25615282..daced607 100644
---- a/src/compositor.c
-+++ b/src/compositor.c
-@@ -4483,13 +4483,28 @@ compositorManageScreen (ScreenInfo *screen_info)
-     XClearArea (display_info->dpy, screen_info->output, 0, 0, 0, 0, TRUE);
-     TRACE ("manual compositing enabled");
- 
-+#ifdef HAVE_PRESENT_EXTENSION
-+    screen_info->use_present = display_info->have_present &&
-+                               (screen_info->vblank_mode == VBLANK_AUTO ||
-+                                screen_info->vblank_mode == VBLANK_XPRESENT);
-+    if (screen_info->use_present)
-+    {
-+        screen_info->present_pending = FALSE;
-+        XPresentSelectInput (display_info->dpy,
-+                             screen_info->output,
-+                             PresentCompleteNotifyMask);
-+    }
-+#else /* HAVE_PRESENT_EXTENSION */
-+    screen_info->use_present = FALSE;
-+#endif /* HAVE_PRESENT_EXTENSION */
-+
- #ifdef HAVE_EPOXY
--    screen_info->use_glx = (screen_info->vblank_mode == VBLANK_AUTO ||
--                            screen_info->vblank_mode == VBLANK_GLX);
-+    screen_info->use_glx = !screen_info->use_present &&
- #ifdef HAVE_XSYNC
--    screen_info->use_glx &= display_info->have_xsync;
-+                            display_info->have_xsync &&
- #endif /* HAVE_XSYNC */
--
-+                            (screen_info->vblank_mode == VBLANK_AUTO ||
-+                             screen_info->vblank_mode == VBLANK_GLX);
-     if (screen_info->use_glx)
-     {
-         screen_info->glx_context = None;
-@@ -4503,24 +4518,6 @@ compositorManageScreen (ScreenInfo *screen_info)
-     screen_info->use_glx = FALSE;
- #endif /* HAVE_EPOXY */
- 
--#ifdef HAVE_PRESENT_EXTENSION
--    screen_info->use_present = display_info->have_present &&
--#ifdef HAVE_EPOXY
--                               !screen_info->use_glx &&
--#endif /* HAVE_EPOXY */
--                               (screen_info->vblank_mode == VBLANK_AUTO ||
--                                screen_info->vblank_mode == VBLANK_XPRESENT);
--    if (screen_info->use_present)
--    {
--        screen_info->present_pending = FALSE;
--        XPresentSelectInput (display_info->dpy,
--                             screen_info->output,
--                             PresentCompleteNotifyMask);
--    }
--#else /* HAVE_PRESENT_EXTENSION */
--    screen_info->use_present = FALSE;
--#endif /* HAVE_PRESENT_EXTENSION */
--
-     if (screen_info->use_present)
-     {
-         g_info ("Compositor using XPresent for vsync");
--- 
-2.20.1
-
diff --git a/meta-openembedded/meta-xfce/recipes-xfce/xfwm4/xfwm4_4.14.5.bb b/meta-openembedded/meta-xfce/recipes-xfce/xfwm4/xfwm4_4.16.0.bb
similarity index 82%
rename from meta-openembedded/meta-xfce/recipes-xfce/xfwm4/xfwm4_4.14.5.bb
rename to meta-openembedded/meta-xfce/recipes-xfce/xfwm4/xfwm4_4.16.0.bb
index f8febe8..3f64365 100644
--- a/meta-openembedded/meta-xfce/recipes-xfce/xfwm4/xfwm4_4.14.5.bb
+++ b/meta-openembedded/meta-xfce/recipes-xfce/xfwm4/xfwm4_4.16.0.bb
@@ -2,14 +2,13 @@
 SECTION = "x11/wm"
 LICENSE = "GPLv2"
 LIC_FILES_CHKSUM = "file://COPYING;md5=d791728a073bc009b4ffaf00b7599855"
-DEPENDS = "virtual/libx11 libxfce4ui libwnck3 libxinerama exo-native"
+DEPENDS = "virtual/libx11 libxfce4ui libwnck3 libxinerama"
 
 inherit xfce update-alternatives features_check
 
 REQUIRED_DISTRO_FEATURES = "x11"
 
-SRC_URI += "file://0001-Revert-compositor-Revert-to-GLX-as-default-vblank-me.patch"
-SRC_URI[sha256sum] = "d7a7c63fa42ec6d7cb3caab130d6f496be5bd7689b775d20e8786b7f3e282930"
+SRC_URI[sha256sum] = "1e22eae1bbb66cebfd1753b0a5606e76ecbf6b09ce4cdfd732d093c936f1feb3"
 
 PACKAGECONFIG ?= " \
     ${@bb.utils.contains('DISTRO_FEATURES', 'opengl', 'epoxy', '', d)} \
