<!--#include file="header.html" -->

<div class="container">
<div class="row nh">
<div class="col-lg-10 col-lg-offset-1 col-md-12 col-sm-12 col-xs-12">

  <div class="panel panel-primary">
    <div class="panel-heading">Support</div>
    <div class="panel-body">
      <p>You can get support for Buildroot through three main channels:</p>

      <div class="row">
	<div class="col-sm-12">
	  <div class="panel panel-primary">
	    <div class="panel-heading">IRC</div>
	    <div class="panel-body">
	      <div class="row">
		<div class="col-sm-1">
		  <img class="img-responsive" src="images/irc.png" style="max-width:50px; margin-bottom:10px;">
		</div>
		<div class="col-sm-11">
		  <p>The Buildroot IRC channel is <a href="irc://irc.oftc.net/#buildroot">
		      #buildroot</a>, hosted on OFTC. If you do not have an IRC client, you can
		    use the <a href="https://www.oftc.net/WebChat/">OFTC web interface</a>. The
		    channel is also bridged to matrix as <a href="https://matrix.to/#/#_oftc_#buildroot:matrix.org">
		      #_oftc_#buildroot:matrix.org</a>.
		    When asking for help on IRC, share relevant logs or pieces of code using a code
		    sharing website.</p>

		  <p>Note that due to excessive spamming on IRC, you can only talk in the
		    channel if you are a registered user with
		    <a href="https://www.oftc.net/Services/">OFTC NickServ</a>
		    service. Follow the instructions to register as a user with a password,
		    and then join the <code>#buildroot</code> channel.</p>
		</div>
	      </div>
	    </div>
	  </div>
	</div>

	<div class="col-sm-12">
	  <div class="panel panel-primary">
	    <div class="panel-heading">Mailing List Information</div>
	    <div class="panel-body">
	      <div class="row">
		<div class="col-sm-1">
		  <img class="img-responsive" src="images/email.png" style="max-width:50px; margin-bottom:10px;">
		</div>
		<div class="col-sm-11">
		  <p>The mailing list is for discussion and
		    development.  You can subscribe by visiting
		    <a href="http://lists.buildroot.org/mailman/listinfo/buildroot">this
		    page</a>.  Only subscribers to the Buildroot
		    mailing list are allowed to post to this
		    list. Archives are available
		    from <a href="/lists/buildroot/">Mailman</a>
		    and <a href="https://lore.kernel.org/buildroot/">lore.kernel.org</a>.

		  <h4>Search the List Archives</h4>
		  <p>Please search the mailing list archives before asking questions on the mailing
		    list, since there is a good chance someone else has asked the same question
		    before.</p>

		  <form method="get" action="https://lore.kernel.org/buildroot/">
		    <input type="text" name="q">
		    <button type="submit" class="btn btn-default">Submit</button>
		  </form>
		</div>
	      </div>
	    </div>
	  </div>
	</div>

	<div class="col-sm-12">
	  <div class="panel panel-primary">
	    <div class="panel-heading">Bug Tracker</div>
	    <div class="panel-body">
	      <div class="row">
		<div class="col-sm-1">
		  <img class="img-responsive" src="images/bug-buddy.png" style="max-width:50px; margin-bottom:10px;">
		</div>
		<div class="col-sm-11">
		  <p>If you think you found a bug in Buildroot, you can use the
		    <a href="https://gitlab.com/buildroot.org/buildroot/-/issues">Bug Tracker</a> to post your bugs and/or
		    participate to find solutions to existing problems.</p>

		  <p>Note: patches are only accepted through the mailing list.</p>
		</div>
	      </div>
	    </div>
	  </div>
	</div>
      </div>
    </div>
  </div>

  <div class="panel panel-primary">
    <div class="panel-heading">Buildroot LTS</div>
    <div class="panel-body">
      <p>Buildroot's Long Term Support (LTS) branch is maintained thanks to the
	<a href="https://mind.be/buildroot-lts">LTS Sponsoring program</a>. Its
	goal is	to provide three or more years of stable support for your
	Buildroot deployments. The success of this venture depends on the
	generosity of sponsors like you, willing to make a change and ensuring
	the longevity of Buildroot's reliability.</p>
      <p>Prior to this initiative, LTS maintenance was handled by volunteers.
        As a result, it was limited to just one year. In addition, it diverted
        maintainer time away from mainline development, slowing  down the overall
        progress of the project.</p>
      <p>Thanks to LTS sponsoring, the entire community gets access to a better
        and longer maintained LTS branch. The sponsors get access to some
        additional perks, such as selecting which packages to focus on, reports
        with information that is relevant for you, and direct contact with the
        LTS maintainers.</p>
      <p style="text-align: center;"><a href="https://mind.be/buildroot-lts">Ready
        to sponsor?</a></p>
    </div>
  </div>

  <div class="panel panel-primary">
    <div class="panel-heading">Commercial support</div>
    <div class="panel-body">
      <p>In addition, the following companies are able to provide commercial
	 support. Only companies heavily involved in Buildroot maintenance and
	 community are listed here.</p>

      <div class="row">
	<div class="col-sm-12">
	  <center>
	    <a href="https://bootlin.com/engineering/">
	      <img src="images/bootlin-logo.png" style="max-width:200px; margin-right:40px;"/>
	    </a>
	    <a href="https://mind.be/about-us/#anchor-open-source">
	      <img src="images/mind-logo.png" style="max-width:200px; margin-right:40px;"/>
	    </a>
	    <a href="https://www.smile.eu/en/offers/embedded-iot">
	      <img src="images/smile-logo.png" style="max-width:200px; margin-right:40px;"/>
	    </a>
	    <a href="https://www.amarulasolutions.com/services/integrated-system/">
	      <img src="images/amarula-solutions-logo.png" style="max-width:200px; margin-right:40px;"/>
	    </a>
	  </center>
	</div>
      </div>
    </div>
  </div>

</div><!--/.col-sm-10 -->
</div><!--/.row -->
</div>

<!--#include file="footer.html" -->
