diff --git a/technology.kura/README.txt b/technology.kura/README.txt
new file mode 100644
index 0000000..13afc4a
--- /dev/null
+++ b/technology.kura/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.kura/_projectCommon.php b/technology.kura/_projectCommon.php
new file mode 100644
index 0000000..741b7e0
--- /dev/null
+++ b/technology.kura/_projectCommon.php
@@ -0,0 +1,3 @@
+<?php
+include("../_proposalCommon.php");
+?>
diff --git a/technology.kura/functions.php b/technology.kura/functions.php
new file mode 100644
index 0000000..432bb72
--- /dev/null
+++ b/technology.kura/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.kura/index.php b/technology.kura/index.php
new file mode 100644
index 0000000..d4afb48
--- /dev/null
+++ b/technology.kura/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.kura/proposal.html b/technology.kura/proposal.html
new file mode 100644
index 0000000..f8fa280
--- /dev/null
+++ b/technology.kura/proposal.html
@@ -0,0 +1,373 @@
+<!-- 
+	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>Kura</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>
+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 Kura project is a proposed open source project under the <a
+	href="http://www.eclipse.org/projects/project_summary.php?projectid=technology">
+	Eclipse Technology Project</a>.</p>
+
+<!-- 
+	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>
+Until recently, machine-to-machine projects have been approached as embedded systems 
+designed around custom hardware, custom software, and custom network connectivity. 
+The challenge of developing such projects was given by the large customization and 
+integration costs and the small re-usability across similar engagements. 
+The results were often proprietary systems leveraging proprietary protocols.
+</p>
+<p>
+The emergence of the service gateway model, which operates on the edge of an M2M 
+deployment as an aggregator and controller, has opened up new possibilities. 
+Cost effective service gateways are now capable of running modern software stacks 
+opening the world of M2M to enterprise technologies and programming languages. 
+Advanced software frameworks, which isolate the developer from the complexity of the 
+hardware and the networking sub-systems, can now be offered to complement the service 
+gateway hardware into an integrated hardware and software solution.
+</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>
+The goals of the Eclipse Kura project can be summarized as:
+</p>
+<ol>
+<li>Provide an OSGi-based container for M2M applications running in service gateways. 
+Kura complements the Java 6 SE and OSGi platforms with API and services covering the most 
+common requirements of M2M applications. These extensions include but they are not limited 
+to: I/O access, data services, watchdog, network configuration and remote management.</li>
+<li>Kura adopts existing javax.* API for its functionalities when available - for example 
+javax.comm, javax.usb, and javax.bluetooth. When possible, Kura will select an open source
+implementation of such API that is compatible with the Eclipse-license and package it in 
+an OSGi bundle to include it in the Kura default build.</li>
+<li>Design a build environment, which isolates the native code components and makes it 
+simple to add ports of these components for new platforms in the Kura build and 
+distribution.</li>
+<li>Provide a development environment which allows developers to run M2M applications in 
+an emulated environment within the Eclipse IDE, then deploy them on a target gateway and 
+finally remotely provision the applications to Kura-enabled devices on the field.</li>
+</ol>
+<p>
+Kura offers a foundation on top of which other contributions for higher-level M2M protocol 
+implementations like ModBUS, CanBUS, ProfiBUS can reside.
+</p>
+
+
+<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>
+Kura offers a Java/OSGi-based container for M2M applications running in service 
+gateways. Kura provides or, when available, aggregates open source implementations for 
+the most common services needed by M2M applications. Kura components are designed as 
+configurable OSGi Declarative Service exposing service API and raising events. 
+While several Kura components are in pure Java, others are invoked through JNI and 
+have a dependency on the Linux operating system. 
+</p>
+<p>
+Kura is currently planning this initial set of services: 
+</p>
+<ul>
+<li><strong>I/O Services</strong>
+	<ul>
+		<li>Serial port access through javax.comm 2.0 API or OSGi I/O connection</li>
+		<li>USB access and events through javax.usb, HID API, custom extensions</li>
+		<li>Bluetooth access through javax.bluetooth or OSGi I/O connection</li>
+		<li>Position Service for GPS information from a NMEA stream</li>
+		<li>Clock Service for the synchronization of the system clock</li>
+		<li>Kura API for GPIO/PWM/I2C/SPI access</li>
+	</ul>
+</li>
+<li><strong>Data Services</strong>
+	<ul>
+		<li>Store and forward functionality for the telemetry data collected by the 
+		gateway and published to remote servers.</li>
+		<li>Policy-driven publishing system, which abstracts the application developer 
+		from the complexity of the network layer and the publishing protocol used. 
+		Eclipse Paho and its MQTT client provides the default messaging library used.</li>
+	</ul>
+</li>	
+<li><strong>Cloud Services</strong>
+	<ul>
+		<li>Easy to use API layer for M2M application to communicate with a remote server. 
+		In addition to simple publish/subscribe, the Cloud Service API simplifies the 
+		implementation of more complex interaction flows like request/response or remote 
+		resource management.</li>
+		<li>Allow for a single connection to a remote server to be shared across more 
+		than one application in the gateway providing the necessary topic partitioning.</li>
+	</ul>
+</li>	
+<li><strong>Configuration Service</strong> 
+	<ul>
+		<li>Leverage the OSGi specifications ConfigurationAdmin and MetaType to provide 
+		a snapshot service to import/export the configuration of all registered services 
+		in the container.</li>
+	</ul>
+</li>	
+<li><strong>Remote Management</strong>
+	<ul>
+		<li>Allow for remote management of the M2M applications installed in Kura 
+		including their deployment, upgrade and configuration management. The Remote 
+		Management service relies on the Configuration Service and the Cloud Service.</li>
+	</ul>
+</li>
+<li><strong>Networking</strong>
+	<ul>
+		<li>Provide API for introspects and configure the network interfaces available 
+		in the gateway like Ethernet, Wifi, and Cellular modems.</li>
+	</ul>
+</li>
+<li><strong>Watchdog  Service</strong>
+	<ul>
+		<li>Register critical components to the Watchdog Service, which will force a 
+		system reset through the hardware watchdog when a problem is detected.</li>
+	</ul>
+</li>	
+<li><strong>Web administration interface</strong>
+	<ul>
+		<li>Offer a web-based management console running within the Kura container 
+		to manage the gateway.</li>
+	</ul>
+</li>
+</ul>
+<p>
+Kura will provide a pre-made build for popular open hardware platforms like the RaspberryPi.
+</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>
+Being an M2M project, Kura aims at becoming another component of the interesting 
+set of technologies grouped under the Eclipse M2M Industry Working Group umbrella. 
+Kura already has a strong relationship with other Eclipse projects:
+</p>
+<ul>
+<li><a href="http://www.eclipse.org/paho/">Eclipse Paho</a> is the default message 
+protocol library used in Kura. The default communication protocol in Kura is MQTT and 
+it is used to transport both data and device management messages.</li>
+<li>Eclipse Equinox is the default OSGi container for Kura.</li>
+<li><a href="http://www.eclipse.org/proposals/rt.concierge/">Eclipse Concierge</a>, 
+a small-footprint OSGi container optimized for embedded devices, will be considered 
+as another runtime platform for Kura.</li>
+</ul>
+<p>
+Kura originates from Eurotech Everyware Software Framework. 
+The UI client view of that framework has already been contributed to the Eclipse Paho 
+project.
+</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>
+The initial contribution of the Kura project will be a large subset of the current
+Eurotech Everyware Software Framework. In particular:
+</p>
+<ul>
+<li>Kura source code and build system for most of the services described above 
+including the web management administration UI</li>
+<li>A Kura M2M application developer's guide with an example application</li>
+<li>Documentation on the Kura application protocol to perform remote resource management 
+and remote administration of M2M applications</li>
+<li>A build of Kura for an open-hardware platform like the RaspberryPi</li>
+</ul>
+
+ 
+<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>
+Eurotech will go through the Eclipse legal review process to make sure all Kura 
+dependencies are eligible for contribution. While Kura has selected open-source 
+components with friendly licenses, a detailed review will be conducted with 
+the Eclipse legal team.
+</p>
+<p>
+Kura has already been tested on open Java VM implementations like OpenJDK.
+</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>Wes Johnson, Eurotech</dt>
+	<dt>Marco Carrer, Eurotech</dt>
+	<dt>Cristiano De Alti, Eurotech</dt>
+	<dt>Dave Woodard, Eurotech</dt>
+	<dt>Elbert Evangelista, Eurotech</dt>
+	<dt>Pierre Pitiot, Eurotech</dt>
+</dl>
+
+<p>We welcome additional committers and contributions.</p>
+
+<!-- 
+	Describe any initial contributions of code that will be brought to the 
+	project. If there is no existing code, just remove this section.
+ -->
+
+<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>Benjamin Cabé</li>
+	<li>TDB</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>Dave Locke, IBM</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>
+Kura aims at the initial contribution to be completed by Q4 2013.
+</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>16-June-2013</td>
+		<td>Document created</td>
+	</tr>
+	<tr>
+		<td>30-June-2013</td>
+		<td>Incorporated Eurotech's internal feedback</td>
+	</tr>
+	<tr>
+		<td>11-July-2013</td>
+		<td>Incorporated Benjamin Cabé's feedback</td>
+	</tr>
+	<tr>
+		<td>15-July-2013</td>
+		<td>Incorporated Dave Locke's feedback</td>
+	</tr>
+</table>
+</body>
+</html>
\ No newline at end of file
