diff --git a/website/templates/html/base.html b/website/templates/html/base.html
deleted file mode 100644
index cfba1a5..0000000
--- a/website/templates/html/base.html
+++ /dev/null
@@ -1,25 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-	<meta charset="utf-8">
-	<meta name="viewport" content="width=device-width, initial-scale=1.0">
-	<title>{{ title }}</title>
-	<meta name="generator" content="wnframework">
-	<script type="text/javascript" src="lib/js/lib/jquery/jquery.min.js"></script>
-	<script type="text/javascript" src="js/all-web.min.js"></script>
-	<script type="text/javascript" src="js/wn-web.js"></script>
-	<link type="text/css" rel="stylesheet" href="css/all-web.css">
-	<link type="text/css" rel="stylesheet" href="css/wn-web.css">
-	<link rel="shortcut icon" href="{{ favicon }}" type="image/x-icon">
-	<link rel="icon" href="{{ favicon }}" type="image/x-icon">
-	{% if description -%}
-	<meta name="description" content="{{ description }}">	
-	{%- endif %}
-	{% block header -%}
-	{%- endblock %}
-</head>
-<body>
-	{% block body %}
-	{% endblock %}
-</body>
-</html>
\ No newline at end of file
diff --git a/website/templates/html/blog_page.html b/website/templates/html/blog_page.html
index 270d427..cf1f00e 100644
--- a/website/templates/html/blog_page.html
+++ b/website/templates/html/blog_page.html
@@ -1,11 +1,11 @@
-{% extends "html/page.html" %}
+{% extends "app/website/templates/html/page.html" %}
 
 {% block javascript %}
-	{% include "js/blog_page.js" %}
+	{% include "app/website/templates/js/blog_page.js" %}
 {% endblock %}
 
 {% block css %}
-	{% include "css/blog_page.css" %}
+	{% include "app/website/templates/css/blog_page.css" %}
 {% endblock %}
 
 {% block content %}
@@ -23,7 +23,7 @@
 	<!-- end blog content -->
 	{% if blogger_info %}
 	<hr />
-	{% include "html/blogger.html" %}
+	{% include "app/website/templates/html/blogger.html" %}
 	{% endif %}
 	<hr>
 	<h3>{{ texts.comments }}</h3><br>
@@ -35,7 +35,7 @@
 		</div>
 		{% endif %}
 		
-		{% include 'html/comment.html' %}
+		{% include 'app/website/templates/html/comment.html' %}
 	</div>
 	<div><button class="btn add-comment">{{ texts.add_comment }}</button></div>
 	<div style="display: none; margin-top: 10px;" 
@@ -52,5 +52,5 @@
 		</form>
 	</div>
 </div>
-{% include 'html/blog_footer.html' %}
+{% include 'app/website/templates/html/blog_footer.html' %}
 {% endblock %}
\ No newline at end of file
diff --git a/website/templates/html/outer.html b/website/templates/html/outer.html
index 624371e..570c769 100644
--- a/website/templates/html/outer.html
+++ b/website/templates/html/outer.html
@@ -1,4 +1,4 @@
-{% extends "html/base.html" %}
+{% extends "lib/templates/base.html" %}
 
 {% block body %}
 	<div class="container">
@@ -10,13 +10,13 @@
 			<div class="span12">{{ banner_html }}</div>
 		</div>{% endif %}
 		<div class="outer">
-			{% include "html/navbar.html" %}
+			{% include "app/website/templates/html/navbar.html" %}
 			<div class="content row" id="page-{{ name }}" style="display: block;">
 			{%- block content -%}
 			{%- endblock -%}
 			</div>
 		</div>
 	</div>
-	{% include "html/footer.html" %}
+	{% include "app/website/templates/html/footer.html" %}
 
 {% endblock %}
\ No newline at end of file
diff --git a/website/templates/html/page.html b/website/templates/html/page.html
index 9d38cdc..c9fbec4 100644
--- a/website/templates/html/page.html
+++ b/website/templates/html/page.html
@@ -1,4 +1,4 @@
-{% extends "html/outer.html" %}
+{% extends "app/website/templates/html/outer.html" %}
 
 {% block title -%}{{ title }}{%- endblock %}
 
