diff --git a/bundles/org.eclipse.rap.doc/guide/articles/application-setup.html b/bundles/org.eclipse.rap.doc/guide/articles/application-setup.html
index f88c226..81b5701 100644
--- a/bundles/org.eclipse.rap.doc/guide/articles/application-setup.html
+++ b/bundles/org.eclipse.rap.doc/guide/articles/application-setup.html
@@ -3,7 +3,7 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-  <meta name="copyright" content="Copyright (c) 2007, 2012 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
+  <meta name="copyright" content="Copyright (c) 2007, 2013 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
   <title>Choosing a RAP Application Setup</title>
   <link rel="stylesheet" href="../../../PRODUCT_PLUGIN/book.css" type="text/css"/>
@@ -77,14 +77,14 @@
     In JEE mode, code execution will continue after opening the dialog, but any operations reacting
     to closing the dialog must be done in a callback.
     RAP provides an
-    <a href="../reference/api/org/eclipse/rwt/widgets/DialogUtil.html">alternative API</a> that can
+    <a href="../reference/api/org/eclipse/rap/rwt/widgets/DialogUtil.html">alternative API</a> that can
     be used for those dialog callbacks.
     This mechanism does not exist in SWT.
   </p>
   <p>
     Another blocking API in SWT are the <em>Browser</em>-widget's execute and evaluate
     methods. Their return value can also be obtained with
-    <a href="../reference/api/org/eclipse/rwt/widgets/BrowserUtil.html">callback implementation</a>,
+    <a href="../reference/api/org/eclipse/rap/rwt/widgets/BrowserUtil.html">callback implementation</a>,
     but this may be problematic when developing
     <a href="custom-widget.html#browser">browser-based custom widgets</a>.
   </p>
diff --git a/bundles/org.eclipse.rap.doc/guide/articles/deployment.html b/bundles/org.eclipse.rap.doc/guide/articles/deployment.html
index e6e32b1..3320de0 100644
--- a/bundles/org.eclipse.rap.doc/guide/articles/deployment.html
+++ b/bundles/org.eclipse.rap.doc/guide/articles/deployment.html
@@ -3,7 +3,7 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-  <meta name="copyright" content="Copyright (c) 2007, 2011 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
+  <meta name="copyright" content="Copyright (c) 2007, 2013 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
   <title>Deployment</title>
   <link rel="stylesheet" href="../../../PRODUCT_PLUGIN/book.css" type="text/css"/>
@@ -33,8 +33,8 @@
     </li>
     <li>
       have installed the WAR Products tooling from this p2 repository
-      <a href="http://download.eclipse.org/releases/indigo">http://download.eclipse.org/releases/indigo</a>
-      into your IDE. This tooling is part of <a href="http://eclipse.org/libra">Libra</a> and not
+      <a href="http://download.eclipse.org/releases/juno/">http://download.eclipse.org/releases/juno/</a>
+      into your IDE. This tooling is part of <a href="http://eclipse.org/libra/">Libra</a> and not
       part of RAP. Anyway it can be used to deploy RAP applications in a very comfortable way.
     </li>
     <li>
diff --git a/bundles/org.eclipse.rap.doc/guide/articles/hello-world.html b/bundles/org.eclipse.rap.doc/guide/articles/hello-world.html
index cb6208e..23218aa 100644
--- a/bundles/org.eclipse.rap.doc/guide/articles/hello-world.html
+++ b/bundles/org.eclipse.rap.doc/guide/articles/hello-world.html
@@ -27,7 +27,7 @@
   <p>
     First we need to create a project for your application.
     It is recommended to use a <em>Plug-in Project</em>,
