diff --git a/src/packages/xdc/runtime/Assert.xml b/src/packages/xdc/runtime/Assert.xml
index 1c8ae7d..dddf29d 100644
--- a/src/packages/xdc/runtime/Assert.xml
+++ b/src/packages/xdc/runtime/Assert.xml
@@ -18,7 +18,7 @@
 <page>
 <html><body>
   <table>
-  <tr><td colspan="2">  <form><p>This module does not have any user settable configuration parameters.  For more information about this module, see the on-line reference documentation for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Assert.html">Assert module</a> in the xdc.runtime package.</p><p>For more information about the xdc.runtime package, see the <a href="http://rtsc.eclipseprojects.io/docs-tip/XDCtools_User%27s_Guide#The_xdc.runtime_package">xdc.runtime User's Guide</a> maintained in the <a href="http://rtsc.eclipseprojects.io/docs">RTSCpedia.</a></p></form></td></tr>
+  <tr><td colspan="2">  <form><p>This module does not have any user settable configuration parameters.  For more information about this module, see the on-line reference documentation for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Assert.html">Assert module</a> in the xdc.runtime package.</p><p>For more information about the xdc.runtime package, see the <a href="http://rtsc.eclipseprojects.io/docs-tip/XDCtools_User%27s_Guide#The_xdc.runtime_package">xdc.runtime User's Guide</a> maintained in the <a href="http://rtsc.eclipseprojects.io/docs">RTSCpedia.</a></p></form></td></tr>
   <tr><td colspan="2">
     <control type="checkbox" label="Add Assert to my configuration" value="value:this.$used" enabled="false" bold="true"/></td>
   </tr>
diff --git a/src/packages/xdc/runtime/Diags.xml b/src/packages/xdc/runtime/Diags.xml
index a4e756e..fc0e115 100644
--- a/src/packages/xdc/runtime/Diags.xml
+++ b/src/packages/xdc/runtime/Diags.xml
@@ -18,7 +18,7 @@
 <page>
 <html><body>
   <table>
-  <tr><td colspan="2">  <form><p>This module does not have any user settable configuration parameters.  For more information about this module, see the on-line reference documentation for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Diags.html">Diags module</a> in the xdc.runtime package.</p><p>For more information about the xdc.runtime package, see the <a href="http://rtsc.eclipseprojects.io/docs-tip/XDCtools_User%27s_Guide#The_xdc.runtime_package">xdc.runtime User's Guide</a> maintained in the <a href="http://rtsc.eclipseprojects.io/docs">RTSCpedia.</a></p></form></td></tr>
+  <tr><td colspan="2">  <form><p>This module does not have any user settable configuration parameters.  For more information about this module, see the on-line reference documentation for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Diags.html">Diags module</a> in the xdc.runtime package.</p><p>For more information about the xdc.runtime package, see the <a href="http://rtsc.eclipseprojects.io/docs-tip/XDCtools_User%27s_Guide#The_xdc.runtime_package">xdc.runtime User's Guide</a> maintained in the <a href="http://rtsc.eclipseprojects.io/docs">RTSCpedia.</a></p></form></td></tr>
   <tr><td colspan="2">
     <control type="checkbox" label="Add Diags to my configuration" value="value:this.$used" enabled="false" bold="true"/></td>
   </tr>
diff --git a/src/packages/xdc/runtime/GateNull.xml b/src/packages/xdc/runtime/GateNull.xml
index b576254..7525137 100644
--- a/src/packages/xdc/runtime/GateNull.xml
+++ b/src/packages/xdc/runtime/GateNull.xml
@@ -19,7 +19,7 @@
 <html><body><table>
   <tr>
       <td><form>
-        <p>An instance of this <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/IGateProvider.html">IGateProvider</a> implementation is assigned to all gated modules as a default module-wide gate.
+        <p>An instance of this <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/IGateProvider.html">IGateProvider</a> implementation is assigned to all gated modules as a default module-wide gate.
         Instances of this gate implementation provide no protection for critical sections and should only be used for modules in which the data structures protected by module-level gates are never accessed by concurrent threads.</p>
         <p> </p>
       </form></td>
diff --git a/src/packages/xdc/runtime/HeapMin.xml b/src/packages/xdc/runtime/HeapMin.xml
index 03387d2..174c65b 100644
--- a/src/packages/xdc/runtime/HeapMin.xml
+++ b/src/packages/xdc/runtime/HeapMin.xml
@@ -20,8 +20,8 @@
   <tr>
     <td>
       <form>
-        <p>The HeapMin module provides a minimal alloc-only heap manager that can be used with the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Memory.html">Memory</a> module.
-        In most cases, runtime allocation is handled by the <a href="ref:xdc.runtime.Memory">default heap</a> defined by the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Memory.html">Memory</a> module.</p>
+        <p>The HeapMin module provides a minimal alloc-only heap manager that can be used with the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Memory.html">Memory</a> module.
+        In most cases, runtime allocation is handled by the <a href="ref:xdc.runtime.Memory">default heap</a> defined by the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Memory.html">Memory</a> module.</p>
         <p> </p>
       </form>
     </td>
diff --git a/src/packages/xdc/runtime/HeapStd.xml b/src/packages/xdc/runtime/HeapStd.xml
index 95335c7..60ceba9 100644
--- a/src/packages/xdc/runtime/HeapStd.xml
+++ b/src/packages/xdc/runtime/HeapStd.xml
@@ -20,8 +20,8 @@
   <tr>
     <td>
       <form>
-        <p>The HeapStd module provides an ANSI C standard malloc()/free() based heap manager that can be used with the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Memory.html">Memory</a> module.
-        In most cases, runtime allocation is handled by the <a href="ref:xdc.runtime.Memory">default heap</a> defined by the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Memory.html">Memory</a> module.</p>
+        <p>The HeapStd module provides an ANSI C standard malloc()/free() based heap manager that can be used with the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Memory.html">Memory</a> module.
+        In most cases, runtime allocation is handled by the <a href="ref:xdc.runtime.Memory">default heap</a> defined by the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Memory.html">Memory</a> module.</p>
         <p> </p>
       </form>
     </td>
diff --git a/src/packages/xdc/runtime/Log.xml b/src/packages/xdc/runtime/Log.xml
index 1b68d9e..9750120 100644
--- a/src/packages/xdc/runtime/Log.xml
+++ b/src/packages/xdc/runtime/Log.xml
@@ -18,7 +18,7 @@
 <page>
 <html><body>
   <table>
-  <tr><td colspan="2">  <form><p>This module does not have any user settable configuration parameters.  For more information about this module, see the on-line reference documentation for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Log.html">Log module</a> in the xdc.runtime package.</p><p>For more information about the xdc.runtime package, see the <a href="http://rtsc.eclipseprojects.io/docs-tip/XDCtools_User%27s_Guide#The_xdc.runtime_package">xdc.runtime User's Guide</a> maintained in the <a href="http://rtsc.eclipseprojects.io/docs">RTSCpedia.</a></p></form></td></tr>
+  <tr><td colspan="2">  <form><p>This module does not have any user settable configuration parameters.  For more information about this module, see the on-line reference documentation for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Log.html">Log module</a> in the xdc.runtime package.</p><p>For more information about the xdc.runtime package, see the <a href="http://rtsc.eclipseprojects.io/docs-tip/XDCtools_User%27s_Guide#The_xdc.runtime_package">xdc.runtime User's Guide</a> maintained in the <a href="http://rtsc.eclipseprojects.io/docs">RTSCpedia.</a></p></form></td></tr>
   <tr><td colspan="2">
     <control type="checkbox" label="Add Log to my configuration" value="value:this.$used" enabled="false" bold="true"/></td>
   </tr>
diff --git a/src/packages/xdc/runtime/LoggerCallback.xml b/src/packages/xdc/runtime/LoggerCallback.xml
index 303e71f..e3cd459 100644
--- a/src/packages/xdc/runtime/LoggerCallback.xml
+++ b/src/packages/xdc/runtime/LoggerCallback.xml
@@ -24,7 +24,7 @@
     <td colspan="2">
     <h1>Description</h1>
       <form>
-        <p>The LoggerCallback module provides "back-end" support for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Log.html">Log</a> module. This module allows user to define C functions to support the handling of events from the Log module.  For more information see the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/LoggerCallback.html">LoggerCallback reference</a> documentation.</p>
+        <p>The LoggerCallback module provides "back-end" support for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Log.html">Log</a> module. This module allows user to define C functions to support the handling of events from the Log module.  For more information see the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/LoggerCallback.html">LoggerCallback reference</a> documentation.</p>
         <p> </p>
       </form>
     </td>
diff --git a/src/packages/xdc/runtime/Registry.xml b/src/packages/xdc/runtime/Registry.xml
index 87ecbca..cc18a39 100644
--- a/src/packages/xdc/runtime/Registry.xml
+++ b/src/packages/xdc/runtime/Registry.xml
@@ -18,7 +18,7 @@
 <page>
 <html><body>
   <table>
-  <tr><td colspan="2">  <form><p>This module does not have any user settable configuration parameters.  For more information about this module, see the on-line reference documentation for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Registry.html">Registry module</a> in the xdc.runtime package.</p><p>For more information about the xdc.runtime package, see the <a href="http://rtsc.eclipseprojects.io/docs-tip/XDCtools_User%27s_Guide#The_xdc.runtime_package">xdc.runtime User's Guide</a> maintained in the <a href="http://rtsc.eclipseprojects.io/docs">RTSCpedia.</a></p><p></p></form></td></tr>
+  <tr><td colspan="2">  <form><p>This module does not have any user settable configuration parameters.  For more information about this module, see the on-line reference documentation for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Registry.html">Registry module</a> in the xdc.runtime package.</p><p>For more information about the xdc.runtime package, see the <a href="http://rtsc.eclipseprojects.io/docs-tip/XDCtools_User%27s_Guide#The_xdc.runtime_package">xdc.runtime User's Guide</a> maintained in the <a href="http://rtsc.eclipseprojects.io/docs">RTSCpedia.</a></p><p></p></form></td></tr>
   <tr><td colspan="2">
     <control type="checkbox" label="Add Registry to my configuration" value="value:this.$used" bold="true"/></td>
   </tr>
diff --git a/src/packages/xdc/runtime/SysCallback.xml b/src/packages/xdc/runtime/SysCallback.xml
index 54fb854..fe93bdb 100644
--- a/src/packages/xdc/runtime/SysCallback.xml
+++ b/src/packages/xdc/runtime/SysCallback.xml
@@ -23,7 +23,7 @@
   <tr>
     <td colspan="2">
     <h1>Description</h1>
-    <form><p>The SysCallback module provides "back-end" support for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/System.html">System</a> module. This module allows user to define C callback functions to support the low level character output.  For more information see the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/SysCallback.html">SysCallback reference</a> documentation.</p></form>
+    <form><p>The SysCallback module provides "back-end" support for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/System.html">System</a> module. This module allows user to define C callback functions to support the low level character output.  For more information see the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/SysCallback.html">SysCallback reference</a> documentation.</p></form>
     </td>
   </tr>
   <tr>
diff --git a/src/packages/xdc/runtime/SysMin.xml b/src/packages/xdc/runtime/SysMin.xml
index 46d6cc4..f3979ed 100644
--- a/src/packages/xdc/runtime/SysMin.xml
+++ b/src/packages/xdc/runtime/SysMin.xml
@@ -20,7 +20,7 @@
   <tr>
     <td>
       <form>
-        <p>The SysMin module provides buffer-based "back-end" support for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/System.html">System</a> module.  This support only requires minimal ANSI C runtime support and a memory buffer large enough to hold the characters output via the System module's functions.
+        <p>The SysMin module provides buffer-based "back-end" support for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/System.html">System</a> module.  This support only requires minimal ANSI C runtime support and a memory buffer large enough to hold the characters output via the System module's functions.
         </p>
         <p> </p>
       </form>
diff --git a/src/packages/xdc/runtime/SysStd.xml b/src/packages/xdc/runtime/SysStd.xml
index dd6b74b..e627c4a 100644
--- a/src/packages/xdc/runtime/SysStd.xml
+++ b/src/packages/xdc/runtime/SysStd.xml
@@ -20,7 +20,7 @@
   <tr>
     <td>
       <form>
-        <p>The SysStd module provides "back-end" support for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/System.html">System</a> module.  This support relies on a small set of ANSI C standard runtime functions, such as putchar() and fflush(), to handle output produced by the System module's functions.
+        <p>The SysStd module provides "back-end" support for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/System.html">System</a> module.  This support relies on a small set of ANSI C standard runtime functions, such as putchar() and fflush(), to handle output produced by the System module's functions.
         </p>
         <p> </p>
       </form>
diff --git a/src/packages/xdc/runtime/TimestampNull.xml b/src/packages/xdc/runtime/TimestampNull.xml
index e79b828..be8d29f 100644
--- a/src/packages/xdc/runtime/TimestampNull.xml
+++ b/src/packages/xdc/runtime/TimestampNull.xml
@@ -18,7 +18,7 @@
 <page>
 <html><body>
   <table>
-    <tr><td colspan="2">  <form><p>This module provides time values for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Timestamp.html">Timestamp</a> module.  In this case, a constant 0 value is always returned.  This module is used to minimize code space and time overhead for configurations which do not need timestamps but use other modules that require a timestamp provider.</p><p></p></form></td></tr>
+    <tr><td colspan="2">  <form><p>This module provides time values for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Timestamp.html">Timestamp</a> module.  In this case, a constant 0 value is always returned.  This module is used to minimize code space and time overhead for configurations which do not need timestamps but use other modules that require a timestamp provider.</p><p></p></form></td></tr>
     <tr><td colspan="2">
       <control type="checkbox" label="Add TimestampNull to my configuration" value="value:this.$used" bold="true"/></td>
     </tr>
diff --git a/src/packages/xdc/runtime/TimestampStd.xml b/src/packages/xdc/runtime/TimestampStd.xml
index 25f61c0..6bf8275 100644
--- a/src/packages/xdc/runtime/TimestampStd.xml
+++ b/src/packages/xdc/runtime/TimestampStd.xml
@@ -18,7 +18,7 @@
 <page>
 <html><body>
   <table>
-    <tr><td colspan="2">  <form><p>This module provides time values for the <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/Timestamp.html">Timestamp</a> module.  In this case, the value from the ANSI C standard clock() function is always returned.</p><p></p></form></td></tr>
+    <tr><td colspan="2">  <form><p>This module provides time values for the <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/Timestamp.html">Timestamp</a> module.  In this case, the value from the ANSI C standard clock() function is always returned.</p><p></p></form></td></tr>
 
     <tr><td colspan="2">
       <control type="checkbox" label="Add TimestampStd to my configuration" value="value:this.$used" bold="true"/></td>
diff --git a/src/packages/xdc/runtime/knl/CacheSupportNull.xml b/src/packages/xdc/runtime/knl/CacheSupportNull.xml
index f5a991d..73fa00c 100644
--- a/src/packages/xdc/runtime/knl/CacheSupportNull.xml
+++ b/src/packages/xdc/runtime/knl/CacheSupportNull.xml
@@ -6,7 +6,7 @@
 <html><body><table>
   <tr>
       <td><form>
-        <p>Empty <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/ICacheSupport.html">ICacheSupport</a> implementation.</p>
+        <p>Empty <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/ICacheSupport.html">ICacheSupport</a> implementation.</p>
         <p> </p>
       </form></td>
   </tr>
diff --git a/src/packages/xdc/runtime/knl/GateH.xml b/src/packages/xdc/runtime/knl/GateH.xml
index 6cfd3d1..5de8f4f 100644
--- a/src/packages/xdc/runtime/knl/GateH.xml
+++ b/src/packages/xdc/runtime/knl/GateH.xml
@@ -9,9 +9,9 @@
       <td><form>
         <p>An application can isolate itself from IGate implementations by using this module.
 		   The application must first obtain an IGate.Handle. It can get such a handle by directly
-		   calling <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/GateThread.html#per-instance_creation"> GateThread.create </a>
+		   calling <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/GateThread.html#per-instance_creation"> GateThread.create </a>
 		   or
-		   <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/GateProcess.html#per-instance_creation"> GateProcess.create. </a>
+		   <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/GateProcess.html#per-instance_creation"> GateProcess.create. </a>
 		   Then the application can use the generic APIs provided by this module.</p>
         <p> </p>
       </form></td>
diff --git a/src/packages/xdc/runtime/knl/GateProcess.xml b/src/packages/xdc/runtime/knl/GateProcess.xml
index 13a4d85..9f3e28a 100644
--- a/src/packages/xdc/runtime/knl/GateProcess.xml
+++ b/src/packages/xdc/runtime/knl/GateProcess.xml
@@ -7,9 +7,9 @@
   <tr>
       <td><form>
         <p>This module provides services through its proxy
-		   <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/IGateProcessSupport.html"> IGateProcessSupport </a>         
+		   <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/IGateProcessSupport.html"> IGateProcessSupport </a>         
            interface. It has a module wide config parameter
-		   <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/GateProcess.html#.Proxy"> Proxy </a> 
+		   <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/GateProcess.html#.Proxy"> Proxy </a> 
 		   which needs to be bound to an OS specific delegate before this module can be used.</p>
         <p> </p>
       </form></td>
diff --git a/src/packages/xdc/runtime/knl/GateProcessSupportNull.xml b/src/packages/xdc/runtime/knl/GateProcessSupportNull.xml
index a732f78..5a5141e 100644
--- a/src/packages/xdc/runtime/knl/GateProcessSupportNull.xml
+++ b/src/packages/xdc/runtime/knl/GateProcessSupportNull.xml
@@ -6,7 +6,7 @@
 <html><body><table>
   <tr>
       <td><form>
-        <p>Empty <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/IGateProcessSupport.html">IGateProcessSupport</a> implementation.</p>
+        <p>Empty <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/IGateProcessSupport.html">IGateProcessSupport</a> implementation.</p>
         <p> </p>
       </form></td>
   </tr>
diff --git a/src/packages/xdc/runtime/knl/GateThread.xml b/src/packages/xdc/runtime/knl/GateThread.xml
index 3c12fcb..a181e9d 100644
--- a/src/packages/xdc/runtime/knl/GateThread.xml
+++ b/src/packages/xdc/runtime/knl/GateThread.xml
@@ -7,9 +7,9 @@
   <tr>
       <td><form>
         <p>This module provides services through its proxy
-         <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/IGateThreadSupport.html"> IGateThreadSupport </a>        
+         <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/IGateThreadSupport.html"> IGateThreadSupport </a>        
           interface. It has a module wide config parameter
-         <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/GateThread.html#.Proxy"> Proxy </a>
+         <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/GateThread.html#.Proxy"> Proxy </a>
           which needs to be bound to an OS specific delegate before this module can be used.</p>
         <p> </p>
       </form></td>
diff --git a/src/packages/xdc/runtime/knl/GateThreadSupportNull.xml b/src/packages/xdc/runtime/knl/GateThreadSupportNull.xml
index 113a3e6..569a905 100644
--- a/src/packages/xdc/runtime/knl/GateThreadSupportNull.xml
+++ b/src/packages/xdc/runtime/knl/GateThreadSupportNull.xml
@@ -6,7 +6,7 @@
 <html><body><table>
   <tr>
       <td><form>
-        <p>Empty <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/IGateThreadSupport.html">IGateThreadSupport</a> implementation.</p>
+        <p>Empty <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/IGateThreadSupport.html">IGateThreadSupport</a> implementation.</p>
         <p> </p>
       </form></td>
   </tr>
diff --git a/src/packages/xdc/runtime/knl/SemProcess.xml b/src/packages/xdc/runtime/knl/SemProcess.xml
index 2075472..7474d9f 100644
--- a/src/packages/xdc/runtime/knl/SemProcess.xml
+++ b/src/packages/xdc/runtime/knl/SemProcess.xml
@@ -7,9 +7,9 @@
   <tr>
       <td><form>
         <p>This module manages multi-process semaphores through its proxy
-           <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/ISemProcessSupport.html"> ISemProcessSupport  </a>                   
+           <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/ISemProcessSupport.html"> ISemProcessSupport  </a>                   
            interface. It has a module wide config parameter 
-           <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/SemProcess.html#.Proxy"> Proxy </a>           
+           <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/SemProcess.html#.Proxy"> Proxy </a>           
            which needs to be bound to an OS specific delegate before 
            this module can be used.</p>
         <p> </p>
diff --git a/src/packages/xdc/runtime/knl/SemThread.xml b/src/packages/xdc/runtime/knl/SemThread.xml
index 8c39de0..a3e21e6 100644
--- a/src/packages/xdc/runtime/knl/SemThread.xml
+++ b/src/packages/xdc/runtime/knl/SemThread.xml
@@ -7,9 +7,9 @@
   <tr>
       <td><form>
         <p>This module manages semaphores through its proxy
-           <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/ISemThreadSupport.html"> ISemThreadSupport </a>
+           <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/ISemThreadSupport.html"> ISemThreadSupport </a>
            interface. It has a module wide config parameter
-           <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/SemThread.html#.Proxy"> Proxy </a>
+           <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/SemThread.html#.Proxy"> Proxy </a>
            which needs to be bound to an OS specific delegate before this module can be used.</p>
         <p> </p>
       </form></td>
diff --git a/src/packages/xdc/runtime/knl/Semaphore.xml b/src/packages/xdc/runtime/knl/Semaphore.xml
index 68bf83d..5a7f4f7 100644
--- a/src/packages/xdc/runtime/knl/Semaphore.xml
+++ b/src/packages/xdc/runtime/knl/Semaphore.xml
@@ -9,9 +9,9 @@
         <p>An application can isolate itself from ISemaphore implementations by using
            this module. The application must first obtain an ISemaphore.Handle.
            It make get such a handle by directly calling
-           <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/SemThread.html#per-instance_creation"> SemThread.create </a>
+           <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/SemThread.html#per-instance_creation"> SemThread.create </a>
            or
-           <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/SemProcess.html#per-instance_creation"> SemProcess.create </a>
+           <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/SemProcess.html#per-instance_creation"> SemProcess.create </a>
            Then the application can use the generic APIs provided by this module.</p>
         <p> </p>
       </form></td>
diff --git a/src/packages/xdc/runtime/knl/Sync.xml b/src/packages/xdc/runtime/knl/Sync.xml
index 27cf70f..42c46ad 100644
--- a/src/packages/xdc/runtime/knl/Sync.xml
+++ b/src/packages/xdc/runtime/knl/Sync.xml
@@ -7,9 +7,9 @@
   <tr>
       <td><form>
         <p>The application must first obtain an ISync.Handle. It can get such a handle by directly calling
-		   calling <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/SyncGeneric.html#per-instance_creation"> SyncGeneric.create </a>
+		   calling <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/SyncGeneric.html#per-instance_creation"> SyncGeneric.create </a>
 		   or
-		   <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/SyncSemThread.html#per-instance_creation"> SyncSemThread.create. </a>
+		   <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/SyncSemThread.html#per-instance_creation"> SyncSemThread.create. </a>
            Then the application can use the generic APIs provided by this module.</p>
         <p> </p>
       </form></td>
diff --git a/src/packages/xdc/runtime/knl/SyncGeneric.xml b/src/packages/xdc/runtime/knl/SyncGeneric.xml
index 885cfd0..2ff1739 100644
--- a/src/packages/xdc/runtime/knl/SyncGeneric.xml
+++ b/src/packages/xdc/runtime/knl/SyncGeneric.xml
@@ -17,7 +17,7 @@
 
 <page name="Module" title="Module Settings">
 <html><body><table>
-    <tr><td colspan="2">  <form><p>Instances of this module provide basic synchronization between threads calling the wait() and signal() functions define by the  <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/Sync.html">Sync</a> module.</p><p></p></form></td></tr>
+    <tr><td colspan="2">  <form><p>Instances of this module provide basic synchronization between threads calling the wait() and signal() functions define by the  <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/Sync.html">Sync</a> module.</p><p></p></form></td></tr>
     <tr><td colspan="2">
       <control type="checkbox" label="Add SyncGeneric to my configuration" value="value:this.$used" bold="true"/></td>
     </tr>
diff --git a/src/packages/xdc/runtime/knl/SyncNull.xml b/src/packages/xdc/runtime/knl/SyncNull.xml
index 4fe35cd..002e644 100644
--- a/src/packages/xdc/runtime/knl/SyncNull.xml
+++ b/src/packages/xdc/runtime/knl/SyncNull.xml
@@ -18,7 +18,7 @@
 <page>
 <html><body>
   <table>
-    <tr><td colspan="2">  <form><p>Instances of this module provide basic synchronization between threads calling the wait() and signal() functions defined by the  <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/Sync.html">Sync</a> module.  In this case, clients of wait() always timeout.  This module is used to minimize code space and time overhead for configurations which do not need synchronization but use other modules that require some synchronization provider.</p><p></p></form></td></tr>
+    <tr><td colspan="2">  <form><p>Instances of this module provide basic synchronization between threads calling the wait() and signal() functions defined by the  <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/Sync.html">Sync</a> module.  In this case, clients of wait() always timeout.  This module is used to minimize code space and time overhead for configurations which do not need synchronization but use other modules that require some synchronization provider.</p><p></p></form></td></tr>
     <tr><td colspan="2">
       <control type="checkbox" label="Add SyncNull to my configuration" value="value:this.$used" bold="true"/></td>
     </tr>
diff --git a/src/packages/xdc/runtime/knl/Thread.xml b/src/packages/xdc/runtime/knl/Thread.xml
index b4ddbdb..1ee3aac 100644
--- a/src/packages/xdc/runtime/knl/Thread.xml
+++ b/src/packages/xdc/runtime/knl/Thread.xml
@@ -7,9 +7,9 @@
   <tr>
       <td><form>
         <p>This module manages threads through a proxy which inherits from
-		   <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/IThreadSupport.html"> IThreadSupport </a>         
+		   <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/IThreadSupport.html"> IThreadSupport </a>         
            interface. It has a module wide config parameter 
-		   <a href="http://rtsc.eclipse.org/cdoc-tip/index.html#xdc/runtime/knl/Thread.html#.Proxy"> Proxy </a> 
+		   <a href="http://rtsc.eclipseprojects.io/cdoc-tip/index.html#xdc/runtime/knl/Thread.html#.Proxy"> Proxy </a> 
            which needs to be bound to an OS specific delegate before this module can be used.</p>
         <p> </p>
       </form></td>
