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


<ul>

  <li><b>26 July 2004 -- BusyBox 1.0.0-rc2 released</b><p>

    Here goes release candidate 2...
    <p>
    The <a href="downloads/Changelog">changelog</a> has all the details.
    And as usual you can <a href="downloads">download busybox here</a>.

    <p>Have Fun!

  <p>
  <li><b>20 July 2004 -- BusyBox 1.0.0-rc1 released</b><p>

    Here goes release candidate 1...  This fixes all (most?) of the problems
    that have turned up since -pre10.  In particular, loading and unloading of
    kernel modules with 2.6.x kernels should be working much better.
    <p>

    I <b>really</b> want to get BusyBox 1.0.0 released soon and I see no real
    reason why the 1.0.0 release shouldn't happen with things pretty much as
    is.  BusyBox is in good shape at the moment, and it works nicely for
    everything that I'm doing with it.  And from the reports I've been getting,
    it works nicely for what most everyone else is doing with it as well.
    There will eventually be a 1.0.1 anyway, so we might as well get on with
    it.  No BusyBox is not perfect.  No piece of software ever is.  And while
    there is still plenty that can be done to improve things, most of that work
    is waiting till we can get a solid 1.0.0 release out the door....
    <p>

    Please do not bother to send in patches adding cool new features at this
    time.  Only bug-fix patches will be accepted.  If you have submitted a
    bug-fixing patch to the busybox mailing list and no one has emailed you
    explaining why your patch was rejected, it is safe to say that your patch
    has been lost or forgotten.  That happens sometimes.  Please re-submit your
    bug-fixing patch to the BusyBox mailing list, and be sure to put "[PATCH]"
    at the beginning of the email subject line!

    <p>
    The <a href="downloads/Changelog">changelog</a> has all the details.
    And as usual you can <a href="downloads">download busybox here</a>.

    <p>Have Fun!

    <p>
    On a less happy note, My 92 year old grandmother (my dad's mom) passed away
    yesterday (June 19th).  The funeral will be Thursday in a little town about
    2 hours south of my home.  I've checked and there is absolutely no way I
    could be back in time for the funeral if I attend <a
    href="http://www.linuxsymposium.org/2004/">OLS</a> and give my presentation
    as scheduled.
    <p>
    As such, it is with great reluctance and sadness that I have come
    to the conclusion I will have to make my appologies and skip OLS
    this year.
    <p>


  <p>
  <li><b>13 April 2004 -- BusyBox 1.0.0-pre10 released</b><p>

    Ok, I lied.  It turns out that -pre9 will not be the final BusyBox
    pre-release.  With any luck however -pre10 will be, since I <b>really</b>
    want to get BusyBox 1.0.0 released very soon.  As usual, please do not
    bother to send in patches adding cool new features at this time.  Only
    bug-fix patches will be accepted.  It would also be <b>very</b> helpful if
    people could continue to review the BusyBox documentation and submit
    improvements.

    <p>
    The <a href="downloads/Changelog">changelog</a> has all the details.
    And as usual you can <a href="downloads">download busybox here</a>.

    <p>Have Fun!
    <p>


  <p>
  <li><b>6 April 2004 -- BusyBox 1.0.0-pre9 released</b><p>

    Here goes the final BusyBox pre-release...  This is your last chance for
    bug fixes.  With luck this will be released as BusyBox 1.0.0 later this
    week.  Please do not bother to send in patches adding cool new features at
    this time.  Only bug-fix patches will be accepted.  It would also be
    <b>very</b> helpful if people could help review the BusyBox documentation
    and submit improvements.  I've spent a lot of time updating the
    documentation to make it better match reality, but I could really use some
    assistance in checking that the features supported by the various applets
    match the features listed in the documentation.

    <p>
    I had hoped to get this released a month ago, but
    <a href="http://codepoet.org/gallery/baby_peter/img_1796">
    another release on 1 March 2004</a> has kept me busy...

    <p>
    The <a href="downloads/Changelog">changelog</a> has all the details.
    And as usual you can <a href="downloads">download busybox here</a>.

    <p>Have Fun!
    <p>


  <p>
  <li><b>23 February 2004 -- BusyBox 1.0.0-pre8 released</b><p>

    Here goes yet another BusyBox pre-release...  Please do not bother to send
    in patches supplying new features at this time.  Only bug-fix patches will
    be accepted.  If you have a cool new feature you would like to see
    supported, or if you have an amazing new applet you would like to submit,
    please wait and submit such things later.  We really want to get a release
    out we can all be proud of.  We are still aiming to finish off the -pre
    series in February and move on to the final 1.0.0 release...  So if you
    spot any bugs, now would be an excellent time to send in a fix to the
    busybox mailing list.  It would also be <b>very</b> helpful if people could
    help review the BusyBox documentation and submit improvements.  It would be
    especially helpful if people could check that the features supported by the
    various applets match the features listed in the documentation.

    <p>

    The <a href="downloads/Changelog">changelog</a> has all the details.
    And as usual you can <a href="downloads">download busybox here</a>.

    <p>Have Fun!
    <p>


    <p>
    <li><b>Old News</b><p>
    <a href="/oldnews.html">Click here to read older news</a>


</ul>

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