-    unless you want to write an <a href = "rwt-standalone">RAP applications
+    unless you want to write an <a href="?topic=rwt-standalone&amp;version=2.0">RAP applications
     without OSGi</a>. In the latter case, you can also create a plain <em>Java Project</em> here.
     (If you do so, the project setup will differ slightly from this tutorial. Most notably, you
     will have to add <em>org.eclipse.rap.rwt</em> to the java build path/
diff --git a/bundles/org.eclipse.rap.doc/guide/articles/look-and-feel.html b/bundles/org.eclipse.rap.doc/guide/articles/look-and-feel.html
index 80cedbb..d35965f 100644
--- a/bundles/org.eclipse.rap.doc/guide/articles/look-and-feel.html
+++ b/bundles/org.eclipse.rap.doc/guide/articles/look-and-feel.html
@@ -3,7 +3,7 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-  <meta name="copyright" content="Copyright (c) 2009, 2011 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
+  <meta name="copyright" content="Copyright (c) 2009, 2013 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
   <title>RAP look and feel</title>
   <link rel="stylesheet" href="../../../PRODUCT_PLUGIN/book.css" type="text/css" />
@@ -440,9 +440,10 @@
     code allowing you to reuse the component in different places.
   </p>
   <p>
-    This completes our tour of the interaction design API. For questions please
-    feel free to visit the <a href="http://www.eclipse.org/rap/newsgroup.php">
-    RAP newsgroup</a>. We'd also be glad to hear about your experiences with this
+    This completes our tour of the interaction design API.
+    For questions please feel free to ask in the
+    <a href="http://www.eclipse.org/forums/eclipse.technology.rap">RAP forum</a>.
+    We'd also be glad to hear about your experiences with this
     API and to have a look at the great new look and feels you're building for
     your apps.
   </p>
diff --git a/bundles/org.eclipse.rap.doc/guide/articles/markup.html b/bundles/org.eclipse.rap.doc/guide/articles/markup.html
index 95c4b0a..ca804c4 100644
--- a/bundles/org.eclipse.rap.doc/guide/articles/markup.html
+++ b/bundles/org.eclipse.rap.doc/guide/articles/markup.html
@@ -196,7 +196,7 @@
   <p>
     While RAP does not include an markup-enabled text field, there is a rich text editor
     <a href="http://wiki.eclipse.org/RAP/Add-Ons">add-on</a> available based on the
-    the <a href="http://www.ckeditor.com">CKEditor</a>.
+    the <a href="http://www.ckeditor.com/">CKEditor</a>.
   </p>
 </body>
 </html>
diff --git a/bundles/org.eclipse.rap.doc/guide/articles/related-technologies.html b/bundles/org.eclipse.rap.doc/guide/articles/related-technologies.html
index 69083f1..941abd1 100644
--- a/bundles/org.eclipse.rap.doc/guide/articles/related-technologies.html
+++ b/bundles/org.eclipse.rap.doc/guide/articles/related-technologies.html
@@ -3,7 +3,7 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-  <meta name="copyright" content="Copyright (c) 2012 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
+  <meta name="copyright" content="Copyright (c) 2012, 2013 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
   <title>Underlying Technologies</title>
   <link rel="stylesheet" href="../../../PRODUCT_PLUGIN/book.css" type="text/css"/>
@@ -25,7 +25,7 @@
     <a href="http://www.oracle.com/technetwork/java/javaee/servlet/index.html">Servlet technology</a>,
     <a href="http://www.osgi.org/">OSGi</a>,
     the <a href="http://www.eclipse.org/equinox/">Equinox</a> OSGi implementation,
-    <a href="http://www.eclipse.org/swt">SWT</a>,
+    <a href="http://www.eclipse.org/swt/">SWT</a>,
     maybe also
     <a href="http://wiki.eclipse.org/index.php/Rich_Client_Platform">RCP</a>.
     Here are some links to get you started:
diff --git a/bundles/org.eclipse.rap.doc/guide/articles/rwt-standalone.html b/bundles/org.eclipse.rap.doc/guide/articles/rwt-standalone.html
index 0e9e2f2..dc7beb5 100644
--- a/bundles/org.eclipse.rap.doc/guide/articles/rwt-standalone.html
+++ b/bundles/org.eclipse.rap.doc/guide/articles/rwt-standalone.html
@@ -3,7 +3,7 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-  <meta name="copyright" content="Copyright (c) 2012 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
+  <meta name="copyright" content="Copyright (c) 2012, 2013 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
   <title>RWT standalone</title>
   <link rel="stylesheet" href="../../../PRODUCT_PLUGIN/book.css" type="text/css"/>
@@ -13,7 +13,7 @@
   <h1>RWT standalone applications with RAP</h1>
   <p>
     It is possible to use RAP without OSGi. In that case RWT is used like normal Java library.
-    It is recommended to use the <a href="http://eclipse.org/rap/downloads" >RAP Tooling</a>
+    It is recommended to use the <a href="http://eclipse.org/rap/downloads/" >RAP Tooling</a>
     for developing RWT applications. Though it is not strictly necessary to use the tooling, it
     eases development with a launch configuration tailored for RWT applications and documentation.
   </p>
@@ -42,7 +42,7 @@
     </li>
     <li>
       Copy the <em>org.eclipse.rap.rwt_*</em> jar from the
-      <a href="http://eclipse.org/rap/downloads">RAP Runtime</a> into the <em>WEB-INF/lib</em>
+      <a href="http://eclipse.org/rap/downloads/">RAP Runtime</a> into the <em>WEB-INF/lib</em>
       folder and add it to the projects' build path. The <em>org.eclipse.rap.rwt.source_*</em>
       jar contains the RWT source code. To be able to browse the sources and read JavaDoc, specify
       this jar as the<em class="UiLabel">
@@ -126,7 +126,7 @@
   <p>
     You may also find the <a href="http://wiki.eclipse.org/index.php/JFace">JFace</a> components
     useful. In order to use them from RWT standalone, you will need to add the following jars from
-    the <a href="http://eclipse.org/rap/downloads">RAP Runtime</a>:
+    the <a href="http://eclipse.org/rap/downloads/">RAP Runtime</a>:
   </p>
   <ul>
     <li> <em>org.eclipse.rap.jface</em></li>
diff --git a/bundles/org.eclipse.rap.doc/guide/articles/rwt.html b/bundles/org.eclipse.rap.doc/guide/articles/rwt.html
index e90503f..a524c00 100644
--- a/bundles/org.eclipse.rap.doc/guide/articles/rwt.html
+++ b/bundles/org.eclipse.rap.doc/guide/articles/rwt.html
@@ -3,7 +3,7 @@
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
-  <meta name="copyright" content="Copyright (c) 2012 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
+  <meta name="copyright" content="Copyright (c) 2012, 2013 EclipseSource. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page."/>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
   <title>Introduction and Comparison to SWT</title>
   <link rel="stylesheet" href="../../../PRODUCT_PLUGIN/book.css" type="text/css"/>
@@ -29,8 +29,8 @@
     key and mouse event handling, drag and drop and painting (on <em>Canvas</em>).
     If you are not already familiar with SWT, we recommend to first learn the SWT basics
     (almost all valid for RWT) by reading the official documentation
-    and <a href="http://www.eclipse.org/swt/snippets">snippets</a> provided by the
-    <a href="http://www.eclipse.org/swt">SWT project homepage</a>.
+    and <a href="http://www.eclipse.org/swt/snippets/">snippets</a> provided by the
+    <a href="http://www.eclipse.org/swt/">SWT project homepage</a>.
     A full reference specific to RWT can be found
     <a href="../reference/api/overview-summary.html">here</a>.
   </p>
@@ -180,7 +180,7 @@
       <a href="application-setup.html#compat">JEE compatibility mode</a>,
       opening a dialog does not block program execution.
       To obtain their return value, a callback must be registered using the RWT-specific class
-      <em><a href="../reference/api/org/eclipse/rwt/widgets/DialogUtil.html">DialogUtil</a></em>.
+      <em><a href="../reference/api/org/eclipse/rap/rwt/widgets/DialogUtil.html">DialogUtil</a></em>.
     </li>
 
     <li id="browser" style="margin-bottom:10px">
