diff --git a/c++/CMakeLists.txt b/c++/CMakeLists.txt
index 39b8230..2432d86 100644
--- a/c++/CMakeLists.txt
+++ b/c++/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.6)
 project("Cap'n Proto" CXX)
-set(VERSION 0.10.2-rc3)
+set(VERSION 0.10.2)
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
diff --git a/c++/configure.ac b/c++/configure.ac
index b8651a2..18c89e0 100644
--- a/c++/configure.ac
+++ b/c++/configure.ac
@@ -1,6 +1,6 @@
 ## Process this file with autoconf to produce configure.
 
-AC_INIT([Capn Proto],[0.10.2-rc3],[capnproto@googlegroups.com],[capnproto-c++])
+AC_INIT([Capn Proto],[0.10.2],[capnproto@googlegroups.com],[capnproto-c++])
 
 AC_CONFIG_SRCDIR([src/capnp/layout.c++])
 AC_CONFIG_AUX_DIR([build-aux])
diff --git a/doc/install.md b/doc/install.md
index e90d46b..3030b6c 100644
--- a/doc/install.md
+++ b/doc/install.md
@@ -55,9 +55,9 @@
 
 You may download and install the release version of Cap'n Proto like so:
 
-<pre><code>curl -O <a href="https://capnproto.org/capnproto-c++-0.10.1.tar.gz">https://capnproto.org/capnproto-c++-0.10.1.tar.gz</a>
-tar zxf capnproto-c++-0.10.1.tar.gz
-cd capnproto-c++-0.10.1
+<pre><code>curl -O <a href="https://capnproto.org/capnproto-c++-0.10.2.tar.gz">https://capnproto.org/capnproto-c++-0.10.2.tar.gz</a>
+tar zxf capnproto-c++-0.10.2.tar.gz
+cd capnproto-c++-0.10.2
 ./configure
 make -j6 check
 sudo make install</code></pre>
@@ -96,15 +96,15 @@
 
 1. Download Cap'n Proto Win32 build:
 
-   <pre><a href="https://capnproto.org/capnproto-c++-win32-0.10.1.zip">https://capnproto.org/capnproto-c++-win32-0.10.1.zip</a></pre>
+   <pre><a href="https://capnproto.org/capnproto-c++-win32-0.10.2.zip">https://capnproto.org/capnproto-c++-win32-0.10.2.zip</a></pre>
 
-2. Find `capnp.exe`, `capnpc-c++.exe`, and `capnpc-capnp.exe` under `capnproto-tools-win32-0.10.1` in
+2. Find `capnp.exe`, `capnpc-c++.exe`, and `capnpc-capnp.exe` under `capnproto-tools-win32-0.10.2` in
    the zip and copy them somewhere.
 
 3. If your `.capnp` files will import any of the `.capnp` files provided by the core project, or
    if you use the `stream` keyword (which implicitly imports `capnp/stream.capnp`), then you need
    to put those files somewhere where the capnp compiler can find them. To do this, copy the
-   directory `capnproto-c++-0.10.1/src` to the location of your choice, then make sure to pass the
+   directory `capnproto-c++-0.10.2/src` to the location of your choice, then make sure to pass the
    flag `-I <that location>` to `capnp` when you run it.
 
 If you don't care about C++ support, you can stop here. The compiler exe can be used with plugins
@@ -118,7 +118,7 @@
 
 2. Install [CMake](http://www.cmake.org/) version 3.1 or later.
 
-3. Use CMake to generate Visual Studio project files under `capnproto-c++-0.10.1` in the zip file.
+3. Use CMake to generate Visual Studio project files under `capnproto-c++-0.10.2` in the zip file.
    You can use the CMake UI for this or run this shell command:
 
        cmake -G "Visual Studio 16 2019"
