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


<!-- Begin Introduction section -->

<h3>Buildroot: making Embedded Linux easy</h3>

<div align="center">
<a href="images/menuconfig.png">
 <img src="images/menuconfig_small.png" width="340" height="220"
 alt="Buildroot menuconfig" border="0">
</a>
</div>

<p>Buildroot is a set of Makefiles and patches that makes it easy to
generate a complete embedded Linux system. Buildroot can generate any
or all of a cross-compilation toolchain, a root filesystem, a kernel
image and a bootloader image. Buildroot is useful mainly for people
working with small or embedded systems, using various CPU
architectures (x86, ARM, MIPS, PowerPC, etc.) : it automates the
building process of your embedded system and eases the
cross-compilation process.</p>

<p>The major Buildroot features are:</p>

<ul>

  <li>Can <b>handle everything</b> in your embedded system development
  project: cross-compiling toolchain, root filesystem generation,
  kernel image compilation and bootloader compilation. Buildroot is
  also sufficiently flexible that it can also be used for only one or
  several of these steps.</li>

  <li>Is <b>very easy</b> to set up, thanks to its menuconfig, gconfig
  and xconfig configuration interfaces, familiar to all embedded Linux
  developers. Building a basic embedded Linux system with Buildroot
  typically takes 15-30 minutes.</li>

  <li>Supports <b>several hundreds of packages</b> for userspace
  applications and libraries: X.org stack, Gtk2, Qt, DirectFB, SDL,
  GStreamer and a large number of network-related and system-related
  utilities and libraries are supported.</li>

  <li>Supports <b>multiple filesystem types</b> for the root
  filesystem image: JFFS2, UBIFS, tarballs, romfs, cramfs, squashfs
  and more.</li>

  <li>Can generate an uClibc cross-compilation toolchain, or re-use
  your existing glibc, eglibc or uClibc cross-compilation
  toolchain</li>

  <li>Has a <b>simple structure</b> that makes it easy to understand
  and extend. It relies only on the well-known Makefile language.</li>

</ul>

<p>Buildroot is maintained by <a href=
"mailto:jacmet@uclibc.org">Peter Korsgaard</a>, and licensed under the
<a href="http://www.gnu.org/licenses/old-licenses/gpl-2.0.html">GNU
GENERAL PUBLIC LICENSE V2 (Or later)</a>. Stable releases are
delivered every three months.</p>


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