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


<!-- Begin Introduction section -->

<h3>BusyBox: The Swiss Army Knife of Embedded Linux</h3>


BusyBox combines tiny versions of many common UNIX utilities into a single
small executable. It provides replacements for most of the utilities you
usually find in GNU fileutils, shellutils, etc. The utilities in BusyBox
generally have fewer options than their full-featured GNU cousins; however,
the options that are included provide the expected functionality and behave
very much like their GNU counterparts.  BusyBox provides a fairly complete
environment for any small or embedded system.

<p>

BusyBox has been written with size-optimization and limited resources in
mind. It is also extremely modular so you can easily include or exclude
commands (or features) at compile time. This makes it easy to customize
your embedded systems. To create a working system, just add some device
nodes in /dev, a few configuration files in /etc, and a Linux kernel.

<p>

BusyBox is maintained by <a href=
"http://codepoet.org/andersen/erik/erik.html">Erik Andersen</a>, and
licensed under the
<a href= "http://www.gnu.org/copyleft/gpl.html">GNU GENERAL PUBLIC LICENSE</a>

<p>
<p>

<h3>Sponsors</h3>

Please visit our sponsors and thank them for their
support! They have provided money for equipment and
bandwidth. Next time you need help with a project,
consider these fine companies!


<ul>
  <li><a href="http://www.penguru.net">Penguru Consulting</a><br>
  Custom development for embedded Linux systems and multimedia platforms
  </li>

  <li><a href="http://opensource.se/">opensource.se</a><br>
  Embedded open source consulting in Europe.
  </li>

  <li><a href="http://www.codepoet-consulting.com">Codepoet Consulting</a><br>
  Custom Linux, embedded Linux, BusyBox, and uClibc
  development.
  </li>

</ul>

If you wish to be a sponsor, or if you have already contributed and would like
your name added here, email <a href= "mailto:andersen@codepoet.org">Erik</a>.


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