diff --git a/maven-archetype-archetype/pom.xml b/maven-archetype-archetype/pom.xml
index b17ee2c..a6831a0 100644
--- a/maven-archetype-archetype/pom.xml
+++ b/maven-archetype-archetype/pom.xml
@@ -24,31 +24,17 @@
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-archetype</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.1-SNAPSHOT</version>
 
   <name>Maven Archetype Archetype</name>
   <description>
     An archetype which contains a sample archetype.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-archetype</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-archetype</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-archetype</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/maven-archetype-j2ee-simple/pom.xml b/maven-archetype-j2ee-simple/pom.xml
index e71c414..0bed252 100644
--- a/maven-archetype-j2ee-simple/pom.xml
+++ b/maven-archetype-j2ee-simple/pom.xml
@@ -24,31 +24,17 @@
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-j2ee-simple</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.1-SNAPSHOT</version>
 
   <name>Maven Simple J2EE Archetype</name>
   <description>
     An archetype which contains a simplified sample J2EE application.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-j2ee-simple</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-j2ee-simple</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-j2ee-simple</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/maven-archetype-plugin-site/pom.xml b/maven-archetype-plugin-site/pom.xml
index 6e77e0f..e0b6a42 100644
--- a/maven-archetype-plugin-site/pom.xml
+++ b/maven-archetype-plugin-site/pom.xml
@@ -19,19 +19,18 @@
 under the License.
 -->
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-plugin-site</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.2-SNAPSHOT</version>
 
   <name>Maven Plugin Site Archetype</name>
   <description>
@@ -39,16 +38,4 @@
     existing Maven plugin project.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-plugin-site</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-plugin-site</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-plugin-site</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/maven-archetype-plugin/pom.xml b/maven-archetype-plugin/pom.xml
index db31705..c2d7af8 100644
--- a/maven-archetype-plugin/pom.xml
+++ b/maven-archetype-plugin/pom.xml
@@ -19,35 +19,22 @@
 under the License.
 -->
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-plugin</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.3-SNAPSHOT</version>
 
   <name>Maven Plugin Archetype</name>
   <description>
     An archetype which contains a sample Maven plugin.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-plugin</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-plugin</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-plugin</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/maven-archetype-portlet/pom.xml b/maven-archetype-portlet/pom.xml
index 71276be..65c4108 100644
--- a/maven-archetype-portlet/pom.xml
+++ b/maven-archetype-portlet/pom.xml
@@ -24,31 +24,17 @@
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-portlet</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.1-SNAPSHOT</version>
 
   <name>Maven Portlet Archetype</name>
   <description>
     An archetype which contains a sample JSR-268 Portlet.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-portlet</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-portlet</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-portlet</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/maven-archetype-profiles/pom.xml b/maven-archetype-profiles/pom.xml
index de2e465..98e14e8 100644
--- a/maven-archetype-profiles/pom.xml
+++ b/maven-archetype-profiles/pom.xml
@@ -24,31 +24,17 @@
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-profiles</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.0-SNAPSHOT</version>
 
   <name>Maven Profiles Archetype</name>
   <description>
     An archetype which contains a sample Maven project which demonstrates the use of profiles.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-profiles</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-profiles</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-profiles</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/maven-archetype-quickstart/pom.xml b/maven-archetype-quickstart/pom.xml
index 74680fd..e7b0ee6 100644
--- a/maven-archetype-quickstart/pom.xml
+++ b/maven-archetype-quickstart/pom.xml
@@ -19,37 +19,24 @@
 under the License.
 -->
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-quickstart</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.2-SNAPSHOT</version>
 
   <name>Maven Quickstart Archetype</name>
   <description>
     An archetype which contains a sample Maven project.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-quickstart</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-quickstart</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-quickstart</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
   <dependencies>
     <dependency>
       <groupId>junit</groupId>
diff --git a/maven-archetype-simple/pom.xml b/maven-archetype-simple/pom.xml
index 89a773c..e704924 100644
--- a/maven-archetype-simple/pom.xml
+++ b/maven-archetype-simple/pom.xml
@@ -24,31 +24,17 @@
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>5</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-simple</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.1-SNAPSHOT</version>
 
   <name>Maven Simple Project Archetype</name>
   <description>
     An archetype which contains a simple Maven project.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-simple</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-simple</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-simple</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/maven-archetype-site-simple/pom.xml b/maven-archetype-site-simple/pom.xml
