<div class="wiki-content maincontent"><h2 id="HowcanIcontribute-HowcanIcontributetoApacheActiveMQ?">How can I contribute to Apache ActiveMQ?</h2>

There are many ways you can help make ActiveMQ a better piece of software - please dive in and help!<p>Try surf the documentation - if somethings confusing or not clear, let us know. Download the code &amp; try it out and see what you think. Browse the source code. Got an itch to scratch, want to tune some operation or add some feature?</p><p>Want to do some hacking on ActiveMQ? Try surfing to our <a shape="rect" class="external-link" href="http://issues.apache.org/jira/browse/AMQ">issue tracker</a> for open issues or features that need to be implemented, take ownership of an issue and try fix it.</p><h2 id="HowcanIcontribute-Gettingintouch">Getting in touch</h2><p>There are various ways of communicating with the ActiveMQ community.</p><ul class="alternate"><li>join us on the <a shape="rect" href="discussion-forums.html">Discussion Forums</a> or subscribe to the <a shape="rect" href="mailing-lists.html">Mailing Lists</a> and take part in any conversations</li><li><p>pop by on <span>in <a shape="rect" href="irc.html">irc</a> and say hi</span></p></li><li>add some comments to the <a shape="rect" href="navigation.html">wiki</a></li></ul><h2 id="HowcanIcontribute-Ifyoufindabugorproblem">If you find a bug or problem</h2><p>Please raise a new issue in our <a shape="rect" class="external-link" href="https://issues.apache.org/jira/browse/AMQ">issue tracker</a></p><p>If you can create a JUnit test case then your issue is more likely to be resolved quicker.<br clear="none"> e.g. take a look at some of the existing <a shape="rect" class="external-link" href="https://git-wip-us.apache.org/repos/asf?p=activemq.git;a=tree;f=activemq-unit-tests/src/test;h=185a655c5200ed30fd2964bc236c18c5bde534c4;hb=refs/heads/master">unit tests cases</a></p><p>Then we can add your issue to the test suite and then we'll know when its really fixed and we can ensure that the problem <strong>stays fixed</strong> in future releases.</p><h2 id="HowcanIcontribute-Ifyouwanttohelpoutwiththedocumentation">If you want to help out with the documentation</h2><p>If you want to contribute to the ActiveMQ documentation you should first subscribe our <a shape="rect" class="external-link" href="mailto:dev-subscribe@activemq.apache.org" rel="nofollow">dev@</a>&#160;where ActiveMQ developers interact with each other. If you want edit rights on the ActiveMQ site, create an account in the <a shape="rect" href="https://cwiki.apache.org/confluence/display/ACTIVEMQ">ActiveMQ wiki</a> and fill in and submit an ICLA to the ASF (see the&#160;<a shape="rect" href="becoming-a-committer.html">Committer Guide</a>). Then ask on the dev@ list to be granted edit rights and an admin will do so fairly quickly. If you want to just contribute the content, please submit the content on the dev@ list or create an issue and attach it there. <strong>All</strong> contributions are highly appreciated.</p><h2 id="HowcanIcontribute-Workingonthecode">Working on the code</h2><p>Grab the <a shape="rect" href="source.html">Source</a> from git</p><p>Build the project.</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<pre class="brush: java; gutter: false; theme: Default" style="font-size:12px;">export MAVEN_OPTS="-Xmx512M -XX:MaxPermSize=128M"
mvn -Dtest=false install
</pre>
</div></div><p>PS: You might need to build multiple times (if you get a build error) because sometimes maven fails to download all the files.</p><p>Create a project in your IDE. e.g. if you are using Eclipse the following should do the trick.</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<pre class="brush: java; gutter: false; theme: Default" style="font-size:12px;">mvn eclipse:eclipse
</pre>
</div></div><p>Then import the projects into your workspace.</p><h2 id="HowcanIcontribute-Creatingpatches">Creating patches</h2><p>We gladly accept patches if you can find ways to improve, tune or fix ActiveMQ in some way.</p><p>Most IDEs can create nice patches now very easily. e.g. in Eclipse just right click on a file/directory and select Team -&gt; Create Patch. Then just save the patch as a file and then submit it. (You may have to click on Team -&gt; Share... first to enable the Subversion options).</p><p>If you're a command line person try the following to create the patch</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<pre class="brush: java; gutter: false; theme: Default" style="font-size:12px;">diff -u Main.java.orig Main.java &gt;&gt; patchfile.txt
</pre>
</div></div><p>or</p><div class="code panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<pre class="brush: java; gutter: false; theme: Default" style="font-size:12px;">git diff Main.java &gt;&gt; patchfile.txt
</pre>
</div></div><h2 id="HowcanIcontribute-Submittingpatches">Submitting patches</h2><p>The easiest way to submit a patch is to create a new JIRA issue, attach the patch and tick the ASF license grant check box, tick the Patch Attached button on the issue then fire off an email to the <a shape="rect" href="mailing-lists.html">Mailing Lists</a> or <a shape="rect" href="discussion-forums.html">Discussion Forums</a>.</p><h2 id="HowcanIcontribute-Becomingacommmitter">Becoming a commmitter</h2><p>Once you've got involved as above, we may well invite you to be a committer. See <a shape="rect" href="becoming-a-committer.html">Becoming a committer</a> for more details.</p><h2 id="HowcanIcontribute-Usingtheissuetracker">Using the issue tracker</h2><p>Before you can raise an issue in the issue tracker you need to register with it. This is quick &amp; painless.</p><p>If you want to have a go at fixing an issue you need to be in the list of activemq-developers on the issue tracker. To join the group, please mail the&#160;<a shape="rect" class="external-link" href="mailto:dev@activemq.apache.org" rel="nofollow">dev@activemq.apache.org</a> mail list with the email address you used to register with the issue tracker and we'll add you to the group.</p><p>Why not dive in the <a shape="rect" class="external-link" href="https://issues.apache.org/jira/browse/AMQ">issue tracker</a>, and try tackle some of our outstanding issues?</p><h2 id="HowcanIcontribute-Becomingacommitter">Becoming a committer</h2><p>The first step is contributing to the project; if you want to take that a step forward and become a fellow committer on the project then see the <a shape="rect" href="becoming-a-committer.html">Committer Guide</a></p></div>

