diff --git a/README.md b/README.md
index 13197e3..af80f3a 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@
 ### Resources
 
 <!--- BROOKLYN_VERSION_BELOW -->
-The **[Developers](https://brooklyn.apache.org/developers/)** section of the main website contains more detail on working with the codebase. There is also a more **Developer Guide** specific to each version, including [this branch (0.12.0-SNAPSHOT)](https://brooklyn.apache.org/v/0.12.0-SNAPSHOT/dev/), [latest stable](https://brooklyn.apache.org/v/latest/dev/), and [older releases](https://brooklyn.apache.org/meta/versions.html).
+The **[Developers](https://brooklyn.apache.org/developers/)** section of the main website contains more detail on working with the codebase. There is also a more **Developer Guide** specific to each version, including [this branch (0.12.0)](https://brooklyn.apache.org/v/0.12.0/dev/), [latest stable](https://brooklyn.apache.org/v/latest/dev/), and [older releases](https://brooklyn.apache.org/meta/versions.html).
 
 Useful topics include:
 
@@ -48,7 +48,7 @@
 * the **[maven build](http://brooklyn.apache.org/v/latest/dev/env/maven-build.html)** and what to do on build errors
 
 <!--- BROOKLYN_VERSION_BELOW -->
-* **[project structure](https://brooklyn.apache.org/v/0.12.0-SNAPSHOT/dev/code/structure.html)** of the codebase and submodules
+* **[project structure](https://brooklyn.apache.org/v/0.12.0/dev/code/structure.html)** of the codebase and submodules
 
 * the **[people](https://brooklyn.apache.org/community/)** behind Apache Brooklyn
 
diff --git a/pom.xml b/pom.xml
index b32fded..ace9ea5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -30,7 +30,7 @@
 
     <groupId>org.apache.brooklyn</groupId>
     <artifactId>brooklyn</artifactId>
-    <version>0.12.0-SNAPSHOT</version>  <!-- BROOKLYN_VERSION -->
+    <version>0.12.0</version>  <!-- BROOKLYN_VERSION -->
     <packaging>pom</packaging>
 
     <name>Brooklyn Root</name>
