diff --git a/home/page/attributions/attributions.html b/home/page/attributions/attributions.html
index 07da9fd..2d08c79 100644
--- a/home/page/attributions/attributions.html
+++ b/home/page/attributions/attributions.html
@@ -27,6 +27,10 @@
 			<td>The Number One HTTP Server On The Internet.</td>
 		</tr>
 		<tr>
+			<td><a href="http://memcached.org/">Memcached</a></td>
+			<td>Free & open source, high-performance, distributed memory object caching system.</td>
+		</tr>
+		<tr>
 			<td><a href="http://python.org/">Python Programming Language</a></td>
 			<td>The "batteries included" language that lets you write elegant code, quickly.<br><br>Python Libraries:
 			<ul>
diff --git a/website/doctype/style_settings/custom_template.css b/website/doctype/style_settings/custom_template.css
index a67c9f1..00c02bb 100644
--- a/website/doctype/style_settings/custom_template.css
+++ b/website/doctype/style_settings/custom_template.css
@@ -12,7 +12,7 @@
 	background-color: #edede7;
 {% endif %}	
 {% if doc.font or doc.google_web_font_for_text %}
-	font-family: '{{ doc.google_web_font_for_text or doc.font }}', Verdana, Sans !important;
+	font-family: '{{ doc.google_web_font_for_text or doc.font }}', 'Helvetica Neue', Arial, Sans !important;
 {% endif %}
 {% if doc.font_size %}
 	font-size: {{ doc.font_size }} !important;
@@ -31,7 +31,7 @@
 
 {% if doc.google_web_font_for_heading or doc.heading_font %}
 h1, h2, h3, h4, h5 {
-	font-family: '{{ doc.google_web_font_for_heading or doc.heading_font }}', Arial, 'Helvetica Neue' !important;
+	font-family: '{{ doc.google_web_font_for_heading or doc.heading_font }}', 'Helvetica Neue', Arial !important;
 }
 {% endif %}
 {% if doc.heading_text_style %}
diff --git a/website/templates/html/slideshow.html b/website/templates/html/slideshow.html
index 8641724..e0e9038 100644
--- a/website/templates/html/slideshow.html
+++ b/website/templates/html/slideshow.html
@@ -5,10 +5,12 @@
 		{% for slide in obj.slides %}
 		<div class="{% if slide.idx==1 %}active {% endif %}item">
 			<img src="{{ slide.image }}" />
+			{% if slide.heading or slide.description %}
 			<div class="carousel-caption">
-				<h4>{{ slide.heading }}</h4>
-				<p>{{ slide.description }}</p>
+				{% if slide.heading %}<h4>{{ slide.heading }}</h4>{% endif %}
+				{% if slide.heading %}<p>{{ slide.description }}</p>{% endif %}
 			</div>
+			{% endif %}
 		</div>
 		{% endfor %}
 	</div>
diff --git a/website/templates/pages/attributions.html b/website/templates/pages/attributions.html
index 2d195ba..9e4b50d 100644
--- a/website/templates/pages/attributions.html
+++ b/website/templates/pages/attributions.html
@@ -12,7 +12,7 @@
 
 {% block content %}
 <div class="layout-attributions span12">
-	<h3>This website is made using these Awesome Open Source Projects <i class="icon-heart" style="color: red"></i></h3>
+	<h3>This website is made using these awesome Open Source projects <i class="icon-heart" style="color: red"></i></h3>
 	<hr>
 	<table class="table table-bordered table-striped">
 		<tbody>
@@ -38,6 +38,10 @@
 			<td>The Number One HTTP Server On The Internet.</td>
 		</tr>
 		<tr>
+			<td><a href="http://memcached.org/">Memcached</a></td>
+			<td>Free & open source, high-performance, distributed memory object caching system.</td>
+		</tr>
+		<tr>
 			<td><a href="http://python.org/">Python Programming Language</a></td>
 			<td>The "batteries included" language that lets you write elegant code, quickly.<br><br>Python Libraries:
 			<ul>
@@ -81,6 +85,10 @@
 			<td>A lightning fast JavaScript grid/spreadsheet.</td>
 		</tr>		
 		<tr>
+			<td><a href="http://arshaw.com/fullcalendar/">FullCalendar</a></td>
+			<td>FullCalendar is a jQuery plugin that provides a full-sized, drag and drop calendar.</td>
+		</tr>
+		<tr>
 			<td><a href="http://www.flotcharts.org/">Flot Charting Library</a></td>
 			<td>Attractive JavaScript plotting for jQuery.</td>
 		</tr>		
@@ -97,12 +105,36 @@
 			<td>HTML/Javascript Color Picker.</td>
 		</tr>
 		<tr>
+			<td><a href="http://qunitjs.com/">QUnit</a></td>
+			<td>A JavaScript Unit Testing framework.</td>
+		</tr>
+		<tr>
 			<td><a href="https://github.com/dcneiner/Downloadify">Downloadify - Flash Download Widget</a></td>
 			<td>A tiny javascript + Flash library that enables the creation and download of text files without server interaction.</td>
 		</tr>				
 		</tbody>
 	</table>
+	
+	<hr>
+	<h3>ERPNext License: GNU/General Public License</h3>
+	<div class="well">
+	<p><b>ERPNext - Open Source, web based ERP</b></p>
+	<p>Copyright &copy; 2012, Web Notes Technologies Pvt Ltd, India</p>
 
-	<p class="alert">Note: A link to this page must be easily accessible.</p>
+	<p>This program is free software: you can redistribute it and/or modify
+	    it under the terms of the <b>GNU General Public License</b> as published by
+	    the Free Software Foundation, either version 3 of the License, or
+	    (at your option) any later version.</p>
+
+	    <p>This program is distributed in the hope that it will be useful,
+	    but WITHOUT ANY WARRANTY; without even the implied warranty of
+	    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	    GNU General Public License for more details.</p>
+
+ 		<p>For complete license see <a href="http://www.gnu.org/licenses/">http://www.gnu.org/licenses/</a></p>
+	</div>
+	<p class="alert">Note: A link to this page must be easily accessible and all other ERPNext branding must remain as it is.</p>
+	<hr>
+	<p>For more information please write to us at support@erpnext.com</p>
 </div>
 {% endblock %}
\ No newline at end of file
