diff --git a/src/site/xdoc/install.xml b/src/site/xdoc/install.xml
index f0b5b52..82572c2 100644
--- a/src/site/xdoc/install.xml
+++ b/src/site/xdoc/install.xml
@@ -60,6 +60,30 @@
 </pre>
 				
 			</subsection>
+
+			<subsection name="From Composer">
+			
+				<p>Apache log4php is available from <a href="https://packagist.org/packages/apache/log4php">Packagist</a> via <a href="http://getcomposer.org/">Composer</a>. Please note: this channel is not an official Apache Software Foundation channel,
+				but maintained from Apache log4php committers.</p>
+				
+				<p>To with compoers, add the following lines to composer.json:</p>
+			
+<pre>
+"require": {
+    "apache/log4php": "2.3.0"
+}
+</pre>
+				<p>Then run:</p>
+
+<pre>
+php composer.phar install
+</pre>
+				<p>Or, if you have composer installed as binary:</p>
+
+<pre>
+composer install
+</pre>								
+			</subsection>
 		</section>
 	</body>
 </document>
