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:
