diff --git a/technology.smarthome/README.txt b/technology.smarthome/README.txt
new file mode 100644
index 0000000..13afc4a
--- /dev/null
+++ b/technology.smarthome/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.smarthome/_projectCommon.php b/technology.smarthome/_projectCommon.php
new file mode 100644
index 0000000..741b7e0
--- /dev/null
+++ b/technology.smarthome/_projectCommon.php
@@ -0,0 +1,3 @@
+<?php
+include("../_proposalCommon.php");
+?>
diff --git a/technology.smarthome/functions.php b/technology.smarthome/functions.php
new file mode 100755
index 0000000..432bb72
--- /dev/null
+++ b/technology.smarthome/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.smarthome/index.php b/technology.smarthome/index.php
new file mode 100644
index 0000000..d4afb48
--- /dev/null
+++ b/technology.smarthome/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.smarthome/proposal.html b/technology.smarthome/proposal.html
new file mode 100644
index 0000000..5a460d6
--- /dev/null
+++ b/technology.smarthome/proposal.html
@@ -0,0 +1,266 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 
+	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 Smart Home</title>
+</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 Smart Home project is a proposed open source project under the <a
+	href="http://www.eclipse.org/projects/project_summary.php?projectid=technology">Eclipse Technology Container 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>
+
+<p>Since the emergence of broadband internet connections, smartphones and tablets the Smart Home market shows a remarkable upsurge.
+This has led to a very fragmented market, which makes it difficult for customers to "bet on the right horse". In fact,
+there is not one system, protocol or standard that could possibly fulfill all potential requirements. There is hence
+a need for platforms that allow the integration of different systems, protocols or standards and that provide a uniform
+way of user interaction and higher level services.</p>
+
+<h2>Scope</h2>
+
+<p>The goals of the Eclipse Smart Home project can be summarized as:</p>
+<ol>
+	<li>Provide a flexible framework for smart home and ambient assisted living (AAL) solutions. This framework
+	focuses on the use cases of this domain, e.g. on easy automation and visualization aspects.</li>
+	<li>Specify extension points for integration possibilities and higher-level services. Extending and thus
+	customizing the solution must be as simple as possible and this requires concise and dedicated interfaces.</li>
+	<li>Provide implementations of extensions for relevant systems, protocols or standards. Many of them can
+	be useful to many Smart Home solutions, so this project will provide a set of extensions that can be included
+	if desired. They can also be in the shape of a general Java library or an OSGi bundle, so that these
+	implementations can be used independently of the rest of the project as well.</li>
+	<li>Provide a development environment and tools to foster implementations of extensions. The right tooling can
+	support the emergence of further extensions and thus stimulates future contributions to the project.</li>
+	<li>Create a packaging and demo setups. Although the focus is on the framework, it needs to be shown how to
+	package a real solution from it, which can be used as a starting point and for demo purposes.</li>
+</ol>
+
+<h2>Description</h2>
+
+<p>The Eclipse Smart Home project is a framework that allows building Smart Home solutions that have a strong focus on
+heterogeneous environments, i.e. solutions that deal with the integration of different protocols or standards. Its
+purpose is to provide a uniform access to devices and information and to facilitate different kinds of interactions
+with them. This framework consists out of a set of OSGi bundles that can be deployed on an OSGi runtime and which
+defines OSGi services as extension points.</p>
+
+<p>The stack is meant to be usable on any kind of system that can run an OSGi stack - be it a multi-core server,
+a residential gateway or a Raspberry Pi.
+ 
+<p>
+Currently planned initial features and extension points of this framework include: 
+</p>
+<ul>
+<li><strong>Data Handling</strong>
+	<ul>
+		<li><strong>Type System:</strong> A basic but extensible type system for Smart Home data and commands
+		that provides a common ground for an abstracted data and device access.</li>
+		<li><strong>Data Registry:</strong> Keeps track of data point instances and their values.</li>
+		<li><strong>Event Mechanism:</strong> Passes data and operations asynchronously in a loosly coupled way
+			between components.</li>
+		<li><strong>Bindings:</strong> Infrastructure to exchange data and commands with external systems and devices,
+		 e.g. through regular polling or background threads. Useful binding implementations such as HTTP, NTP or
+		 TCP will be part of the project.
+	</ul>	
+</li>
+<li><strong>Rule Engine</strong>
+	<ul>
+		<li>An implementation of a flexible rule engine that allows changing rules during runtime.</li>
+		<li>Provides triggering upon events or on a temporal basis.</li>
+		<li>Extensible through rule actions that are made available to all rules</li>
+		<li>Simple but powerful textual representation of rules</li>
+	</ul>	
+</li>
+<li><strong>Declarative User Interfaces</strong>
+	<ul>
+		<li>A simple way of describing user interface content in a declarative way.</li>
+		<li>Defines a set of standard widgets and a hierarchy of pages.</li>
+		<li>Structure is made available through REST APIs to be easily consumable by UI implementations</li>
+	</ul>	
+</li>
+<li><strong>Persistence Management</strong>
+	<ul>
+		<li>Infrastructure that allows automatic data processing based on a simple and unified configuration</li>
+		<li>Persistence targets can be anything like databases, log files, IoT cloud services etc.</li>
+		<li>Implementations of persistence services such as logging or cli will be part of the project.</li>
+	</ul>
+</li>
+<li><strong>REST API</strong>
+	<ul>
+		<li>Provides all relevant information and services to user interfaces (e.g. native clients)</li>
+		<li>Extensible to provide additional resources specific to a solution</li>
+		<li>Integrates with persistence services to serve time series for interactive charts</li>
+	</ul>
+</li>
+</ul>
+<p>Besides the runtime framework and implementation, the Eclipse Smart Home projects also provides different kinds
+of tools and samples:</p>
+<ul>
+	<li>Eclipse editors for editing configuration models and rules. These provide full IDE support, such
+	as content assist and syntax validation.</li>
+	<li>Maven archetypes to easily create skeletons for extensions</li>
+	<li>Demo packaging with Eclipse RT</li>
+</ul>
+
+Planned additions for the future include:
+<ul>
+	<li>Remote management for configuration models, possibly through REST</li>
+	<li>Meta-data based configuration of extensions</li>
+	<li>Definition of rule modules (triggers and actions) that can be easily plugged together</li>
+	<li>Notification APIs to easily administrate notification channels</li>
+	<li>Interfaces for natural language processing / voice recognition</li>
+</ul>
+
+<h2>Why Eclipse?</h2> 
+
+<p>Targeting the vertical market of Smart Homes, this project fits nicely into the recent activities around IoT/M2M.</p>
+
+<p>Besides this, Eclipse provides many projects that are a perfect fit for this project (and which are in fact used
+by the initial contribution):</p>
+<ul>
+	<li>Eclipse Equinox is used as the default OSGi runtime.</li>
+	<li>Eclipse Jetty serves as an embedded HTTP server for the REST API and other HTTP services.</li>
+	<li>Eclipse Modelling Framework is the basis for all configuration models</li>
+	<li>Eclipse Xtext provides IDE support for the textual editors and furthermore provides with Xbase
+	   the basis for the textual rule representation</li>
+</ul>
+<p>Other Eclipse projects can be of interest in the future as well:</p>
+<ul>
+	<li>Concierge: a small-footprint OSGi container optimized for embedded devices can be an interesting alternative
+	to Equinox when being used on constrained devices.</li>
+	<li>Kura: Lower level services offered by Kura, such as I/O connectivity, remote management and configuration can
+	perfectly complement the Eclipse Smart Home stack.
+	<li>Paho: As an MQTT extension is planned as a communication channel, Paho is the natural choice here.</li>
+	<li>Ponte: Ponte can be used as a uniform way of binding custom M2M devices and solutions to the Smart Home.</li>
+</ul>
+
+<h2>Initial Contribution</h2>
+
+The initial contribution of the Eclipse Smart Home project will be a large subset of the current code of
+openHAB (open Home Automation Bus). In particular:
+<ul>
+	<li>Source code for all mentioned interfaces and services of the framework</li>
+	<li>Source code of a couple of extensions (openHAB bindings, actions and persistence services)</li>
+	<li>Documentation of the architecture and its extension points</li>
+	<li>Build scripts and sample files</li>
+</ul>	
+
+<h2>Legal Issues</h2>
+
+<p>openHAB is currently available under GPLv3 license. The openHAB project owners will make the code base available under
+EPL (with the agreement of all contributors). Most dependencies of the openHAB core framework are already under EPL
+and even taken from Eclipse Orbit. For all other dependencies of the core framework, the project owners will go through
+the Eclipse legal review process to make sure that they are eligible for contribution.</p>
+
+<p>Many of the existing extensions (bindings, actions, etc.) include third-party libraries that might not be moved to
+Eclipse. As a result, only a small subset of these extensions will be contributed to the Eclipse Smart Home project
+while the rest will stay within the openHAB project.</p>
+
+<h2>Committers</h2>
+
+<p>The following individuals are proposed as initial committers to the project:</p>
+
+<dl>
+	<dt>Kai Kreuzer, Deutsche Telekom AG (Project lead)</dt>
+	<dt>Thomas Eichstädt-Engelen, innoQ Deutschland GmbH (Project co-lead)</dt>
+	<dt>Thomas Letsch, Thomas Letsch IT Solutions</dt>
+</dl>
+
+<p>We welcome additional committers and contributions.</p>
+
+<h2>Mentors</h2>
+
+<p>The following Architecture Council members will mentor this
+project:</p>
+
+<ul>
+	<li>Benjamin Cabé</li>
+	<li>Mike Milinkovich</li>
+</ul>
+
+<h2>Interested Parties</h2>
+
+<p>The following individuals, organisations, companies and projects have 
+expressed interest in this project:</p>
+
+<ul>
+	<li>Jochen Hiller, Deutsche Telekom AG</li>
+	<li>Lars Pfannenschmidt, Deutsche Telekom AG</li>
+</ul>
+
+<h2>Project Scheduling</h2>
+
+Eclipse Smart Home aims at the initial contribution to be completed by the end of 2013.
+A first release is planned early 2014, mainly based on the refactored initial contribution.
+
+<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>09-August-2013</td>
+		<td>Document created</td>
+	</tr>
+</table>
+</body>
+</html>
\ No newline at end of file
