<div class="wiki-content maincontent"><p>TLP Description:</p><p>Apache ActiveMQ is a popular and powerful open source messaging server. Apache ActiveMQ is fast, supports many Cross Language Clients and Protocols, comes with easy to use Enterprise Integration Patterns and many advanced features while fully supporting JMS 1.1 and J2EE 1.4.</p><p>Community:</p><ul><li>The development and user lists continue to stay active.</li><li>Most SCM roots in ActiveMQ have switched from SVN to Git.</li></ul><p>Development:</p><ul><li>It's been a busy quarter preparing for the The ActiveMQ 5.9 release. It should be done soon!</li></ul><p>Trademark / Branding Status:</p><ul><li>Sub-projects need to be reviewed to make sure they are also compliant /w TM policies</li><li>Documentation and readme files will also be reviewed for compliance</li></ul><p>Releases:</p><ul><li>ActiveMQ-CPP v3.8.1 - Sep 19th 2013</li><li>ActiveMQ-CPP v3.8.0 - Sep 6th 2013</li></ul></div>

