diff --git a/README b/README
index 2c76693..521b07d 100644
--- a/README
+++ b/README
@@ -1,12 +1,72 @@
                               Fontconfig
              Font configuration and customization library
-                      Version 2.13.93 (2.14 RC3)
-                              2020-11-28
+                      Version 2.13.94 (2.14 RC4)
+                              2021-06-28
 
 
 Check INSTALL for compilation and installation instructions.
 Report bugs to https://gitlab.freedesktop.org/fontconfig/fontconfig/issues/new.
 
+2.13.94 (2.14 RC4)
+
+Akira TAGOH (10):
+      Add back fullname property at scan matching phase
+      Overwrite symlinks for config files
+      Fix missing <dir> element for WINDOWSFONTDIR in meson
+      Refactoring configure.ac to add <dir> element around font paths
+      Fix build fail when missing docbook and/or disabling doc-build
+      ci: Update CA cert related thing for Python on Windows
+      Add support for XDG_DATA_DIRS
+      Better wording for comments in config
+      Revert constructing fullname property from family and style properties
+      Fix score evaluation for multiple values in properties
+
+Albert Astals Cid (1):
+      Fix potential memory leak in _get_real_paths_from_prefix
+
+Ben Wagner (11):
+      Skip leading whitespace in style name.
+      Remove abort from FcCompareSize.
+      Add line between licenses in COPYING.
+      Portable trap conditions in run-test.sh.
+      Fix leaks in fcxml.c, fc-match.c, and tests.
+      Fix wild frees and leak of fs in test-conf.
+      Always run-test-conf, but skip if not built.
+      Fix test-conf string to integer conversion.
+      Test all not_eq for family names.
+      Clean up test-family-matching test.
+      Fix stack use after scope in FcConfigCompareValue
+
+Carmina16 (1):
+      ie.orth: Corrected; mistaken source replaced
+
+Heiko Becker (1):
+      Handle absolute sysconfdir when installing symlinks
+
+Jacko Dirks (1):
+      fccfg.c: lock_config: Fix potential memory leak
+
+Szunti (3):
+      Fix locale dependent behaviour in run-test.sh
+      Check qual and compare for family tests
+      Fix stripping whitespace from end of family in FcPatternAddFullname
+
+Tim-Philipp Müller (6):
+      meson: remove unused stdin_wrapper.py script
+      fcformat: fix compiler warnings with clang on Android
+      ci: add meson android aarch64 build
+      meson: error out in script if gperf preprocessing failed
+      meson: fix cross-compilation issues with gperf header file preprocessing
+      meson: fix subproject build regression
+
+Xavier Claessens (3):
+      Meson: Fallback to gperf subproject on all platforms
+      Meson: Do not wrap fccache insallation script
+      Windows: Fix symlink privilege error detection
+
+ratijas (1):
+      Fix closing tag bracket typo in doc/fontconfig-user.sgml
+
 2.13.93 (2.14 RC3)
 
 Akira TAGOH (48):
diff --git a/configure.ac b/configure.ac
index 574be2e..7c1a697 100644
--- a/configure.ac
+++ b/configure.ac
@@ -33,7 +33,7 @@
 dnl version.  This same version number must appear in fontconfig/fontconfig.h
 dnl Yes, it is a pain to synchronize version numbers.  Unfortunately, it's
 dnl not possible to extract the version number here from fontconfig.h
-AC_INIT([fontconfig], [2.13.93], [https://gitlab.freedesktop.org/fontconfig/fontconfig/issues/new])
+AC_INIT([fontconfig], [2.13.94], [https://gitlab.freedesktop.org/fontconfig/fontconfig/issues/new])
 AM_INIT_AUTOMAKE([1.11 parallel-tests dist-xz])
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
 
diff --git a/fontconfig/fontconfig.h b/fontconfig/fontconfig.h
index db14371..1ae34ae 100644
--- a/fontconfig/fontconfig.h
+++ b/fontconfig/fontconfig.h
@@ -53,7 +53,7 @@
 
 #define FC_MAJOR	2
 #define FC_MINOR	13
-#define FC_REVISION	93
+#define FC_REVISION	94
 
 #define FC_VERSION	((FC_MAJOR * 10000) + (FC_MINOR * 100) + (FC_REVISION))
 
diff --git a/meson.build b/meson.build
index 4f84ca5..0ec3dc6 100644
--- a/meson.build
+++ b/meson.build
@@ -1,5 +1,5 @@
 project('fontconfig', 'c',
-  version: '2.13.93',
+  version: '2.13.94',
   meson_version : '>= 0.56.0',
   default_options: [ 'buildtype=debugoptimized'],
 )