diff --git a/website/templates/html/product_group.html b/website/templates/html/product_group.html
index 510f994..b3c8511 100644
--- a/website/templates/html/product_group.html
+++ b/website/templates/html/product_group.html
@@ -1,11 +1,11 @@
-{% extends "html/page.html" %}
+{% extends "app/website/templates/html/page.html" %}
 
 {% block content %}
-{% include 'html/product_search_box.html' %}
-{% include 'html/product_breadcrumbs.html' %}
+{% include 'app/website/templates/html/product_search_box.html' %}
+{% include 'app/website/templates/html/product_breadcrumbs.html' %}
 <div class="span12">
 	{% if slideshow %}<!-- slideshow -->
-	{% include "html/slideshow.html" %}
+	{% include "app/website/templates/html/slideshow.html" %}
 	{% endif %}
 	{% if description %}<!-- description -->
 	<div>{{ description or ""}}</div>
diff --git a/website/templates/html/product_in_list.html b/website/templates/html/product_in_list.html
index bc62607..5cd9eac 100644
--- a/website/templates/html/product_in_list.html
+++ b/website/templates/html/product_in_list.html
@@ -4,7 +4,7 @@
 		{%- if website_image -%}
 		<img class="product-image" style="width: 80%; margin: auto;" src="{{ website_image }}">
 		{%- else -%}
-		{% include 'html/product_missing_image.html' %}
+		{% include 'app/website/templates/html/product_missing_image.html' %}
 		{%- endif -%}
 		</a>
 	</div>
diff --git a/website/templates/html/product_page.html b/website/templates/html/product_page.html
index f897a31..23091ad 100644
--- a/website/templates/html/product_page.html
+++ b/website/templates/html/product_page.html
@@ -1,28 +1,28 @@
-{% extends "html/page.html" %}
+{% extends "app/website/templates/html/page.html" %}
 
 {% block javascript %}
-	{% include "js/product_page.js" %}
+	{% include "app/website/templates/js/product_page.js" %}
 {% endblock %}
 
 {% block css %}
-	{% include "css/product_page.css" %}
+	{% include "app/website/templates/css/product_page.css" %}
 {% endblock %}
 
 {% block content %}
-	{% include 'html/product_search_box.html' %}
-	{% include 'html/product_breadcrumbs.html' %}
+	{% include 'app/website/templates/html/product_search_box.html' %}
+	{% include 'app/website/templates/html/product_breadcrumbs.html' %}
 	<div class="span12 product-page-content" itemscope itemtype="http://schema.org/Product">
 		<div class="row">
 			<div class="span6">
 				{% if slideshow %}
-					{% include "html/slideshow.html" %}
+					{% include "app/website/templates/html/slideshow.html" %}
 				{% else %}
 					{% if website_image %}
 					<image itemprop="image" class="item-main-image"
 						src="{{ website_image }}" />
 					{% else %}
 					<div class="img-area">
-						{% include 'html/product_missing_image.html' %}
+						{% include 'app/website/templates/html/product_missing_image.html' %}
 					</div>
 					{% endif %}
 				{% endif %}
diff --git a/website/templates/html/web_page.html b/website/templates/html/web_page.html
index d3c646a..6b8c914 100644
--- a/website/templates/html/web_page.html
+++ b/website/templates/html/web_page.html
@@ -1,4 +1,4 @@
-{% extends "html/page.html" %}
+{% extends "app/website/templates/html/page.html" %}
 
 {% block javascript %}
 	{% if insert_code %}
@@ -8,7 +8,7 @@
 
 {% block content %}
 <div class="span12" style="margin-top: 15px;">
-	{% include "html/slideshow.html" %}
+	{% include "app/website/templates/html/slideshow.html" %}
 	{{ main_section }}
 </div>
 {% endblock %}
\ No newline at end of file
