diff --git a/.jenkins b/.jenkins
index 0f40e00..92b9dae 100755
--- a/.jenkins
+++ b/.jenkins
@@ -32,6 +32,9 @@
     export DISABLE_HEADERS_CHECK=yes
 fi
 
+# https://reproducible-builds.org/docs/source-date-epoch/
+export SOURCE_DATE_EPOCH=$(git log -1 --format=%ct)
+
 for file in .jenkins.d/*; do
     [[ -f $file && -x $file ]] || continue
 
diff --git a/.waf-tools/default-compiler-flags.py b/.waf-tools/default-compiler-flags.py
index 3a7bf66..8c71871 100644
--- a/.waf-tools/default-compiler-flags.py
+++ b/.waf-tools/default-compiler-flags.py
@@ -18,19 +18,22 @@
     if cxx == 'gcc':
         if ccver < (7, 4, 0):
             errmsg = ('The version of gcc you are using is too old.\n'
-                      'The minimum supported gcc version is 7.4.')
+                      'The minimum supported gcc version is 9.3.')
+        elif ccver < (9, 3, 0):
+            warnmsg = ('Using a version of gcc older than 9.3 is not '
+                       'officially supported and may result in build failures.')
         conf.flags = GccFlags()
     elif cxx == 'clang':
         if Utils.unversioned_sys_platform() == 'darwin':
             if ccver < (10, 0, 0):
                 errmsg = ('The version of Xcode you are using is too old.\n'
-                          'The minimum supported Xcode version is 11.3.')
-            elif ccver < (11, 0, 0):
-                warnmsg = ('Using a version of Xcode older than 11.3 is not '
+                          'The minimum supported Xcode version is 12.4.')
+            elif ccver < (12, 0, 0):
+                warnmsg = ('Using a version of Xcode older than 12.4 is not '
                            'officially supported and may result in build failures.')
-        elif ccver < (6, 0, 0):
+        elif ccver < (7, 0, 0):
             errmsg = ('The version of clang you are using is too old.\n'
-                      'The minimum supported clang version is 6.0.')
+                      'The minimum supported clang version is 7.0.')
         conf.flags = ClangFlags()
     else:
         warnmsg = f'{cxx} compiler is unsupported'
diff --git a/docs/INSTALL.rst b/docs/INSTALL.rst
index 188ceeb..d3f1446 100644
--- a/docs/INSTALL.rst
+++ b/docs/INSTALL.rst
@@ -7,18 +7,20 @@
 NFD is built against a continuous integration system and has been tested on the
 following platforms:
 
-- Ubuntu 18.04 / 20.04 / 22.04
-- Debian 11
+- Ubuntu 20.04 (focal)
+- Ubuntu 22.04 (jammy)
+- Debian 11 (bullseye)
 - CentOS Stream 9
-- macOS 10.15 / 11 / 12 / 13
+- macOS 11 / 12 / 13
 
-NFD is known to work on the following platforms, although they are not officially
+NFD should also work on the following platforms, although they are not officially
 supported:
 
+- Any other recent version of Ubuntu not listed above
 - Alpine >= 3.12
-- Fedora >= 29
-- Gentoo Linux
-- Raspberry Pi OS (formerly Raspbian) >= 2019-06-20
+- Fedora >= 32
+- Any version of Raspberry Pi OS based on Debian 11 (bullseye)
+- macOS 10.15
 - FreeBSD >= 12.2
 
 .. _Install NFD on Ubuntu Linux using the NDN PPA repository:
