diff --git a/_includes/footer.html b/_includes/footer.html
index 386f51d..ad4369c 100644
--- a/_includes/footer.html
+++ b/_includes/footer.html
@@ -1,22 +1,22 @@
     <footer class="footer">
       <div class="container">
         <p class="pull-right" style="clear: right"><iframe class="github-btn" src="http://ghbtns.com/github-btn.html?user=haskell-distributed&repo=distributed-process&type=watch&count=true" allowtransparency="true" frameborder="0" scrolling="0" width="100px" height="20px"></iframe></p>
-        <p>&copy; 2012 - 2013 <a href="http://twitter.com/welltyped">Well-Typed</a>
+        <p>&copy; 2012 - 2017 <a href="http://twitter.com/welltyped">Well-Typed</a>
             - <a href="http://twitter.com/CloudHaskell" target="_blank">CloudHaskell</a>
             - <a href="https://github.com/hyperthunk" target="_blank">Tim Watson</a>
         </p>
-        <p class="pull-right" style="clear: right"><iframe class="github-btn" src="http://ghbtns.com/github-btn.html?user=haskell-distributed&repo=distributed-process-platform&type=fork&count=true" allowtransparency="true" frameborder="0" scrolling="0" width="102px" height="20px"></iframe></p>
+        <p class="pull-right" style="clear: right"><iframe class="github-btn" src="http://ghbtns.com/github-btn.html?user=haskell-distributed&repo=distributed-process&type=fork&count=true" allowtransparency="true" frameborder="0" scrolling="0" width="102px" height="20px"></iframe></p>
         <p><a href="http://github.com/haskell-distributed">Code</a> licensed under <a href="https://github.com/haskell-distributed/distributed-process/blob/master/LICENSE" target="_blank">BSD-3</a>,
         </p>
         <p>
-            Website design shamelessly derived from <a href="https://twitter.com/kmett">Edward Kmett's'</a> 
+            Website design shamelessly derived from <a href="https://twitter.com/kmett">Edward Kmett's'</a>
             <a href="http://lens.github.com/">lens library github pages</a> under <a href="http://creativecommons.org/licenses/by/3.0/">CC BY 3.0</a>.
         </p>
         <p class="pull-right" style="clear: right; margin-right: -2px">
             <a href="https://twitter.com/CloudHaskell" class="twitter-follow-button" data-link-color="#0069D6" data-show-count="true">Follow @CloudHaskell</a>
         </p>
         <p><a href="http://glyphicons.com">Glyphicons</a> and <a href="http://www.vectorportal.com/">Vectorportal</a> images reproduced with permission.</p>
-        <p class="pull-right" style="clear: right"><!-- TODO: build status 
+        <p class="pull-right" style="clear: right"><!-- TODO: build status
         --></p>
 
         <ul class="footer-links">
diff --git a/_includes/nav.html b/_includes/nav.html
index 2fa93b1..4e45e25 100644
--- a/_includes/nav.html
+++ b/_includes/nav.html
@@ -32,7 +32,6 @@
                 </a>
                 <ul class="dropdown-menu">
                    <li><a href="/wiki.html">Wiki</a></li>
-                   <li><a href="/changes.html">ChangeLog</a></li>
                    <li><a href="http://www.haskell.org/haskellwiki/Cloud_Haskell">CH on haskell.org</a></li>
                    <li><a href="https://github.com/haskell-distributed">Github Repositories</a></li>
                    <li><a href="/static/semantics.pdf">Formal Semantics</a></li>
diff --git a/_layouts/changelog.html b/_layouts/changelog.html
deleted file mode 100644
index be8f132..0000000
--- a/_layouts/changelog.html
+++ /dev/null
@@ -1,59 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    {% include head.html %}
-    <style>
-      body { padding-top: 0px; }
-     .navbar-fixed-top { position: relative !important; }
-    </style>
-    <link href="/css/sidenav.css" rel="stylesheet">
-  </head>
-  <body data-spy="scroll" data-target=".sidebar"> <!-- data-offset-top="10">-->
-    {% include nav.html %}
-    <div class="container">
-      <ul class="breadcrumb">
-        <li><a href="/">Home</a> <span class="divider">/</span></li>
-        <li><a href="/changes.html">Changelog</a> <span class="divider">/</span></li>
-        <li><a href="">{{ page.project }}-{{ page.version}}</a> <spawn class="divider">/</span></li>
-      </ul>
-    </div>
-    <div class="container">
-      <div class="row">
-        <div class="span3 sidebar">
-          <div data-spy="affix" data-offset-bottom="290">
-            <ul class="nav nav-list sidenav">
-            {% for page in site.pages %}
-                {% if page.url contains '/changelog/' %}
-                    <li><a href="{{ page.url }}">{{ page.project }}-{{ page.version }}</a></li>
-                {% endif %}
-            {% endfor %}
-           </ul>
-          </div>
-        </div>
-        <div class="span9">
-          <h4>Version <a href="https://cloud-haskell.atlassian.net/browse/{{ page.code }}/fixforversion/{{ page.release }}">{{ page.version }}</a></h4>
-          <h4>Status: {% if page.status contains 'Released' %}
-                          <a href="https://hackage.haskell.org/package/{{ page.project }}-{{ page.version }}">{{ page.status }}</a>
-                      {% else %}
-                          Pending Release
-                      {% endif %}
-          </h4>
-          <h4>Due/Released: {{ page.date }}</h4>
-          <h4><a href="https://github.com/haskell-distributed/{{ page.project }}/compare/{{ page.commits }}">Code Changes (redirects to github)</a></h4>
-          {{ content }}
-          
-          <a href="https://cloud-haskell.atlassian.net/sr/jira.issueviews:searchrequest-rss/temp/SearchRequest.xml?jqlQuery=project+%3D+DP+AND+status+%3D+Closed+AND+fixVersion+%3D+{{ page.version }}&tempMax=1000"><h5>Issue RSS Feed</h5></a>
-        </div>
-        <!--
-        <div class="span9">
-            <h4>Upgrading</h4>
-            TODO: some generic advice about upgrading??
-        </div>
-        -->
-      </div>
-    </div>
-    {% include footer.html %}
-    {% include js.html %}
-  </body>
-</html>
-
diff --git a/_layouts/changes.html b/_layouts/changes.html
deleted file mode 100644
index f4fd013..0000000
--- a/_layouts/changes.html
+++ /dev/null
@@ -1,53 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    {% include head.html %}
-    <style>
-      body { padding-top: 0px; }
-     .navbar-fixed-top { position: relative !important; }
-    </style>
-    <link href="/css/sidenav.css" rel="stylesheet">
-  </head>
-  <body data-spy="scroll" data-target=".sidebar"> <!-- data-offset-top="10">-->
-    {% include nav.html %}
-    <div class="container">
-      <ul class="breadcrumb">
-        <li><a href="/">Home</a> <span class="divider">/</span></li>
-        <li><a href="/changes.html">Changes</a> <span class="divider">/</span></li>
-      </ul>
-    </div>
-    <div class="container">
-      <div class="row">
-        <div class="span3 sidebar">
-          <div data-spy="affix" data-offset-bottom="290">
-            <ul class="nav nav-list sidenav">
-                <li>
-                    <h4>Beta 2 (29 May 2014)</h4>
-                    <ul>
-                        <li><a href="/changelog/dpp-0.1.0.html">distributed-process-platform-0.1.0</a></li>
-                        <li><a href="/changelog/dp-0.5.0.html">distributed-process-0.5.0</a></li>
-                        <li><a href="/changelog/nt-0.4.0.0.html">network-transport-0.4.0.0</a></li>
-                        <li><a href="/changelog/ds-0.3.0.0.html">distributed-static-0.3.0.0</a></li>
-                        <li><a href="/changelog/rd-0.2.0.0.html">rank1dynamic-0.2.0.0</a></li>
-                    </ul>
-                </li>
-                <li>
-                    <h4>Beta 1 (27 Jan 2013)</h4>
-                    <ul>
-                        <li><a href="/changelog/dp-0.4.1.html">distributed-process-0.4.1</a></li>
-                        <li><a href="/changelog/dp-0.4.2.html">distributed-process-0.4.2</a></li>
-                    </ul>
-                </li>
-           </ul>
-          </div>
-        </div>
-        <div class="span9">
-          {{ content }}
-        </div>
-      </div>
-    </div>
-    {% include footer.html %}
-    {% include js.html %}
-  </body>
-</html>
-
diff --git a/changelog/dp-0.4.1.md b/changelog/dp-0.4.1.md
deleted file mode 100644
index d7213ca..0000000
--- a/changelog/dp-0.4.1.md
+++ /dev/null
@@ -1,23 +0,0 @@
----
-layout: changelog
-code: DP
-project: distributed-process
-title: distributed-process-0.4.1
-date: 27-01-2013
-status: Released
-version: 0.4.1
-commits: distributed-process-0.4.0.2...distributed-process-0.4.1
----
-
-### Notes
-
-This is a small feature release containing various enhancements.
-
-#### Improvements
-
-* [Update package boundaries](https://github.com/haskell-distributed/distributed-process/commit/a5faffd)
-* [depend on binary-0.6 instead of 0.5](https://github.com/haskell-distributed/distributed-process/commit/0f03091)
-* [Require http-conduit gt 1.8.1](https://github.com/haskell-distributed/distributed-process/commit/294e873)
-* [Implement receiveChanTimeout](https://github.com/haskell-distributed/distributed-process/commit/8b95ef1)
-* [Changed semantics of register/unregister to match Erlang](https://github.com/haskell-distributed/distributed-process/commit/37b0263)
-* [Fixed de-registration of remote processes when the process terminates](https://github.com/haskell-distributed/distributed-process/commit/24163c2)
diff --git a/changelog/dp-0.4.2.md b/changelog/dp-0.4.2.md
deleted file mode 100644
index 76e8f0f..0000000
--- a/changelog/dp-0.4.2.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-layout: changelog
-code: DP
-project: distributed-process
-date: 27-01-2013
-status: Released
-version: 0.4.2
-commits: distributed-process-0.4.1...v0.4.2
-release: 10006
----
-
-### Notes
-
-This is a small feature release containing process management enhancements and
-a new tracing/debugging capability.
-
-#### Bugs
-
-* [DP-60](https://cloud-haskell.atlassian.net/browse/DP-60) - Fixes made for the distributed-process with strict bytestrings
-
-#### Improvements
-
-* [DP-61](https://cloud-haskell.atlassian.net/browse/DP-61) - Switched from Binary to cereal, allowed switching between lazy and strict ByteString
-* [DP-31](https://cloud-haskell.atlassian.net/browse/DP-31) - Messages from the &quot;main channel&quot; as a receivePort
-* [DP-35](https://cloud-haskell.atlassian.net/browse/DP-35) - Add variants of exit and kill for the current process
-* [DP-50](https://cloud-haskell.atlassian.net/browse/DP-50) - Support for killing processes
-* [DP-51](https://cloud-haskell.atlassian.net/browse/DP-51) - provide local versions of spawnLink and spawnMonitor
-* [DP-13](https://cloud-haskell.atlassian.net/browse/DP-13) - Tracing and Debugging support]
diff --git a/changelog/dp-0.5.0.md b/changelog/dp-0.5.0.md
deleted file mode 100644
index 77516c4..0000000
--- a/changelog/dp-0.5.0.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-layout: changelog
-code: DP
-project: distributed-process
-status: Released
-date: 28-05-2014
-version: 0.5.0
-commits: distributed-process-0.4.2...v0.5.0
-release: 10008
----
-
-### Notes
-
-This is a full feature release containing important enhancements to inter-process messaging,
-process and node management, debugging and tracing. Various bug-fixes have also been made.
-
-#### Highlights
-
-New advanced messaging APIs provide broader polymorphic primitives for receiving and processing message
-regardless of the underlying (when decoded) types. Extended exit handling capabilities have been added,
-to facilitate processing *exit signals* when the *exit reason* could be represented by a variety of
-underlying types.
-
-The performance of inter-process messaging has been optimised for intra-node use cases. Messages are no
-longer sent over the network-transport infrastructure when the receiving process resides on the same node
-as the sender. New unsafe APIs have been made available to allow code that uses intra-node messaging to
-skip the serialization of messages, facilitating further performance benefits at the risk of altered
-error handling semantics. More details are available in the [UnsafePrimitives documentation][1].
-
-A new [Management API][2] has been added, giving user code the ability to receive and respond to a running
-node's internal system events. The tracing and debugging support added in 0.4.2 has been [upgraded][3] to use
-this API, which is more efficient and flexible.
-
-#### Bugs
-
-* [DP-68](https://cloud-haskell.atlassian.net/browse/DP-68) - Dependency on STM implicitly changed from 1.3 to 1.4, but was not reflected in the cabal file
-* [DP-79](https://cloud-haskell.atlassian.net/browse/DP-79) - Race condition in local monitoring when using call
-* [DP-94](https://cloud-haskell.atlassian.net/browse/DP-94) - mask does not work correctly if unmask is called by another process
-
-#### Improvements
-
-* [DP-20](https://cloud-haskell.atlassian.net/browse/DP-20) - Improve efficiency of local message passing
-* [DP-77](https://cloud-haskell.atlassian.net/browse/DP-77) - nsend should use local communication channels
-* [DP-39](https://cloud-haskell.atlassian.net/browse/DP-39) - Link Node Controller and Network Listener
-* [DP-62](https://cloud-haskell.atlassian.net/browse/DP-62) - Label spawned processes using labelThread
-* [DP-85](https://cloud-haskell.atlassian.net/browse/DP-85) - Relax upper bound on syb in the cabal manifest
-* [DP-78](https://cloud-haskell.atlassian.net/browse/DP-78) - Bump binary version to include 0.7.*
-* [DP-92](https://cloud-haskell.atlassian.net/browse/DP-92) - Expose process info
-* [DP-92](https://cloud-haskell.atlassian.net/browse/DP-92) - Expose node statistics
-* [DP-91](https://cloud-haskell.atlassian.net/browse/DP-91) - Move tests to https://github.com/haskell-distributed/distributed-process-tests
-
-#### New Features
-
-* [DP-7](https://cloud-haskell.atlassian.net/browse/DP-7) - Polymorphic expect, see details [here](https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process.html#g:5)
-* [DP-57](https://cloud-haskell.atlassian.net/browse/DP-57) - Expose Message type and broaden scope of polymorphic expect
-* [DP-84](https://cloud-haskell.atlassian.net/browse/DP-84) - Management API (for working with internal/system events)
-* [DP-83](https://cloud-haskell.atlassian.net/browse/DP-83) - Report node statistics for monitoring/management
-
-[1]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-UnsafePrimitives.html
-[2]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Management.html
-[3]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Debug.html
diff --git a/changelog/dpp-0.1.0.md b/changelog/dpp-0.1.0.md
deleted file mode 100644
index 3a19471..0000000
--- a/changelog/dpp-0.1.0.md
+++ /dev/null
@@ -1,83 +0,0 @@
----
-layout: changelog
-code: DPP
-project: distributed-process-platform
-status: Released
-date: 28-05-2014
-version: 0.5.0
-commits: b3dee891...master
-release: 10003
----
-
-### Notes / Highlights
-
-This is the first release of distributed-process-platform.
-Modelled after Erlang's OTP, this framework provides similar
-facilities for Cloud Haskell, grouping essential practices
-into a set of modules and standards designed to help you build
-concurrent, distributed applications with relative ease.
-
-#### Highlights
-
-* [UnsafePrimitives][2] - Extended version of the [UnsafePrimitives module from distributed-process][1]
-* [Time][3] - API for working with time delays and timeouts
-* [Timer][4] - Timer API (for running code or sending messages based on timers)
-* [Async][21] - API for spawning asynchronous operations, waiting for results, cancelling, etc
-* [Async - STM][22] - Async implementation built on STM
-* [Async - Chan][23] - Async implementation built on Typed Channels
-* [Managed Processes][5] - Build complex 'Processes' by abstracting out management of the process' mailbox, reply/response handling, timeouts, process hiberation, error handling and shutdown/stop procedures
-* [Managed Processes - Prioritised Mailbox][6] - Prioritised Message Processing
-* [Managed Processes - Restricted Execution][7] - Restricted (pure) execution environment
-* [Managed Processes - Client API][8] - Client facing `ManagedProcess` API
-* [Managed Processes - Unsafe Clients][9] - Unsafe client API
-* [Process Supervision][10] - A generic API for supervising trees of managed processes
-* [Execution Framework][11] - Framework for managing non-functional implementation aspects such as load regulation
-* [Execution - Buffers][12] - Mailbox bounding and buffering
-* [Execution - Routing][13] - The "exchange" message routing pattern
-* [Execution - Event Handling][14] - Generic *event handling* mechanism
-* [Task Framework][15] - Task management, work scheduling and execution management
-* [Task Framework - Queues][16] - Bounded (i.e., blocking) work queues
-* [Service Framework][17] - Framework for developing re-usable service components
-* [Service - Monitoring][18] - Node monitoring API
-* [Service - Registry][19] - General Purpose Extended Process Registry
-* [Service - System Log][20] - Extensible System Logging Capability
-
-#### Improvements / New Features
-
-* [DPP-68](https://cloud-haskell.atlassian.net/browse/DPP-68) - a variant of `link` that only signals in case of abnormal termination
-* [DPP-4](https://cloud-haskell.atlassian.net/browse/DPP-4) - Managed Processes (aka gen-server)
-* [DPP-74](https://cloud-haskell.atlassian.net/browse/DPP-74) - Priority Queue based Managed Process
-* [DPP-71](https://cloud-haskell.atlassian.net/browse/DPP-71) - ManagedProcess API consistency
-* [DPP-7](https://cloud-haskell.atlassian.net/browse/DPP-7) - Channel vs Process based GenServer
-* [DPP-1](https://cloud-haskell.atlassian.net/browse/DPP-1) - Supervision trees
-* [DPP-79](https://cloud-haskell.atlassian.net/browse/DPP-79) - Add support for Akka-style routers
-* [DPP-81](https://cloud-haskell.atlassian.net/browse/DPP-81) - Have two Supervisor.ChildSpec constructors, one for RemoteChild (current one) and one for LocalChild 
-
-#### Bugs
-
-Since this is the first release, see [github](https://github.com/haskell-distributed/distributed-process-platform/commits) for
-a view on bugs that have been filed and fixed during the development process.
-
-[1]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-UnsafePrimitives.html
-[2]: https://hackage.haskell.org/package/distributed-process-platform-0.1.0/docs/Control-Distributed-Process-Platform-UnsafePrimitives.html
-[3]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Time.html
-[4]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Timer.html
-[5]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-ManagedProcess.html
-[6]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-ManagedProcess-Server-Priority.html
-[7]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-ManagedProcess-Server-Restricted.html
-[8]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-ManagedProcess-Client.html
-[9]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-ManagedProcess-UnsafeClient.html
-[10]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Supervisor.html
-[11]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Execution.html
-[12]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Execution-Mailbox.html
-[13]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Execution-Exchange.html
-[14]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Execution-EventManager.html
-[15]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Task.html
-[16]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Task=Queue-BlockingQueue.html
-[17]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Service.html
-[18]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Service-Monitoring.html
-[19]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Service-Registry.html
-[20]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Service-SystemLog.html
-[21]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Async.html
-[22]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Async-AsyncSTM.html
-[23]: https://hackage.haskell.org/package/distributed-process-0.5.0/docs/Control-Distributed-Process-Platform-Async-AsyncChan.html
diff --git a/changelog/ds-0.3.0.0.md b/changelog/ds-0.3.0.0.md
deleted file mode 100644
index 2abd1b8..0000000
--- a/changelog/ds-0.3.0.0.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-layout: changelog
-code: DS
-title: distributed-static-0.3.0.0
-date: 28-01-2013
-status: Released
-version: 0.3.0.0
-commits: distributed-static-0.2.1.1...v0.3.0.0
----
-
-### Notes
-
-Minor improvements to support the latest cloud haskell.
-
-#### Bug Fixes
-
-* [DS-3](https://cloud-haskell.atlassian.net/browse/DS-3) - Bump binary dependency
diff --git a/changelog/nt-0.4.0.0.md b/changelog/nt-0.4.0.0.md
deleted file mode 100644
index 545eacd..0000000
--- a/changelog/nt-0.4.0.0.md
+++ /dev/null
@@ -1,24 +0,0 @@
----
-layout: changelog
-code: NT
-project: network-transport
-date: 28-01-2013
-status: Released
-version: 0.4.0.0
-commits: network-transport-0.3.0.1...v0.4.0.0
----
-
-### Notes
-
-Minor improvements to support the latest cloud haskell.
-
-#### Bug Fixes
-
-* [62171](https://github.com/haskell-distributed/network-transport/commit/6217173abd87c55e5c34565931b5ba41d729fe62) - Fix build for GHC 7.4 - thanks mboes!
-* [5d0aa](https://github.com/haskell-distributed/network-transport/commit/5d0aacf421031eb155122d3381b1b401cd59f477) - Allow transformers above v5
-* [NT-7](https://cloud-haskell.atlassian.net/browse/NT-7) - Bump binary version to include 0.7.*
-
-#### Improvements
-
-* [44672](https://github.com/haskell-distributed/network-transport/commit/44672be03c9d0d66926416fdac23555477f99229) - Binary instance for 'Reliability' - thanks mboes!
-* [9c5d0c](https://github.com/haskell-distributed/network-transport/commit/9c5d0c7f84d59eae72075c4e327e3b7b7954f5aa) - Hashable instance for 'EndPointAddress'
diff --git a/changelog/rd-0.2.0.0.md b/changelog/rd-0.2.0.0.md
deleted file mode 100644
index 77567b4..0000000
--- a/changelog/rd-0.2.0.0.md
+++ /dev/null
@@ -1,19 +0,0 @@
----
-layout: changelog
-code: RANKNDYN
-project: rank1dynamic
-date: 28-01-2013
-status: Released
-version: 0.2.0.0
-commits: rank1dynamic-0.1.0.2...v0.2.0.0
----
-
-### Notes
-
-This is a bug fix release.
-
-#### Improvements
-
-* [RANKNDYN-3](https://cloud-haskell.atlassian.net/browse/RANKNDYN-3) - Fix funResultTy so @funResultTy ANY _ = ANY@
-* [PR4](https://github.com/haskell-distributed/rank1dynamic/pull/4) - Ensure the result of funResultTy is consistent with unification
-* [RANKNDYN-2](https://cloud-haskell.atlassian.net/browse/RANKNDYN-2) - Bump binary version to include 0.7.*
diff --git a/documentation.md b/documentation.md
index 0279619..004c76d 100644
--- a/documentation.md
+++ b/documentation.md
@@ -28,12 +28,25 @@ on Cloud Haskell and this reimplementation, which is worth reading in conjunctio
 with the documentation and wiki pages on this website..
 
 Cloud Haskell comprises the following components, some of which are complete,
-others experimental.
+others experimental. There are three main parts:
 
-* [distributed-process][distributed-process]: Base concurrency and distribution support
-* [distributed-process-platform][distributed-process-platform]: The Cloud Haskell Platform - APIs
+#### The core libraries
+
+* [distributed-process][distributed-process]: Base concurrency and distribution support. It provides a number of primitives known from Erlang like `link` and `monitor`.
 * [distributed-static][distributed-static]: Support for static values
 * [rank1dynamic][rank1dynamic]: Like `Data.Dynamic` and `Data.Typeable` but supporting polymorphic values
+
+#### The platform libraries
+
+* [distributed-process-client-server][distributed-process-client-server]: Common client/server patterns like Erlang's `gen_server`
+* [distributed-process-async][distributed-process-async]: Future-style computations
+* [distributed-process-task][distributed-process-task]: A worker queue
+* [distributed-process-extras][distributed-process-extras]: Monitoring, logging, resolving names etc.
+* [distributed-process-registry][distributed-process-registry]: A key-value registry
+* [distributed-process-execution][distributed-process-execution]: Load regulation, work shedding, hand-off etc.
+
+#### The network layer
+
 * [network-transport][network-transport]: Generic `Network.Transport` API
 * [network-transport-tcp][network-transport-tcp]: TCP realisation of `Network.Transport`
 * [network-transport-inmemory][network-transport-inmemory]: In-memory realisation of `Network.Transport` (incomplete)
@@ -319,19 +332,19 @@ is managed in the *process layer*, whilst a higher level API described as the
 * data centric processing model
 * a promise (or *future*) abstraction, representing the result of a calculation that may or may not have yet completed
 
-The [distributed-process-platform][distributed-process-platform] library implements parts of the
+The [distributed-process-task][distributed-process-task] library implements parts of the
 *task layer*, but takes a very different approach to that described
 in the original paper and implemented by the [remote][remote] package. In particular,
 we diverge from the original design and defer to many of the principles
 defined by Erlang's [Open Telecom Platform][OTP], taking in some well established
 Haskell concurrency design patterns along the way.
 
-In fact, [distributed-process-platform][distributed-process-platform] does not really consider the
+In fact, [distributed-process-async][distributed-process-async] does not really consider the
 *task layer* in great detail. We provide an API comparable to remote's
-`Promise` in `Control.Distributed.Process.Platform.Async`. This API however,
+`Promise` in `Control.Distributed.Process.Async`. This API however,
 is derived from Simon Marlow's [Control.Concurrent.Async][async] package, and is not
 limited to blocking queries on `Async` handles in the same way. Instead our
-[API][d-p-platform-async] handles both blocking and non-blocking queries, polling
+[API][d-p-async-async] handles both blocking and non-blocking queries, polling
 and working with lists of `Async` handles. We also eschew throwing exceptions
 to indicate asynchronous task failures, instead handling *task* and connectivity
 failures using monitors. Users of the API need only concern themselves with the
@@ -388,7 +401,7 @@ Work is also underway to provide abstractions for managing asynchronous tasks
 at a higher level, focussing on workload distribution and load regulation.
 
 The kinds of task that can be performed by the async implementations in
-[distributed-process-platform][distributed-process-platform] are limited only by their return type:
+[distributed-process-async][distributed-process-async] are limited only by their return type:
 it **must** be `Serializable` - that much should've been obvious by now.
 The type of asynchronous task definitions comes in two flavours, one for
 local nodes which require no remote-table or static serialisation dictionary,
@@ -427,14 +440,14 @@ domain was more *haskell-ish* than working with bare send and receive primitives
 The `Async` sub-package also provides a type safe interface for receiving data,
 although it is limited to running a computation and waiting for its result.
 
-The [Control.Distributed.Processes.Platform.ManagedProcess][d-p-platform-ManagedProcess] API provides a
+The [Control.Distributed.Processes.Platform.ManagedProcess][d-p-client-server-ManagedProcess] API provides a
 number of different abstractions that can be used to achieve similar benefits
 in your code. It works by introducing a standard protocol between your process
 and the *world outside*, which governs how to handle request/reply processing,
 exit signals, timeouts, sleeping/hibernation with `threadDelay` and even provides
 hooks that terminating processes can use to clean up residual state.
 
-The [API documentation][d-p-platform-ManagedProcess] is quite extensive, so here we will simply point
+The [API documentation][d-p-client-server-ManagedProcess] is quite extensive, so here we will simply point
 out the obvious differences. A process implemented with `ManagedProcess`
 can present a type safe API to its callers (and the server side code too!),
 although that's not its primary benefit. For a very simplified example:
@@ -487,7 +500,7 @@ configurable task pools and task supervision strategy part of its API.
 
 More complex examples of the `ManagedProcess` API can be seen in the
 [Managed Processes tutorial](tutorials/tutorial3.html). API documentation for HEAD is available
-[here][d-p-platform-ManagedProcess].
+[here][d-p-client-server-ManagedProcess].
 
 ### Supervision Trees
 
@@ -500,7 +513,12 @@ TBC
 [cloud-haskell]: http://haskell-distributed.github.io/documentation.html
 [fun201202-coutts]: http://sneezy.cs.nott.ac.uk/fun/2012-02/coutts-2012-02-28.pdf
 [distributed-process]: https://github.com/haskell-distributed/distributed-process
-[distributed-process-platform]: https://github.com/haskell-distributed/distributed-process-platform
+[distributed-process-client-server]: https://github.com/haskell-distributed/distributed-process-client-server
+[distributed-process-async]: https://github.com/haskell-distributed/distributed-process-async
+[distributed-process-execution]: https://github.com/haskell-distributed/distributed-process-execution
+[distributed-process-extras]: https://github.com/haskell-distributed/distributed-process-extras
+[distributed-process-task]: https://github.com/haskell-distributed/distributed-process-task
+[distributed-process-registry]: https://github.com/haskell-distributed/distributed-process-registry
 [distributed-static]: http://hackage.haskell.org/package/distributed-static
 [rank1dynamic]: http://hackage.haskell.org/package/rank1dynamic
 [network-transport]: http://hackage.haskell.org/package/network-transport
@@ -513,6 +531,6 @@ TBC
 [haskell11-ch]: http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel/remote.pdf
 [OTP]: http://en.wikipedia.org/wiki/Open_Telecom_Platform
 [remote]: http://hackage.haskell.org/package/remote
-[d-p-platform-async]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-Async.html
+[d-p-async-async]: https://hackage.haskell.org/package/distributed-process-async/docs/Control-Distributed-Process-Async.html
 [async]: http://hackage.haskell.org/package/async
-[d-p-platform-ManagedProcess]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-ManagedProcess.html
+[d-p-client-server-ManagedProcess]: https://hackage.haskell.org/package/distributed-process-client-server/docs/Control-Distributed-Process-ManagedProcess.html
diff --git a/index.md b/index.md
index abaefb5..f28e417 100644
--- a/index.md
+++ b/index.md
@@ -5,9 +5,8 @@ title: Home
 Cloud Haskell: Erlang-style concurrent and distributed programming in Haskell.
 The Cloud Haskell Platform consists of a
 [generic network transport API](https://github.com/haskell-distributed/network-transport),
-libraries for sending [static closures](https://github.com/haskell-distributed/distributed-static) to remote nodes, a rich [API for distributed programming](https://github.com/haskell-distributed/distributed-process) and a 
-set of [Platform Libraries](https://github.com/haskell-distributed/distributed-process-platform),
-modelled after Erlang's [Open Telecom Platform](http://www.erlang.org/doc/).
+libraries for sending [static closures](https://github.com/haskell-distributed/distributed-static) to remote nodes, a rich [API for distributed programming](https://github.com/haskell-distributed/distributed-process) and a
+set of platform libraries modelled after Erlang's [Open Telecom Platform](http://www.erlang.org/doc/).
 
 Generic network transport backends have been developed for
 [TCP](https://github.com/haskell-distributed/network-transport-tcp) and
@@ -19,7 +18,7 @@ Documentation is available on this site for HEAD, or
 [hackage](http://hackage.haskell.org/package/distributed-process) for the current and preceding versions of
 each library.
 
-### <a href="/rss.xml"><img src="/img/feed-icon-28x28.png"></a> Recent Activity <a class="pull-right" href="http://hackage.haskell.org/platform" ><img src="http://hackage.haskell.org/platform/icons/button-64.png"></a>
+### <a href="/rss.xml"><img src="/img/feed-icon-28x28.png"></a> Recent Activity
 
 <div class="content">
   <div class="related">
@@ -32,5 +31,3 @@ each library.
     </ul>
   </div>
 </div>
-
-
diff --git a/team.md b/team.md
index c16b71d..924776e 100644
--- a/team.md
+++ b/team.md
@@ -27,9 +27,15 @@ of Cloud Haskell as a whole. [Edsko De Vries][13], a member of Well-Typed and th
 author of much of the new implementation we have today, is still closely involved
 as well.
 
-[Tim][6] is the primary author and maintainer of [disributed-process-platform][8];
-an effort to port many of the benefits of Erlang's [Open Telecom Platform][10] to
-the Cloud Haskell ecosystem.
+Most of the packages are maintained by the haskell-distributed
+organization, with people from Well Typed, Tweag, and other companies
+that are involved.
+
+The core [disributed-process][8] library is maintained by
+[Facundo Domínguez][14], and the platform libaries are maintained by
+[Tim Watson][6].
+
+Some libraries are maintained my third parties, most notably d-p-p2p.
 
 [Jeff][7] is the author of [distributed-process-global][11], a re-implementation of
 Erlang's [global][12] (locking, registration and cluster management) API for
@@ -48,9 +54,10 @@ Duncan Coutts, Simon Marlow, Ryan Newton, Eric Kow, Adam Foltzer, Nicolas Wu
 [5]: http://www.haskell.org/haskellwiki/Parallel_GHC_Project
 [6]: https://github.com/hyperthunk
 [7]: https://github.com/jepst
-[8]: https://github.com/haskell-distributed/disributed-process-platform
+[8]: https://github.com/haskell-distributed/disributed-process
 [9]: http://hackage.haskell.org/trac/ghc/wiki/Contributors
 [10]: http://en.wikipedia.org/wiki/Open_Telecom_Platform
 [11]: https://github.com/jepst/distributed-process-global
 [12]: http://www.erlang.org/doc/man/global.html
 [13]: https://github.com/edsko
+[14]: https://github.com/facundominguez
diff --git a/tutorials/1ch.md b/tutorials/1ch.md
index 41f00e1..4eb07d2 100644
--- a/tutorials/1ch.md
+++ b/tutorials/1ch.md
@@ -138,7 +138,7 @@ main = do
       -- Die immediately - throws a ProcessExitException with the given reason.
       Nothing  -> die "nothing came back!"
       Just s -> say $ "got " ++ s ++ " back!"
-      
+
     -- Without the following delay, the process sometimes exits before the messages are exchanged.
     liftIO $ threadDelay 2000000
 {% endhighlight %}
@@ -289,9 +289,9 @@ different ways:
 
 ------
 
-[1]: /static/doc/distributed-process/Control-Distributed-Process.html#v:Message
-[2]: http://hackage.haskell.org/package/distributed-process
-[3]: /static/doc/distributed-process-platform/Control-Distributed-Process-Platform-Async.html
-[4]: /static/doc/distributed-process-platform/Control-Distributed-Process-Platform-ManagedProcess.htmlv:callAsync
-[5]: http://hackage.haskell.org/packages/archive/distributed-process/latest/doc/html/Control-Distributed-Process-Internal-Primitives.html#t:Match
-[6]: http://hackage.haskell.org/packages/archive/distributed-process/latest/doc/html/Control-Distributed-Process-Closure.html
+[1]: https://hackage.haskell.org/package/distributed-process-0.6.6/docs/Control-Distributed-Process.html#t:Message
+[2]: https://hackage.haskell.org/package/distributed-process
+[3]: https://hackage.haskell.org/package/distributed-process-async/docs/Control-Distributed-Process-Async.html
+[4]: https://hackage.haskell.org/package/distributed-process-client-server-0.1.3.2/docs/Control-Distributed-Process-ManagedProcess-Client.html#v:callAsync
+[5]: https://hackage.haskell.org/packages/archive/distributed-process/latest/doc/html/Control-Distributed-Process-Internal-Primitives.html#t:Match
+[6]: https://hackage.haskell.org/packages/archive/distributed-process/latest/doc/html/Control-Distributed-Process-Closure.html
diff --git a/tutorials/3ch.md b/tutorials/3ch.md
index 680421e..c5b9dc7 100644
--- a/tutorials/3ch.md
+++ b/tutorials/3ch.md
@@ -177,9 +177,9 @@ proxy :: Serializable a => ProcessId -> (a -> Process Bool) -> Process ()
 {% endhighlight %}
 
 Since `matchAny` operates on `(Message -> Process b)` and `handleMessage` operates on
-`a -> Process b` we can compose these to make our proxy server. We must not forward 
+`a -> Process b` we can compose these to make our proxy server. We must not forward
 messages for which the predicate function evaluates to `Just False`, nor can we sensibly
-forward messages which the predicate function is unable to evaluate due to type 
+forward messages which the predicate function is unable to evaluate due to type
 incompatibility. This leaves us with the definition found in distributed-process:
 
 {% highlight haskell %}
@@ -197,7 +197,7 @@ proxy pid proc = do
 
 Beyond simple relays and proxies, the raw message handling capabilities available in
 distributed-process can be utilised to develop highly generic message processing code.
-All the richness of the distributed-process-platform APIs (such as `ManagedProcess`) which
+All the richness of the distributed-process-client-server APIs (such as `ManagedProcess`) which
 will be discussed in later tutorials are, in fact, built upon these families of primitives.
 
 ### Typed Channels
@@ -234,10 +234,10 @@ is terminated.
 
 The `ProcessExitException` signal is sent from one process to another, indicating that the
 receiver is being asked to terminate. A process can choose to tell itself to exit, and the
-[`die`][7] primitive simplifies doing so without worrying about the expected type for the 
+[`die`][7] primitive simplifies doing so without worrying about the expected type for the
 action. In fact, [`die`][7] has slightly different semantics from [`exit`][5], since the
 latter involves sending an internal signal to the local node controller. A direct consequence
-of this is that the _exit signal_ may not arrive immediately, since the _Node Controller_ could 
+of this is that the _exit signal_ may not arrive immediately, since the _Node Controller_ could
 be busy processing other events. On the other hand, the [`die`][7] primitive throws a
 `ProcessExitException` directly in the calling thread, thus terminating it without delay.
 In practise, this means the following two functions could behave quite differently at
@@ -247,19 +247,19 @@ runtime:
 
 -- this will never print anything...
 demo1 = die "Boom" >> expect >>= say
-  
+
 -- this /might/ print something before it exits
 demo2 = do
   self <- getSelfPid
   exit self "Boom"
-  expect >>= say 
+  expect >>= say
 {% endhighlight %}
 
 The `ProcessExitException` type holds a _reason_ field, which is serialised as a raw `Message`.
 This exception type is exported, so it is possible to catch these _exit signals_ and decide how
 to respond to them. Catching _exit signals_ is done via a set of primitives in
 distributed-process, and the use of them forms a key component of the various fault tolerance
-strategies provided by distributed-process-platform.
+strategies provided by distributed-process-supervisor.
 
 A `ProcessKillException` is intended to be an _untrappable_ exit signal, so its type is
 not exported and therefore you can __only__ handle it by catching all exceptions, which
@@ -296,7 +296,7 @@ special case. Since link exit signals cannot be caught directly, if you find you
 to _trap_ a link failure, you probably want to use a monitor instead.
 
 Whilst the built-in `link` primitive terminates the link-ee regardless of exit reason,
-distributed-process-platform provides an alternate function `linkOnFailure`, which only
+distributed-process-extras provides an alternate function `linkOnFailure`, which only
 dispatches the `ProcessLinkException` if the link-ed process dies abnormally (i.e., with
 some `DiedReason` other than `DiedNormal`).
 
@@ -305,7 +305,7 @@ putting a `ProcessMonitorNotification` into the process' mailbox. This signal an
 constituent fields can be introspected in order to decide what action (if any) the receiver
 can/should take in response to the monitored process' death. Let's take a look at how
 monitors can be used to determine both when and _how_ a process has terminated. Tucked
-away in distributed-process-platform, the `linkOnFailure` primitive works in exactly this
+away in distributed-process-extras, the `linkOnFailure` primitive works in exactly this
 way, only terminating the caller if the subject terminates abnormally. Let's take a look...
 
 {% highlight haskell %}
@@ -366,17 +366,17 @@ process. The `ProcessInfo` type it returns contains the local node id and a list
 registered names, monitors and links for the process. The call returns `Nothing` if the
 process in question is not alive.
 
-### Monad Transformer Stacks 
+### Monad Transformer Stacks
 
-It is not generally necessary, but it may be convenient in your application to use a 
-custom monad transformer stack with the Process monad at the bottom. For example, 
+It is not generally necessary, but it may be convenient in your application to use a
+custom monad transformer stack with the Process monad at the bottom. For example,
 you may have decided that in various places in your application you will make calls to
 a network database. You may create a data access module, and it will need configuration information available to it in
-order to connect to the database server. A ReaderT can be a nice way to make 
+order to connect to the database server. A ReaderT can be a nice way to make
 configuration data available throughout an application without
-schlepping it around by hand. 
+schlepping it around by hand.
 
-This example is a bit contrived and over-simplified but 
+This example is a bit contrived and over-simplified but
 illustrates the concept. Consider the `fetchUser` function below, it runs in the `AppProcess`
 monad which provides the configuration settings required to connect to the database:
 
@@ -409,7 +409,7 @@ openDB = do
 
 closeDB :: DB.Connection -> AppProcess ()
 closeDB db = liftIO (DB.close db)
-  
+
 {% endhighlight %}
 
 So this would mostly work but it is not complete. What happens if an exception
@@ -423,17 +423,17 @@ In the base library, [bracket][brkt] is defined in Control.Exception with this s
 bracket :: IO a	       --^ computation to run first ("acquire resource")
         -> (a -> IO b) --^ computation to run last ("release resource")
         -> (a -> IO c) --^ computation to run in-between
-	-> IO c	 
+	-> IO c
 
 {% endhighlight %}
 
 Great! We pass an IO action that acquires a resource; `bracket` passes that
 resource to a function which takes the resource and runs another action.
-We also provide a release function which `bracket` is guaranteed to run 
-even if the primary action raises an exception. 
+We also provide a release function which `bracket` is guaranteed to run
+even if the primary action raises an exception.
 
 
-Unfortunately, we cannot directly use `bracket` in our 
+Unfortunately, we cannot directly use `bracket` in our
 `fetchUser` function: openDB (resource acquisition) runs in the `AppProcess`
 monad. If our functions ran in IO, we could lift the entire bracket computation into
 our monad transformer stack with liftIO; but we cannot do that for the computations
@@ -473,7 +473,7 @@ onException p what = p `catch` \e -> do _ <- what
 
 `distributed-process` needs to do this sort of thing to keep its dependency
 list small, but do we really want to write this for every transformer stack
-we use in our own applications? No! And we do not have to, thanks to 
+we use in our own applications? No! And we do not have to, thanks to
 the [monad-control][mctrl] and [lifted-base][lbase] libraries.
 
 [monad-control][mctrl] provides several typeclasses and helper functions
@@ -489,17 +489,17 @@ bracket that looks like this:
 
 {% highlight haskell %}
 
-bracket :: MonadBaseControl IO m	 
+bracket :: MonadBaseControl IO m
         => m a	       --^ computation to run first ("acquire resource")
         -> (a -> m b)  --^ computation to run last ("release resource")
         -> (a -> m c)  --^ computation to run in-between
-        -> m c	 
+        -> m c
 
 {% endhighlight %}
 
 It is just the same as the version found in base, except it is generalized to work
 with actions in any monad that implements [MonadBaseControl IO][mbc]. [monad-control][mctrl] defines
-instances for the standard transformers, but that instance requires the base monad 
+instances for the standard transformers, but that instance requires the base monad
 (in this case, `Process`) to also have an instance of these classes.
 
 To address this the [distributed-process-monad-control][dpmc] package
@@ -520,7 +520,7 @@ fetchUser email =
   Lifted.bracket openDB
                  closeDB
           	 $ \db -> liftIO $ DB.query db email
-          
+
 
 {% endhighlight %}
 
diff --git a/tutorials/4ch.md b/tutorials/4ch.md
index 83dc0ef..2475784 100644
--- a/tutorials/4ch.md
+++ b/tutorials/4ch.md
@@ -8,9 +8,9 @@ title: 4. Managed Process Tutorial
 ### Introduction
 
 The source code for this tutorial is based on the `BlockingQueue` API
-from distributed-process-platform and can be accessed [here][1].
+from distributed-process-task and can be accessed [here][1].
 Please note that this tutorial is based on the stable (master) branch
-of [distributed-process-platform][3].
+of [distributed-process-task][3].
 
 ### Managed Processes
 
@@ -40,8 +40,8 @@ code to be run on termination/shutdown.
 
 {% highlight haskell %}
 myServer :: ProcessDefinition MyStateType
-myServer = 
-  ProcessDefinition { 
+myServer =
+  ProcessDefinition {
       -- handle messages sent to us via the call/cast API functions
       apiHandlers = [
         -- a list of Dispatchers, derived by calling on of the various
@@ -113,7 +113,7 @@ that math server that does just that:
 ----
 
 {% highlight haskell %}
-module MathServer 
+module MathServer
   ( -- client facing API
     add
     -- starting/spawning the server process
@@ -241,9 +241,9 @@ more interesting and useful.
 ### Building a Task Queue
 
 This section of the tutorial is based on a real module from the
-distributed-process-platform library, called `BlockingQueue`.
+distributed-process-task library, called `BlockingQueue`.
 
-Let's imagine we want to execute tasks on an arbitrary node, but want 
+Let's imagine we want to execute tasks on an arbitrary node, but want
 the caller to block whilst the remote task is executing. We also want
 to put an upper bound on the number of concurrent tasks/callers that
 the server will accept. Let's use `ManagedProcess` to implement a generic
@@ -275,7 +275,7 @@ typeclass to allow clients to specify the server's location in whatever
 manner suits them: The type of a task will be `Closure (Process a)` and
 the server will explicitly return an /either/ value with `Left String`
 for errors and `Right a` for successful results.
- 
+
 {% highlight haskell %}
 -- enqueues the task in the pool and blocks
 -- the caller until the task is complete
@@ -342,7 +342,7 @@ data BlockingQueue a = BlockingQueue
 ### Making use of Async
 
 So **how** can we execute this `Closure (Process a)` without blocking the server
-process itself? We can use the `Control.Distributed.Process.Platform.Async` API
+process itself? We can use the `Control.Distributed.Process.Async` API
 to execute each task asynchronously and provide a means for waiting on the result.
 
 In order to use an `Async` handle to get the result of the computation once it's
@@ -663,8 +663,8 @@ another to monitor the first and handle failures and/or cancellation. Spawning
 processes is cheap, but not free as each process is a haskell thread, plus some
 additional book keeping data.
 
-[1]: https://github.com/haskell-distributed/distributed-process-platform/blob/master/src/Control/Distributed/Process/Platform/Task/Queue/BlockingQueue.hs
-[2]: /static/doc/distributed-process-platform/Control-Distributed-Process-Platform-ManagedProcess.html#t:ProcessDefinition
-[3]: https://github.com/haskell-distributed/distributed-process-platform/tree/master/
-[4]: https://github.com/haskell-distributed/distributed-process-platform/tree/master/src/Control/Distributed/Process/Platform/UnsafePrimitives.hs
+[1]: https://github.com/haskell-distributed/distributed-process-task/blob/master/src/Control/Distributed/Process/Task/Queue/BlockingQueue.hs
+[2]: https://hackage.haskell.org/package/distributed-process-client-server-0.1.3.2/docs/Control-Distributed-Process-ManagedProcess.html#t:ProcessDefinition
+[3]: https://github.com/haskell-distributed/distributed-process-task
+[4]: https://github.com/haskell-distributed/distributed-process-extras/blob/master/src/Control/Distributed/Process/Extras/UnsafePrimitives.hs
 [5]: /documentation.html
diff --git a/tutorials/5ch.md b/tutorials/5ch.md
index 1a56c3f..1811c8f 100644
--- a/tutorials/5ch.md
+++ b/tutorials/5ch.md
@@ -56,7 +56,7 @@ triggered the shutdown/terminate sequence for the supervisor's process explicitl
 When a supervisor is told directly to terminate a child process, it uses the
 `ChildTerminationPolicy` to determine whether the child should be terminated
 _gracefully_ or _brutally killed_. This _shutdown protocol_ is used throughout
-[distributed-process-platform][dpp] and in order for a child process to be managed
+[distributed-process-supervisor][dpp] and in order for a child process to be managed
 effectively by its supervisor, it is imperative that it understands the protocol.
 When a _graceful_ shutdown is required, the supervisor will send an exit signal to the
 child process, with the `ExitReason` set to `ExitShutdown`, whence the child process is
@@ -70,7 +70,7 @@ provide a timeout value. The supervisor attempts a _gracefull_ shutdown initiall
 however if the child does not exit within the given time window, the supervisor will
 automatically revert to a _brutal kill_ using `TerminateImmediately`. If the
 timeout value is set to `Infinity`, the supervisor will wait indefintiely for the
-child to exit cleanly. 
+child to exit cleanly.
 
 When a supervisor detects a child exit, it will attempt a restart. Whilst explicitly
 terminating a child will **only** terminate the specified child process, unexpected
@@ -142,11 +142,10 @@ order, otherwise the dependent children might crash whilst we're restarting othe
 rely on. It follows that, in this setup, we cannot subsequently (re)start the children in the
 same order we stopped them either.
 
-[dpp]: https://github.com/haskell-distributed/distributed-process-platform
+[dpp]: https://github.com/haskell-distributed/distributed-process-supervisor
 [sup1]: /img/one-for-one.png
 [sup2]: /img/one-for-all.png
 [sup3]: /img/one-for-all-left-to-right.png
 [alert]: /img/alert.png
 [info]: /img/info.png
 [erlsup]: http://www.erlang.org/doc/man/supervisor.html
-
diff --git a/tutorials/6ch.md b/tutorials/6ch.md
index 1269745..29a32c6 100644
--- a/tutorials/6ch.md
+++ b/tutorials/6ch.md
@@ -56,7 +56,7 @@ look at this in action, revisiting the well-trodden _math server_ example
 from our previous tutorials:
 
 {% highlight haskell %}
-module MathServer 
+module MathServer
   ( -- client facing API
     MathServer()
   , add
@@ -561,20 +561,19 @@ the client using the send ports supplied in the request data.
 > passes data to them (via the `SendPort`) is bound to exactly the same type(s)!
 > Furthermore, adding reply channels (in the form of a `SendPort`) to the request
 > types ensures that the replies will be handled correctly as well! As a result,
-> there can be no ambiguity about the types involved for _either_ side of the 
+> there can be no ambiguity about the types involved for _either_ side of the
 > client-server relationship and therefore no unhandled messages due to runtime
 > type mismatches - the compiler will catch that sort of thing for us!
 ------
 
-[1]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-Service-Registry.html
-[2]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-Async.html
-[3]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-Service-SystemLog.html
-[mgmt]: http://hackage.haskell.org/package/distributed-process/Control-Distributed-Process-Management.html
-[dbg]: http://hackage.haskell.org/package/distributed-process/Control-Distributed-Process-Debug.html
-[rtbl]: http://hackage.haskell.org/package/distributed-proces-platforms/Control-Distributed-Process-Platform.html#t:Routable
-[rsbl]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform.html#t:Resolvable
+[1]: https://hackage.haskell.org/package/distributed-process-registry/docs/Control-Distributed-Process-Registry.html
+[2]: https://hackage.haskell.org/package/distributed-process-async/docs/Control-Distributed-Process-Async.html
+[3]: https://hackage.haskell.org/package/distributed-process-extras/docs/Control-Distributed-Process-Extras-SystemLog.html
+[mgmt]: https://hackage.haskell.org/package/distributed-process/Control-Distributed-Process-Management.html
+[dbg]: https://hackage.haskell.org/package/distributed-process/Control-Distributed-Process-Debug.html
+[rtbl]: https://hackage.haskell.org/package/distributed-process-extras/docs/Control-Distributed-Process-Extras.html#t:Routable
+[rsbl]: https://hackage.haskell.org/package/distributed-process-extras/docs/Control-Distributed-Process-Extras.html#t:Resolvable
 [alert]: /img/alert.png
 [info]: /img/info.png
-[policy]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-ManagedProcess.html#t:UnhandledMessagePolicy
-[mailbox]: http://hackage.haskell.org/package/distributed-process-platform/Control-Distributed-Process-Platform-Execution-Mailbox.html
-
+[policy]: https://hackage.haskell.org/package/distributed-process-client-server/docs/Control-Distributed-Process-ManagedProcess.html#v:unhandledMessagePolicy
+[mailbox]: https://hackage.haskell.org/package/distributed-process-execution-0.1.2.2/docs/Control-Distributed-Process-Execution-Mailbox.html
