diff --git a/technology.eclipsescada/README.txt b/technology.eclipsescada/README.txt
new file mode 100644
index 0000000..13afc4a
--- /dev/null
+++ b/technology.eclipsescada/README.txt
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2009 Eclipse Foundation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Wayne Beaton (Eclipse Foundation)- initial API and implementation
+ *******************************************************************************/
+
+In this package, you will find several files. From a proposal author 
+point of view, the only file you really need to concern yourself with is
+the proposal.html file. There are comments in that file that will help
+you pull the required pieces together.
+
+If you have the phoenix environment set up on your workstation, you can
+see how the proposal will look "live". However, you should be able to
+work successfully with just the HTML document. Please keep the formatting
+simple, as we will use style sheets to format the public version.
+
+Thank you for taking the time to author an Eclipse Project proposal.
+	
+Direct any questions about this template to emo@eclipse.org
\ No newline at end of file
diff --git a/technology.eclipsescada/_projectCommon.php b/technology.eclipsescada/_projectCommon.php
new file mode 100644
index 0000000..741b7e0
--- /dev/null
+++ b/technology.eclipsescada/_projectCommon.php
@@ -0,0 +1,3 @@
+<?php
+include("../_proposalCommon.php");
+?>
diff --git a/technology.eclipsescada/functions.php b/technology.eclipsescada/functions.php
new file mode 100644
index 0000000..432bb72
--- /dev/null
+++ b/technology.eclipsescada/functions.php
@@ -0,0 +1,55 @@
+<? 
+/*******************************************************************************
+ * Copyright (c) 2007 Eclipse Foundation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Wayne Beaton (Eclipse Foundation)- initial API and implementation
+ *******************************************************************************/
+
+function get_title_from_html_document($file_name) {
+	$header = get_header_from_html_document($file_name);
+	
+	/*
+	 * Break the header up into multiple lines. Handle the
+	 * case where line breaks are lf, crlf, or cr.
+	 */
+	
+	$lines = preg_split("/\r?\n|\r/", $header); 
+	
+	/*
+	 * Merge the lines into a single line so that eregi
+	 * can find the title even if it is split over multiple
+	 * lines
+	 */
+	$one_line = implode(" ", $lines); 
+	
+	/*
+	 * If we can match a title tag, extract it.
+	 */
+	if (eregi("<title>(.*)</title>", $one_line, $title)) {
+    	return $title[1];
+	}
+	
+	return "An Eclipse Proposal";
+}
+
+function get_header_from_html_document(&$file_name) {
+	$handle = @fopen($file_name, "r");
+	$content = "";
+    while (!feof($handle)) {
+        $part = fread($handle, 1024);
+        $content .= $part;
+        
+        /*
+         * Only read up to the part that includes the
+         * end tag for the header area.
+         */
+        if (eregi("</head>", $part)) break;
+    }
+    fclose($handle);
+    return $content;
+}
\ No newline at end of file
diff --git a/technology.eclipsescada/index.php b/technology.eclipsescada/index.php
new file mode 100644
index 0000000..d4afb48
--- /dev/null
+++ b/technology.eclipsescada/index.php
@@ -0,0 +1,32 @@
+<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'
+
+require_once("functions.php");
+$proposal_title = get_title_from_html_document("proposal.html");
+
+$pageTitle 		= $proposal_title;
+$pageKeywords	= "Eclipse, proposal";
+$pageAuthor		= "";
+
+
+ob_start();
+?>
+<div id="maincontent">
+	<div id="midcolumn">
+	
+		<h1><?= $proposal_title ?></h1>
+	
+		<?php
+			include_once($_SERVER['DOCUMENT_ROOT'] . "/projects/fragments/proposal-page-header.php");
+			generate_header($proposal_title);
+			
+			include("proposal.html");
+		?>
+	</div>
+</div>
+<?php
+$html = ob_get_contents();
+ob_end_clean();
+
+# Generate the web page
+$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
diff --git a/technology.eclipsescada/proposal.html b/technology.eclipsescada/proposal.html
new file mode 100644
index 0000000..a7528cf
--- /dev/null
+++ b/technology.eclipsescada/proposal.html
@@ -0,0 +1,613 @@
+<!-- 
+	This document is provided as a template along with some guidance for creating
+	your project proposal. This is just a template. Feel free to change it as
+	you see fit (add sections, remove section). We feel, however, that the
+	suggestions represented in this document represent the reasonable minimum
+	amount of information to move forward.
+	
+	Please keep the formatting in this document simple. Please do not edit 
+	this document in Microsoft Word as it adds huge piles of markup that make
+	it difficult to restyle.
+	
+	More information is available here:
+	
+	http://wiki.eclipse.org/Development_Resources/HOWTO/Pre-Proposal_Phase
+	
+	Direct any questions about this template to emo@eclipse.org
+ -->
+
+<html>
+<head>
+
+<!-- 
+	Include the title here. We will parse it out of here and include it on the
+	rendered webpage. Do not duplicate the title within the text of your page.
+ -->
+
+<title>Eclipse SCADA</title>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+</head>
+
+<!-- 
+	We make use of the 'classic' HTML Definition List (dl) tag to specify
+	committers. I know... you haven't seen this tag in a long while...
+ -->
+
+<style type="text/css">
+dt {
+	display: list-item;
+	list-style-position: outside;
+	list-style-image:
+		url(/eclipse.org-common/themes/Phoenix/images/arrow.gif);
+	margin-left: 16px;
+}
+
+dd {
+	margin-left: 25px;
+	margin-bottom: 5px;
+}
+</style>
+
+<body>
+	<p>
+		The Eclipse SCADA project is a proposed open source project under the
+		<a
+			href="http://www.eclipse.org/projects/project_summary.php?projectid=technology">Technology
+			Container Project</a>.
+	</p>
+	<!-- // an alternative top level project would be the m2m working group -->
+
+	<!-- 
+	The communication channel must be specified. Typically, this is the
+	"Proposals" forum. In general, you don't need to change this.
+ -->
+	<p>
+		This proposal is in the Project Proposal Phase (as defined in the
+		Eclipse Development Process) and is written to declare its intent and
+		scope. We solicit additional participation and input from the Eclipse
+		community. Please send all feedback to the <a
+			href="http://www.eclipse.org/forums/eclipse.proposals">Eclipse
+			Proposals</a> Forum.
+	</p>
+
+	<h2>Background</h2>
+
+	<!-- 
+	Optionally provide the background that has lead you to creating this project.
+ -->
+
+	<p>
+		In 2006 (inavare GmbH, later renamed to TH4 SYSTEMS GmbH) started a
+		series of projects which would at first require some sort of
+		connectivity to process control hardware and software. It was obvious
+		that with the upcoming projects more SCADA like functionality would be
+		required. The target platform had to be 64bit Linux and a JEE
+		environment. Since there was no room for a full blown SCADA system and
+		also existing solutions on the market did not seem to fit (or were to
+		expensive), development of a custom SCADA system was started in these
+		projects. It was clear from the beginning that it would be hard to
+		place this custom built solution as a commercial product on the
+		market. Therefore it was decided to create it as a an open source
+		project from the start. It is currently hosted at <a
+			href="http://openscada.org">http://openscada.org</a>.
+	</p>
+
+	<h2>Scope</h2>
+
+	<!-- 
+	All projects must have a well-defined scope. Describe, concisely, what
+	is in-scope and (optionally) what is out-of-scope. An Eclipse project
+	cannot have an open-ended scope.
+ -->
+
+	<p>EclipseSCADA provides a state of the art open source SCADA
+		system, including:</p>
+	<ul>
+		<li>A communication system
+			<ul>
+				<li>An internal communication bus</li>
+				<li>A framework for implementing driver modules/device adapters</li>
+				<li>A set of out-of-the-box drivers modules/device adapters</li>
+			</ul>
+		</li>
+		<li>A monitoring system, evaluating gathered data, storing
+			generated events</li>
+		<li>A data archive, storing gathered data</li>
+		<li>Create a reference implementation</li>
+		<li>A graphical user interface for gathered data, alarms &amp;
+			events from the monitoring system, archived value data</li>
+		<li>A system to configure and document the system</li>
+	</ul>
+
+	<p>Not part of the this project are:</p>
+
+	<ul>
+		<li>An embedded systems platform (like PLCs or embedded control
+			systems)</li>
+		<li>A communication system that transports arbitrary complex data
+			structures</li>
+	</ul>
+
+
+	<h2>Description</h2>
+
+	<!-- 
+	Describe the project here. Be concise, but provide enough information that
+	somebody who doesn't already know very much about your project idea or domain
+	has at least a fighting chance of understanding its purpose.
+ -->
+	<p>
+		Definition from wikipedia: <a
+			href="https://en.wikipedia.org/wiki/SCADA">https://en.wikipedia.org/wiki/SCADA</a>
+	</p>
+	<blockquote cite="https://en.wikipedia.org/wiki/SCADA">
+		<p>SCADA (supervisory control and data acquisition) is a type of
+			industrial control system (ICS). Industrial control systems are
+			computer controlled systems that monitor and control industrial
+			processes that exist in the physical world. SCADA systems
+			historically distinguish themselves from other ICS systems by being
+			large scale processes that can include multiple sites, and large
+			distances.</p>
+	</blockquote>
+
+	<p>Simply speaking the primary target of Eclipse SCADA is a way to
+		connect different industrial devices to a common communication system
+		and post-process as well as visualize the data to operating personnel.</p>
+
+	<p>
+		Since this scheme will also work with non-industrial devices and
+		devices do become more complex and tend to become software solutions
+		themselves the term &ldquo;device&rdquo; should be more considered as an &ldquo;other
+			system&rdquo;.
+	</p>
+
+	<p>The idea of a SCADA system is to provide mostly scalar values
+		instead of complex data structures. Where necessary data structures
+		are split up into multiple scalar values. This is done in order to
+		process the data more quickly and allow common processing of data.</p>
+
+	<!-- not sure if this example explains adequatly what SCADA is about, maybe it should be reformulated or just removed -->
+	<p>For example a meteo station is providing current weather
+		information. It can provide temperature and solar radiation. These are
+		two floating point values which are processed independently. Still the
+		same alarming schema (high level alarm) can be applied to both values.
+		The values can both be assigned a quality/alarm information (alarm
+		state) which can then be shown using the same user interface element
+		and the same visualization scheme (alarm is displayed with red
+		background). This way many different scalar values can be processed
+		exactly the same way.</p>
+
+	<h2>Why Eclipse?</h2>
+
+	<!-- 
+	Answer these two questions:	What value does this project bring to the Eclipse
+	community? What value do you expect to obtain from hosting your project at Eclipse?
+	
+	What value do you get by having your project at Eclipse over and above the value
+	of hosting at Eclipse Labs?
+ -->
+	<p>First of all this project uses several Eclipse technologies like
+		OSGi, RCP, EMF and a few more. This is the reason why the existing
+		openSCADA project is technologically already quite close to the
+		Eclipse project set. Also a lot of code already exists which could be
+		used by other projects in the Eclipse Foundation.</p>
+
+	<p>We hope that bringing openSCADA into Eclipse as Eclipse SCADA
+		will increase the visibility of the open source SCADA system and
+		attract other contributors and companies to an open source SCADA
+		solution. An open source SCADA communication stack could be used by
+		system integrators and device manufactures to provide a default way of
+		communicating with devices, in an open source ecosystem. Due to the
+		connected nature of a SCADA system it is important to have an open
+		connection infrastructure. As ibh SYSTEMS GmbH we are not in the
+		position to provide an industry standard way, as an Eclipse project it
+		would be possible to set a standard together with other industrial
+		projects in that area. We also do not begin from scratch, since we
+		already have a working solution.</p>
+
+	<p>We as ibh SYSTEMS GmbH of course hope to assist in realizing
+		such solutions and enhance Eclipse SCADA in future projects as we did
+		with openSCADA up to now. Yet the Eclipse Foundation provides a much
+		broader audience.</p>
+
+	<p>openSCADA already has a small community and several users. It
+		has an open communication channel (google group), a wiki and bug
+		tracker at Atlassian, three publicly accessible git repositories. This
+		is why we don't see any additional value in migrating to Eclipse Labs.
+	</p>
+
+	<h2>Initial Contribution</h2>
+
+	<!-- 
+	Projects are expected to arrive at Eclipse with existing code.
+	
+	Describe the existing code that will be contributed to the project. Please provide
+	a couple of paragraphs describing the code with modest detail, including important
+	information like code ownership (who holds the copyright?), and some consideration
+	of community that exists around the code. Include a listing of third-party libraries 
+	and associated licenses.
+ -->
+	<p>As base for Eclipse SCADA we want to use the existing openSCADA
+		project source code. The code is currently hosted by ibh SYSTEMS GmbH.
+		The copyright owners are the proposed committers which already worked
+		as freelancer on the project as well the companies TH4 SYSTEMS GmbH
+		(formerly inavare GmbH) and ibh SYSTEMS GmbH.</p>
+
+	<p>The source code was originally managed in several subversion
+		repositories which were converted to git repositories some time ago.
+		The openSCADA project itself is grouped into different sub-projects in
+		order to modularize it.</p>
+
+	<!-- actually I am a fan of "dl" -->
+	<dl>
+		<dt>External</dt>
+		<dd>Contains all external libraries (except j-interop). This
+			project will not be contributed. Eclipse Orbit will be used instead.</dd>
+
+		<dt>Aurora</dt>
+		<dd>Holds non-user interface utility components</dd>
+
+		<dt>Utgard</dt>
+		<dd>The OPC driver implementation, based on j-interop</dd>
+
+		<dt>Oxygen</dt>
+		<dd>Implementations of some protocols, mostly openSCADA internal</dd>
+
+		<dt>Atlantis</dt>
+		<dd>Non-user interface components of the openSCADA system.
+			Including driver modules, alarming, archiving.</dd>
+
+		<dt>Orilla</dt>
+		<dd>User interface components of the openSCADA system.</dd>
+
+		<dt>Infinity</dt>
+		<dd>An SWT based time series chart widget.</dd>
+
+		<dt>Dakara</dt>
+		<dd>The Draw2D based vector graphics visualization</dd>
+
+		<dt>Othala</dt>
+		<dd>
+			An Eclipse RCP project build which provides the <q>OSTC</q> an
+			admin/test client for use with openSCADA.
+		</dd>
+
+		<dt>Orion</dt>
+		<dd>Some additional user interface components used within the
+			Eclipse IDE</dd>
+
+		<dt>Tau'ri</dt>
+		<dd>Some example projects and setups for demoing openSCADA</dd>
+
+		<dt>Contrib</dt>
+		<dd>Some source code that can be used with openSCADA but does not
+			fit into the release version of openSCADA due to the lack of use,
+			testing or license issues.</dd>
+	</dl>
+
+	<!-- 
+	Describe any initial contributions of code that will be brought to the 
+	project. If there is no existing code, just remove this section.
+ -->
+
+	<p>The initial contribution of Eclipse SCADA would be the openSCADA
+		Git repositories which are currently replicated to:</p>
+	<ul>
+		<li><a href="http://git.openscada.org">http://git.openscada.org</a></li>
+		<li><a href="https://bitbucket.org/ctron">https://bitbucket.org/ctron</a></li>
+		<li><a href="https://github.com/ctron">https://github.com/ctron</a></li>
+	</ul>
+
+	<p>The initial components we want to contribute are:</p>
+	<ul>
+		<li>Aurora</li>
+		<li>Oxgyen</li>
+		<li>Utgard (as the j-interop dependencies are resolved)</li>
+		<li>Atlantis</li>
+		<li>Orilla</li>
+		<li>Infinity</li>
+		<li>Othala</li>
+		<li>Dakara</li>
+		<li>Deploy</li>
+		<li>Orion</li>
+	</ul>
+
+	<p>
+		Note that the <em>Orion</em> component will renamed to avoid confusion
+		with the Eclipse Orion project.
+	</p>
+
+	<p>The following external libraries are used by openSCADA at the
+		moment:</p>
+
+	<table>
+		<thead>
+			<tr>
+				<th>Library</th>
+				<th>License</th>
+			</tr>
+		</thead>
+		<tbody>
+
+			<tr>
+				<td>Apache Mina 2.0.7</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+
+			<tr>
+				<td>SLF4J 1.6.4</td>
+				<td><a href="http://www.slf4j.org/license.html">MIT license</a>
+				</td>
+			</tr>
+			<tr>
+				<td>Logback 1.0.0</td>
+				<td>EPL v1.0 &amp; LGPL 2.1</td>
+			</tr>
+
+			<tr>
+				<td>jzlib 1.1.1</td>
+				<td>BSD-style</td>
+			</tr>
+			<tr>
+				<td>guava 10.0.1</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>antlr 3.1.3</td>
+				<td><a
+					href="https://github.com/antlr/antlr4/blob/master/LICENSE.txt">BSD
+						License, </a></td>
+			</tr>
+			<tr>
+				<td>commons-daemon 1.0.10</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>commons-dbcp 1.4</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>commons-io 2.3</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>commons-pool 1.6</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>javax.transaction 1.1.1</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>commons-beanutils 1.8.0</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>commons-collections 3.2.0</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>commons-lang 2.6.0</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>tomcat-apr 5.5.23</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>Apache Xerces 2.9.0</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+
+			<tr>
+				<td>J-Interop</td>
+				<td>LGPLv3</td>
+				<td>Need to check dependencies</td>
+			</tr>
+			<tr>
+				<td>JCIFS 1.2.25</td>
+				<td><a href="http://www.gnu.org/licenses/lgpl-2.1.txt">LGPLv2.1</a>
+				</td>
+				<td>Required for j-interop</td>
+			</tr>
+			<tr>
+				<td>GNU Crypto</td>
+				<td>GPLv2+</td>
+				<td>Required for j-interop, could be replaced with bouncycastle</td>
+			</tr>
+			<tr>
+				<td>jarapac</td>
+				<td>LGPLv3</td>
+				<td>Required for j-interop</td>
+			</tr>
+			<tr>
+				<td>JTDS JDBC Driver</td>
+				<td>LGPLv2.1</td>
+				<td>Required for j-interop</td>
+			</tr>
+
+			<tr>
+				<td>iWombat</td>
+				<td><a href="http://www.iwombat.com/java/license.html">iWombat
+						License</a></td>
+				<td>Required for j-interop, Could be replaced by own
+					implementation, check with Hudson</td>
+			</tr>
+			<tr>
+				<td>Apache XML Beans</td>
+				<td>-</td>
+				<td>Will be removed before contributing</td>
+			</tr>
+
+			<tr>
+				<td>Apache ODFDOM</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+			<tr>
+				<td>Apache POI</td>
+				<td>Apache License, Version 2.0</td>
+			</tr>
+
+		</tbody>
+	</table>
+
+	<h2>Legal Issues</h2>
+
+	<!-- 
+	Please describe any potential legal issues in this section. Does somebody else
+	own the trademark to the project name? Is there some issue that prevents you
+	from licensing the project under the Eclipse Public License? Are parts of the 
+	code available under some other license? Are there any LGPL/GPL bits that you
+	absolutely require?
+ -->
+	<p>The openSCADA project, which will be the source base for Eclipse
+		SCADA, is developed by the named contributors (see below). At the
+		moment the license is LGPLv3, but all contributors have agreed to
+		change the license to the EPL license for contributing the project
+		openSCADA to the Eclipse Foundation.</p>
+
+	<p>There however several external libraries which openSCADA
+		requires at the moment which are not EPL. In order to reduce issues
+		with the upcoming contribution to Eclipse, dependencies were removed
+		or replaced with versions from the Eclipse Orbit repository. The plan
+		is to complete this transition for all required libraries for the
+		openSCADA release 1.2, which is planned to be the initial version
+		contributed to Eclipse (also see below).</p>
+
+	<p>
+		One special case remaining is the library <q>j-interop</q>. This
+		library and its dependencies are required for one important driver
+		(OPC driver) of the openSCADA System. Although the system can work
+		without this driver module, it is a very useful component. Also is
+		this library used by the Eclipse Project <q>Hudson</q> for the
+		DCOM/Windows Slave plugin. Possible solutions are: either to remove
+		the module from Eclipse SCADA and leave it with the openSCADA <q>contrib</q>
+		repository, or to import j-interop (if not already done) into the
+		Eclipse Foundation in some way. Since the author of the j-interop
+		library (Vikram Roopchand) and us worked together in the past and also
+		contributed to the library, it should be an interesting contribution
+		to Eclipse in any way. j-interop includes some code from other
+		libraries (iWombat and GNU Crypto) with incompatible licensing, but
+		this is easily resolvable with a custom implementation and the use of
+		bouncycastle (which is licensed under a variant of the MIT X11
+		License, <a href="http://www.bouncycastle.org/licence.html">http://www.bouncycastle.org/licence.html</a>).
+	</p>
+
+	<h2>Committers</h2>
+
+	<!-- 
+	List any initial committers that should be provisioned along with the
+	new project. Include affiliation, but do not include email addresses at
+	this point.
+ -->
+
+	<p>The following individuals are proposed as initial committers to
+		the project:</p>
+
+	<dl>
+		<dt>Jens Reimann, ibh SYSTEMS GmbH</dt>
+		<dd>Jens Reimann is a commiter on the openSCADA project where he
+			has made significant contributions over many years.</dd>
+
+		<dt>Jürgen Rose, ibh SYSTEMS GmbH</dt>
+		<dd>Jürgen Rose is a commiter on the openSCADA project where he
+			has made significant contributions over many years.</dd>
+
+		<!--
+	<dt>Committer 1, Affiliation</dt>
+	<dd>Committer 1 is a committer on the *** project where he has made significant contributions over
+	many years. S/he will be contribute to the *** functionality in this new project.</dd>
+	<dt>Committer 2, Affiliation</dt>
+	<dd>Committer 2 has provided significant contributions to the existing code base. S/he will contribute
+	to the *** functionality in this new project.
+	</dd>
+-->
+	</dl>
+
+	<p>We welcome additional committers and contributions.</p>
+
+	<h2>Mentors</h2>
+
+	<!-- 
+	New Eclipse projects require a minimum of two mentors from the Architecture
+	Council. You need to identify two mentors before the project is created. The
+	proposal can be posted before this section is filled in (it's a little easier
+	to find a mentor when the proposal itself is public).
+ -->
+
+	<p>The following Architecture Council members will mentor this
+		project:</p>
+
+	<ul>
+		<li>Mentor 1</li>
+		<li>Mentor 2</li>
+	</ul>
+
+	<h2>Interested Parties</h2>
+
+	<!-- 
+	Provide a list of individuals, organisations, companies, and other Eclipse
+	projects that are interested in this project. This list will provide some
+	insight into who your project's community will ultimately include. Where
+	possible, include affiliations. Do not include email addresses.
+ -->
+
+	<p>The following individuals, organisations, companies and projects
+		have expressed interest in this project:</p>
+
+	<ul>
+		<li>OMV Solutions, User of openSCADA</li>
+		<li>E.ON CR, User of openSCADA</li>
+		<li>XION AT, Integrator</li>
+		<li>eTrice, Eclipse Project</li>
+		<li>ScadaBR, another open source SCADA which uses parts of
+			openSCADA</li>
+		<li>4DIAC, an open source framework from fortiss GmbH for
+			distributed industrial automation and control</li>
+		<!--
+	<li>…</li>
+	<li>Somebody, Affiliation</li>
+	<li>Somebody else, Affiliation</li>
+-->
+	</ul>
+
+	<h2>Project Scheduling</h2>
+
+	<!-- 
+	Describe, in rough terms, what the basic scheduling of the project will
+	be. You might, for example, include an indication of when an initial contribution
+	should be expected, when your first build will be ready, etc. Exact
+	dates are not required.
+ -->
+	<p>The project will be started by contributing the openSCADA source
+		code to the Eclipse Foundation. At the moment openSCADA is released as
+		version 1.1 and the version 1.2 is planned withing the next view
+		months. The idea is to clean up some parts and dependencies from 1.1
+		to 1.2 before contributing version 1.2 to the Eclipse Foundation.</p>
+
+	<h2>Changes to this Document</h2>
+
+	<!-- 
+	List any changes that have occurred in the document here.
+	You only need to document changes that have occurred after the document
+	has been posted live for the community to view and comment.
+ -->
+
+	<table>
+		<tr>
+			<th>Date</th>
+			<th>Change</th>
+		</tr>
+		<tr>
+			<td>28-May-2013</td>
+			<td>Document created</td>
+		</tr>
+		<!--
+	<tr>
+		<td>DD-Month-YYYY</td>
+		<td>Document created</td>
+	</tr>
+-->
+	</table>
+</body>
+</html>