index f1bb9c5..7411e65 100644
--- a/maven-archetype-site-simple/pom.xml
+++ b/maven-archetype-site-simple/pom.xml
@@ -19,35 +19,21 @@
 under the License.
 -->
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-site-simple</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.2-SNAPSHOT</version>
 
   <name>Maven Archetype for Simple Site</name>
   <description>
     An archetype which contains a sample Maven site.
   </description>
-
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-site-simple</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-site-simple</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-site-simple</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/maven-archetype-site/pom.xml b/maven-archetype-site/pom.xml
index d774811..0fd266d 100644
--- a/maven-archetype-site/pom.xml
+++ b/maven-archetype-site/pom.xml
@@ -19,19 +19,18 @@
 under the License.
 -->
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-site</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.2-SNAPSHOT</version>
 
   <name>Maven Site Archetype</name>
   <description>
@@ -40,18 +39,6 @@
     upon an existing Maven project.
   </description>
 
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-site</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-site</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-site</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
   <build>
     <plugins>
       <plugin>
diff --git a/maven-archetype-webapp/pom.xml b/maven-archetype-webapp/pom.xml
index 1d6d8cc..d693bc6 100644
--- a/maven-archetype-webapp/pom.xml
+++ b/maven-archetype-webapp/pom.xml
@@ -24,31 +24,16 @@
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
-    <artifactId>maven-archetype-bundles</artifactId>
     <groupId>org.apache.maven.archetypes</groupId>
-    <version>31</version>
-    <relativePath>../../pom/maven/maven-archetype-bundles</relativePath>
+    <artifactId>maven-archetype-bundles</artifactId>
+    <version>1.3-SNAPSHOT</version>
   </parent>
 
   <artifactId>maven-archetype-webapp</artifactId>
   <packaging>maven-archetype</packaging>
-  <version>1.1-SNAPSHOT</version>
 
   <name>Maven Webapp Archetype</name>
   <description>
     An archetype which contains a sample Maven Webapp project.
   </description>
-
-  <scm>
-    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-webapp</connection>
-    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk/maven-archetype-webapp</developerConnection>
-    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk/maven-archetype-webapp</url>
-  </scm>
-  <distributionManagement>
-    <site>
-      <id>apache.website</id>
-      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
-    </site>
-  </distributionManagement>
-
 </project>
diff --git a/pom.xml b/pom.xml
index 3baa469..42c9cde 100644
--- a/pom.xml
+++ b/pom.xml
@@ -19,7 +19,8 @@
 under the License.
 -->
 
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
   <parent>
@@ -29,12 +30,13 @@
   </parent>
 
   <groupId>org.apache.maven.archetypes</groupId>
-  <artifactId>maven-archetype-bundles-aggregator</artifactId>
-  <version>1-SNAPSHOT</version>
+  <artifactId>maven-archetype-bundles</artifactId>
+  <version>1.3-SNAPSHOT</version>
   <packaging>pom</packaging>
 
-  <name>Maven Archetypes</name>
+  <name>Apache Maven Archetypes</name>
   <description>Archetypes provided by Maven.</description>
+  <url>https://maven.apache.org/archetypes/</url>
 
   <modules>
     <module>maven-archetype-archetype</module>
@@ -50,7 +52,51 @@
     <module>maven-archetype-webapp</module>
   </modules>
 
+  <scm>
+    <connection>scm:svn:http://svn.apache.org/repos/asf/maven/archetypes/trunk</connection>
+    <developerConnection>scm:svn:https://svn.apache.org/repos/asf/maven/archetypes/trunk</developerConnection>
+    <url>http://svn.apache.org/viewvc/maven/archetypes/trunk</url>
+  </scm>
+  <issueManagement>
+    <system>jira</system>
+    <url>https://issues.apache.org/jira/browse/MARCHETYPES</url>
+  </issueManagement>
+  <distributionManagement>
+    <site>
+      <id>apache.website</id>
+      <url>scm:svn:https://svn.apache.org/repos/infra/websites/production/maven/components/${maven.site.path}</url>
+    </site>
+  </distributionManagement>
+
   <properties>
+    <maven.site.path>archetypes-archives/archetypes-LATEST</maven.site.path>
     <rat.skip>true</rat.skip>
   </properties>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>org.apache.maven.archetype</groupId>
+        <artifactId>archetype-packaging</artifactId>
+        <version>3.0.1</version>
+      </extension>
+    </extensions>
+    <pluginManagement>
+      <plugins>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-archetype-plugin</artifactId>
+          <version>3.0.1</version>
+        </plugin>
+        <plugin>
+          <groupId>org.apache.maven.plugins</groupId>
+          <artifactId>maven-release-plugin</artifactId>
+          <configuration>
+            <tagBase>https://svn.apache.org/repos/asf/maven/archetypes/tags/</tagBase>
+            <autoVersionSubmodules>true</autoVersionSubmodules>
+          </configuration>
+        </plugin>
+      </plugins>
+    </pluginManagement>
+  </build>
 </project>
diff --git a/src/site/apt/index.apt b/src/site/apt/index.apt
new file mode 100644
index 0000000..6f04a52
--- /dev/null
+++ b/src/site/apt/index.apt
@@ -0,0 +1,55 @@
+ ------
+ Maven Archetypes
+ ------
+ Jason van Zyl
+ ------
+ 2015-08-10
+ ------
+
+~~ Licensed to the Apache Software Foundation (ASF) under one
+~~ or more contributor license agreements.  See the NOTICE file
+~~ distributed with this work for additional information
+~~ regarding copyright ownership.  The ASF licenses this file
+~~ to you under the Apache License, Version 2.0 (the
+~~ "License"); you may not use this file except in compliance
+~~ with the License.  You may obtain a copy of the License at
+~~
+~~   http://www.apache.org/licenses/LICENSE-2.0
+~~
+~~ Unless required by applicable law or agreed to in writing,
+~~ software distributed under the License is distributed on an
+~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+~~ KIND, either express or implied.  See the License for the
+~~ specific language governing permissions and limitations
+~~ under the License.
+
+~~ NOTE: For help with the syntax of this file, see:
+~~ https://maven.apache.org/guides/mini/guide-apt-format.html
+
+Maven Archetypes
+
+  Maven provides several archetype artifacts:
+
+*-----------------------------------------------------------------+----------------+
+|| Archetype ArtifactIds                                          || Description   ||
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-archetype/}maven-archetype-archetype}}     | An archetype to generate a sample archetype. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-j2ee-simple/}maven-archetype-j2ee-simple}} | An archetype to generate a simplifed sample J2EE application. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-plugin/}maven-archetype-plugin}}           | An archetype to generate a sample Maven plugin. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-plugin-site/}maven-archetype-plugin-site}} | An archetype to generate a sample Maven plugin site. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-portlet/}maven-archetype-portlet}}         | An archetype to generate a sample JSR-268 Portlet. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-quickstart/}maven-archetype-quickstart}}   | An archetype to generate a sample Maven project. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-simple/}maven-archetype-simple}}           | An archetype to generate a simple Maven project. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-site/}maven-archetype-site}}               | An archetype to generate a sample Maven site which demonstrates some of the supported document types like APT, XDoc, and FML and demonstrates how to i18n your site. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-site-simple/}maven-archetype-site-simple}} | An archetype to generate a sample Maven site. |
+*-----------------------------------------------------------------+----------------+
+| {{{./maven-archetype-webapp/}maven-archetype-webapp}}           | An archetype to generate a sample Maven Webapp project. |
+*-----------------------------------------------------------------+----------------+
diff --git a/src/site/resources/download.cgi b/src/site/resources/download.cgi
new file mode 100644
index 0000000..1b178d2
--- /dev/null
+++ b/src/site/resources/download.cgi
@@ -0,0 +1,22 @@
+#!/bin/sh
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+# Just call the standard mirrors.cgi script. It will use download.html
+# as the input template.
+exec /www/www.apache.org/dyn/mirrors/mirrors.cgi $*
\ No newline at end of file
diff --git a/src/site/site.xml b/src/site/site.xml
new file mode 100644
index 0000000..8cf6437
--- /dev/null
+++ b/src/site/site.xml
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+<project xmlns="http://maven.apache.org/DECORATION/1.8.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/DECORATION/1.8.0 http://maven.apache.org/xsd/decoration-1.8.0.xsd">
+
+  <edit>${project.scm.url}</edit>
+
+  <body>
+    <breadcrumbs>
+      <item name="Archetypes" href="https://maven.apache.org/archetypes/index.html" />
+    </breadcrumbs>
+
+    <menu name="Overview">
+      <item name="Introduction" href="index.html"/>
+      <!-- According to https://issues.apache.org/jira/browse/MNGSITE-152 -->
+      <item name="License" href="http://www.apache.org/licenses/"/>
+      <item name="Download" href="download.html"/>
+    </menu>
+
+    <menu ref="modules" />
+  </body>
+</project>
\ No newline at end of file
diff --git a/src/site/xdoc/download.xml.vm b/src/site/xdoc/download.xml.vm
new file mode 100644
index 0000000..e883f17
--- /dev/null
+++ b/src/site/xdoc/download.xml.vm
@@ -0,0 +1,126 @@
+<?xml version="1.0"?>
+
+<!--
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements.  See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership.  The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied.  See the License for the
+specific language governing permissions and limitations
+under the License.
+-->
+
+<document>
+  <properties>
+    <title>Download ${project.name} Source</title>
+  </properties>
+  <body>
+    <section name="Download ${project.name} ${project.version} Source">
+
+      <p>${project.name} ${project.version} is distributed in source format. Use a source archive if you intend to build
+      ${project.name} yourself. Otherwise, simply use the ready-made binary artifacts from central repository.</p>
+
+      <p>You will be prompted for a mirror - if the file is not found on yours, please be patient, as it may take 24
+      hours to reach all mirrors.<p/>
+
+      <p>In order to guard against corrupted downloads/installations, it is highly recommended to
+      <a href="http://www.apache.org/dev/release-signing#verifying-signature">verify the signature</a>
+      of the release bundles against the public <a href="http://www.apache.org/dist/maven/KEYS">KEYS</a> used by the Apache Maven
+      developers.</p>
+
+      <p>${project.name} is distributed under the <a href="http://www.apache.org/licenses/">Apache License, version 2.0</a>.</p>
+
+      <p></p>We <b>strongly</b> encourage our users to configure a Maven repository mirror closer to their location, please read <a href="/guides/mini/guide-mirror-settings.html">How to Use Mirrors for Repositories</a>.</p>
+
+      <a name="mirror"/>
+      <subsection name="Mirror">
+
+        <p>
+          [if-any logo]
+          <a href="[link]">
+            <img align="right" src="[logo]" border="0"
+                 alt="logo"/>
+          </a>
+          [end]
+          The currently selected mirror is
+          <b>[preferred]</b>.
+          If you encounter a problem with this mirror,
+          please select another mirror.
+          If all mirrors are failing, there are
+          <i>backup</i>
+          mirrors
+          (at the end of the mirrors list) that should be available.
+        </p>
+
+        <form action="[location]" method="get" id="SelectMirror">
+          Other mirrors:
+          <select name="Preferred">
+            [if-any http]
+            [for http]
+            <option value="[http]">[http]</option>
+            [end]
+            [end]
+            [if-any ftp]
+            [for ftp]
+            <option value="[ftp]">[ftp]</option>
+            [end]
+            [end]
+            [if-any backup]
+            [for backup]
+            <option value="[backup]">[backup] (backup)</option>
+            [end]
+            [end]
+          </select>
+          <input type="submit" value="Change"/>
+        </form>
+
+        <p>
+          You may also consult the
+          <a href="http://www.apache.org/mirrors/">complete list of
+            mirrors.</a>
+        </p>
+
+      </subsection>
+      
+      <subsection name="${project.name} ${project.version}">
+        
+      <p>This is the current stable version of ${project.name}.</p>
+        
+      <table>
+        <thead>
+          <tr>
+            <th></th>
+            <th>Link</th>
+            <th>Checksum</th>
+            <th>Signature</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td>${project.name} ${project.version} (Source zip)</td>
+            <td><a href="[preferred]maven/archetype/${project.artifactId}-${project.version}-source-release.zip">maven/archetype/${project.artifactId}-${project.version}-source-release.zip</a></td>
+            <td><a href="http://www.apache.org/dist/maven/archetype/${project.artifactId}-${project.version}-source-release.zip.md5">maven/archetype/${project.artifactId}-${project.version}-source-release.zip.md5</a></td>
+            <td><a href="http://www.apache.org/dist/maven/archetype/${project.artifactId}-${project.version}-source-release.zip.asc">maven/archetype/${project.artifactId}-${project.version}-source-release.zip.asc</a></td>
+          </tr>
+        </tbody>
+      </table>
+      </subsection>
+
+      <subsection name="Previous Versions">
+        
+      <p>Older non-recommended releases can be found on our <a href="http://archive.apache.org/dist/maven/archetype/">archive site</a>.</p>
+
+      </subsection>
+    </section>
+  </body>
+</document>
+
