<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  <title>Apache OpenOffice - News</title>
  <style type="text/css">
  /* <![CDATA[ */
  /*-------------------- Exceptions on standard css -----------------------*/
  @import "/css/styles.css";
  @import "/css/exceptions.css";
  /* ]]> */

  <!--
  #navcol { visibility: hidden; }
  #navcol { visibility: hidden; }

  #navigation li.th a { background: url(/branding/images/tab-left.png) no-repeat left top #F0F5FE; }
  #navigation li.th a span { background: url(/branding/images/tab-right.png) no-repeat right top #F0F5FE; }

  #navigation li#maintabnews a { float: left; background: url(/branding/images/tab-left.png) no-repeat left -100px #FFF; }
  #navigation li#maintabnews a span { background: url(/branding/images/tab-right.png) no-repeat right -100px #FFF; }
  -->
  </style>
</head>

<body>

<h1>Archived News from Apache OpenOffice</h1>

  <a id="aoo400"></a>
  <h2>Apache OpenOffice 4.0 is now available for download!</h2>
  <p><em>23 July 2013:</em> Following a continuous time of improvement, we are proud to
  <a href="https://blogs.apache.org/OOo/entry/a_short_celebration_and_then"
  title="Blog post of the new Apache OpenOffice 4.0 release">announce today the newest release of Apache OpenOffice</a>.
  It is out now and <a href="../download/index.html" title="Download Apache OpenOffice now!">available for download</a>.
  This is a major feature release, so make sure to check out the
  <a href="https://cwiki.apache.org/confluence/display/OOOUSERS/AOO+4.0+Release+Notes"
  title="Apache OpenOffice 4.0 Release Notes">Feature Overview</a> to learn more about the new features and all
  improvements.</p>

  <a id="apache-graduated"></a>
  <h2>Apache announces graduation status for Apache OpenOffice</h2>
  <p><em>19 October 2012:</em> Apache Software Foundation board has approved a resolution promoting
  <a href="https://blogs.apache.org/OOo/entry/openoffice_graduates_from_the_apache">Apache OpenOffice Podling to an Apache
  Top level project</a>.</p>

  <a id="one-mill-download"></a>
  <h2>Apache OpenOffice 3.4 Blows Past 1M Downloads</h2>
  <p><em>16 May 2012:</em> After last week's release of Apache OpenOffice 3.4, the project is pleased to note the strong
  positive reception by users and the press. <a href="aoo34-1M.html">Apache OpenOffice 3.4 has been downloaded over one
  million times!</a><p>

  <a id="apache-hosted"></a>
  <h2>www.openoffice.org is now hosted by the Apache Software Foundation</h2>
  <p>Our website has migrated to infrastructure hosted by the Apache Software Foundation. Join the 
  <a href="http://openoffice.apache.org/mailing-lists.html#users-mailing-list">Users Mailing List</a> or
  <a href="http://user.services.openoffice.org/">User Forums</a> if you have questions or comments
  </p>

  <a id="asf_statement"></a>
  <h2>The Apache Software Foundation Statement on Apache OpenOffice</h2>
  <p><em>14 October 2011:</em> On 1 June 2011, Oracle Corporation submitted the OpenOffice.org code base to The Apache
  Software Foundation. That submission was accepted, and the project is now being developed as a podling in the Apache
  Incubator under the ASF's meritocratic process informally dubbed "The Apache Way". OpenOffice.org is now officially part
  of the Apache family. The project is known as Apache OpenOffice. Over its 12-year history, the ASF has
  welcomed contributions from individuals and organizations alike, but, as a policy, does not solicit code donations. The
  OpenOffice.org code base was not pursued by the ASF prior to its acceptance into the Apache Incubator.
  <a href="http://blogs.apache.org/foundation/entry/the_apache_software_foundation_statement">
  Read the complete ASF annoncement</a>
  </p>

  <a id="asf_ooo_blog"></a>
  <h2>OpenOffice.org Blog at Apache</h2>
  <p><em>11 July 2011:</em> Keep up with latest developments in the OpenOffice.org to Apache project transition at the
  <a href="https://blogs.apache.org/OOo/">OpenOffice.org (OOo) blog.</a>
  </p>

  <a id="asfsetup"></a>
  <h2>OpenOffice.org is Established as an ASF Project</h2>
  <p><em>13 June 2011:</em> OpenOffice.org has now been accepted as an Apache incubator project. Details
  and further participation in the OpenOffice.org project can be found at the new 
  <a href="http://incubator.apache.org/projects/openofficeorg.html">incubator site.</a>
  </p>

  <a id="join-incubator"></a>
  <h2>OpenOffice.org Joins Apache Incubator</h2>
  <p><em>1 June 2011:</em> On June 1, 2011, Oracle announced that it was donating OpenOffice.org's code to 
  <a href="http://www.marketwire.com/press-release/statements-on-openofficeorg-contribution-to-apache-nasdaq-orcl-1521400.htm">
  The Apache Software Foundation's Incubator.</a> 
  The Apache OpenOffice "podling"
  <a href="http://openoffice.apache.org/">http://openoffice.apache.org/</a>
  site was established on June 13, 2011. Please join us in this new phase of OpenOffice.org by subscribing to our
  <a href="http://openoffice.apache.org/mailing-lists.html">mailing lists</a>.
  </p>

  <a id="apachemove"></a>
  <h2>Oracle Donates OpenOffice.org to Apache</h2>
  <p><em>1 June 2011:</em> In an
  <a href="http://www.marketwire.com/press-release/statements-on-openofficeorg-contribution-to-apache-nasdaq-orcl-1521400.htm">
  announcement</a> made today, Oracle has donated the OpenOffice.org project to the Apache Software Foundation. The proposal
  calls for OpenOffice.org to be established as an incubator project.
  </p>
  
  <a id="commercialsupoort"></a>
  <h2>Oracle Stops Support for Commercial OpenOffice.org</h2>
  <p><em>15 April 2011:</em> Oracle Corporation today
  <a href="http://www.marketwire.com/press-release/oracle-announces-its-intention-to-move-openofficeorg-to-a-community-based-project-nasdaq-orcl-1503027.htm">
  has announced</a> its intention to move OpenOffice.org to a purely community-based open source project and no longer offer
  a commercial version of Open Office (formerly named Oracle Open Office, when the development was at Sun the name was
  StarOffice).
  </p>

  <a id="OOo340beta"></a>
  <h2>OpenOffice.org 3.4 Beta Release</h2>
  <p><em>12 April 2011:</em> We are happy to announce that
  <a href="/download/all_beta.html">OpenOffice.org 3.4 Beta is now ready for download</a>. This Beta Release is available in
  English and 69 additional languages which can be installed as language packs (localizations are still ongoing). Feel free
  to download, test and give feedback. The best way to test is under real life conditions. OpenOffice.org is a community
  effort and your input will help to make OpenOffice.org 3.4 even better!
  <br />
  The Beta testing period ends on May 2<sup>nd</sup>. Take advantage of this evaluation period to take a closer look at the
  <a href="http://wiki.services.openoffice.org/wiki/Feature_Freeze_Testing_3.4">new SVG import, the improved ODF 1.2 support
  and other enhancements</a>and help to find open issues. The following are the preferred ways to provide feedback. Happy
  testing!</p>
  <br />
  <ul>
    <li>send a mail to the mailing list <a href="mailto:qa@openoffice.apache.org">qa@openoffice.apache.org</a> with the
    subject line starting with *Beta 3.4*</li>
    <li>submit an issue in <a href="http://qa.openoffice.org/issue_handling/pre_submission.html">BugZilla</a></li>
  </ul>

  <a id="cebit2011"></a>
  <h2>OpenOffice.org at CeBIT 2011</h2>
  <p><em>28 February 2011:</em> The OpenOffice.org team is at this year's <a href="http://www.cebit.com">CeBIT</a> again with
  a stand in the open source park (hall 2, D44, 145), demoing the new version 3.3. Visitors can meet the community and find
  out more about the product and the project. Migration and training are the focus this year, so don't miss the chance to
  talk with our experts.
  </p>

  <a id="OOo340alpha"></a>
  <h2>OpenOffice.org 3.4 Alpha Release</h2>
  <p><em>28 February 2011:</em> On the way to the next release we have published <a href="/download/next/other.html">
  OpenOffice.org 3.4 Alpha</a> (Developer Snapshot DEV300m101).
  See the <a href="http://wiki.services.openoffice.org/wiki/Feature_Freeze_Testing_3.4">overview about some highlights</a> or
  <a href="http://development.openoffice.org/releases/DEV300m101_snapshot.html">Technical Release Notes</a>. Please note
  that this Alpha release will be available until Developer Snapshot DEV300m103 will be published.
  </p>

  <a id="move"></a>
  <h2>Welcome at the OpenOffice.org site based on Project Kenai</h2>
  <p><em>24 February 2011:</em> The move to a the new framework is finished. Registered users will receive a notification via
  direct mail in the next 1-2 days. Please find <a href="http://kenai.com/projects/ooo-migration/pages/Home">
  more information</a>, some hints about the new site and a list for feedback at
  <a href="http://kenai.com/projects/ooo-migration/pages/Home">http://kenai.com/projects/ooo-migration/pages/Home</a>. Feel
  free to raise problems with the new platform that hinder you to join the collaboration and please bear with us during
  initial hiccups.
  </p>
  
  <h2>Move of the OpenOffice.org Site</h2>
  <p><em>16 February 2011:</em> The OpenOffice.org main site moves to a new infrastructure starting Monday February 21. It
  will be in read-only mode for 4-5 days.</p>
  <p>The move is going to include main site services like publishing of web content, mailing lists, bugtracking, ... and the
  existing data content of those. Projects are locked and mails (lists and user forwarding) are queued during the migration
  process. Satellite sites like OpenOffice.org forums, extensions and templates sites, Wiki, mercurial repositories, ... are
  not affected.</p>
  <p>Please find <a href="http://kenai.com/projects/ooo-migration/pages/Home">more information</a>, some hints about the new
  site and a mail list that continues to work during the migration at
  <a href="http://kenai.com/projects/ooo-migration/pages/Home">http://kenai.com/projects/ooo-migration/pages/Home</a>.
  </p>

  <a id="OOo330"></a>
  <h2>OpenOffice.org 3.3 is available for download!</h2>
  <p><em>26 January 2011:</em> The newest Release of OpenOffice.org is out now and <a href="/download">
  available for download</a>. This is a feature release. Check the <a href="/dev_docs/features/3.3/index.html">
  Feature Overview</a> to learn more about the new features. The technical
  <a href="http://development.openoffice.org/releases/3.3.0.html">Release Notes</a> are also available.
  </p>

  <a id="OOo330rc10"></a>
  <h2>Release Candidate 10 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>21 January 2011:</em> The newest Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc9"></a>
  <h2>Release Candidate 9 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>14 January 2011:</em> The newest Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc8"></a>
  <h2>Release Candidate 8 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>17 December 2010:</em> The newest Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc7"></a>
  <h2>Release Candidate 7 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>29 November 2010:</em> The newest Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc6"></a>
  <h2>Release Candidate 6 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>23 November 2010:</em> The newest Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc5"></a>
  <h2>Release Candidate 5 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>17 November 2010:</em> The fifth Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc4"></a>
  <h2>Release Candidate 4 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>10 November 2010:</em> The fourth Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc3"></a>
  <h2>Release Candidate 3 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>01 November 2010:</em> The third Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc2"></a>
  <h2>Release Candidate 2 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>25 October 2010:</em> The second Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="OOo330rc1"></a>
  <h2>Release Candidate 1 for OpenOffice.org 3.3.0 is now available for testing</h2>
  <p><em>19 October 2010:</em> The first Release Candidate for OpenOffice.org 3.3.0 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.3.0 are described in detail in the
  <a href="/dev_docs/features/3.3/index.html">New Features overview</a>.
  </p>

  <a id="tenth_birthday"></a>
  <h2 style="background-color: white; border: none">It's our 10th birthday!<br />
  <a href="http://wiki.services.openoffice.org/wiki/A_Brief_History_Of_OpenOffice.org" title="It's our 10th birthday!">
	  <img src="/images/OOo_cake_smaller.png" alt="It's our 10th birthday!" /></a></h2>
  <p><em>12 October 2010:</em> Have some <a href="http://www.facebook.com/photo.php?fbid=165650950114082"
  title="Celebration on Facebook">cake!</a> Read our
  <a href="http://wiki.services.openoffice.org/wiki/A_Brief_History_Of_OpenOffice.org" title="History of OpenOffice.org">
  history!</a> Let's <a href="http://www.youtube.com/watch?v=nVIfW92XzBA" title="Celebration on YouTube">celebrate!</a>
  <b><a href="/OO_thankyou.odt" title="Thank You to everyone who got us here!"> Thank You</a></b> to everyone who got us
  here!
  </p>

  <a id="OOo33beta"></a>
  <h2>Beta Release of OpenOffice.org 3.3</h2>
  <p><em>10 August 2010:</em> Today we are announcing our new <a href="/download/all_beta.html">Beta Release</a>. Check out
  the new <a href="http://wiki.services.openoffice.org/wiki/Feature_Freeze_Testing_3.3">features and enhancements</a> for
  the upcoming OpenOffice.org 3.3 release.
  </p>

  <a id="softonic0610"></a>
  <h2>OpenOffice.org 3.2.1 receives Editor's Choice Award at Softonic with exceptional rating</h2>
  <a href="http://openoffice.en.softonic.com?ptn=bdg"
  title="OpenOffice.org 3.2.1 receives Editor's Choice Award at Softonic with exceptional rating">
  <img src="https://e3.sftcdn.net/shared/images/badges/badge_editor.gif"
  alt="OpenOffice.org 3.2.1 receives Editor's Choice Award at Softonic with exceptional rating" /></a>
  <a href="http://openoffice.en.softonic.com?ptn=bdg"
  title="OpenOffice.org 3.2.1 receives Editor's Choice Award at Softonic with exceptional rating">
  <img src="https://openoffice.en.softonic.com/award.png"
  alt="OpenOffice.org 3.2.1 receives Editor's Choice Award at Softonic with exceptional rating" /></a> 
  <p><em>10 June 2010:</em> OpenOffice.org 3.2.1 receives the Editor's Choice Award at Softonic with an exceptional rating
  of 4.5 stars!<br />
  </p>

  <a id="OOo321"></a>
  <h2>OpenOffice.org 3.2.1 is now available for download</h2>
  <p><em>04 June 2010:</em> OpenOffice.org 3.2.1 is now <a href="/download"> available for download</a>. This is a bugfix
  release but shows also a refreshed brand from OpenOffice.org's new sponsor Oracle. The
  <a href="http://development.openoffice.org/releases/3.2.1.html">Release Notes</a> show the changes. The details about
  <a href="/trademark/brandrefresh.html">Brand Refresh</a> are here.
  </p>

  <a id="OOo321rc2"></a>
  <h2>Release Candidate 2 for OpenOffice.org 3.2.1 is now available for testing</h2>
  <p><em>28 May 2010:</em> The second Release Candidate for OpenOffice.org 3.2.1 is
  <a href="/download/all_rc.html">available for testing</a> since today. New things in 3.2 are described in detail on
  <a href="/dev_docs/features/3.2/"> this website</a>.
  </p>

  <a id="internship"></a>
  <h2>OpenOffice.org Summer Internship Programme</h2>
  <p><em>18 May 2010:</em> The <a href="http://wiki.services.openoffice.org/wiki/OpenOffice.org_Internship">
  OpenOffice.org Summer Internship Programme</a> has been launched.</p>

  <a id="OOo321rc1"></a>
  <h2>Release Candidate 1 for OpenOffice.org 3.2.1 is now available for testing</h2>
  <p><em>28 May 2010:</em> The first Release Candidate for OpenOffice.org 3.2.1 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.2 are described in detail on <a href="/dev_docs/features/3.2/">
  this website</a>.
  </p>

  <a id="bos2009"></a>
  <h2>PortalProgramas.com awards us Best Open Source 2009</h2>
  <a href="http://gratis.portalprogramas.com/OpenOffice.html" title="PortalProgramas.com awards us Best Open Source 2009">
  <img src="bestOpenSource.png" alt="PortalProgramas.com awards us Best Open Source 2009" /></a>
  <p><em>15 February 2010:</em> OpenOffice.org has been awarded the
  <a href="http://gratis.portalprogramas.com/OpenOffice.html">Best Open Source 2009 Award</a> by
  <a href="http://www.portalprogramas.com/premios-mejor-software-libre/">PortalProgramas.com</a>.
  </p>

  <a id="OOo32"></a>
  <h2>OpenOffice.org 3.2 is now available for download</h2>
  <p><em>11 February 2010:</em> OpenOffice.org 3.2 is now <a href="/download"> available for download</a>. New features are
  described in detail on <a href="/dev_docs/features/3.2/"> this website</a>.
  </p>

  <a id="OOo32rc5"></a>
  <h2>Release Candidate 5 for OpenOffice.org 3.2 is now available for testing</h2>
  <p><em>04 February 2010:</em> The fifth Release Candidate for OpenOffice.org 3.2 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.2 are described in detail on
  <a href="/dev_docs/features/3.2/rc2.html">this website</a>.
  </p>

  <a id="About.comAwards"></a>
  <h2>About.com Reader's Choice Awards 2010 - Nomination</h2>
  <a href="http://macs.about.com/od/readertoreader/ss/readers-choice-2010-vote.htm"
  title="About.com Reader's Choice Awards 2010 - Nomination">
  <img src="rca_nominee_badge90x112.jpg" alt="About.com Reader's Choice Awards 2010 - Nomination" width="90"
  height="112" /></a>
  <p><em>01 February 2010:</em> OpenOffice.org has been nominated in the
  <a href="http://macs.about.com/od/readertoreader/ss/readers-choice-2010-vote.htm">
  About.com Reader's Choice Awards 2010</a>. Don't miss to vote for us!
  </p>
  <!-- end real news items -->

  <!-- <div class="campaign">
  <h2>Want more news?</h2>
  <p>For monthly updates, subscribe to the <a href="/editorial/spotlightindex.html">OpenOffice.org Newsletter</a>, or follow
  <a href="/editorial/blogs.html">OpenOffice.org Bloggers</a> for the very latest news and rumours.
  </p>
  </div> -->

  <a id="oraclesun"></a>
  <h2>Oracle Completes Acquisition of Sun</h2>
  <p><em>27 January 2010:</em> Oracle completes the acquisition of Sun Microsystems and invites to view the Oracle + Sun
  Product Strategy <a href="http://www.oracle.com/events/productstrategy/index.html">Webcast series</a> including one
  demonstrating the continued
  <a href="http://oracle.com.edgesuite.net/ivt/4000/8104/9236/12637/lobby_external_flash_clean_480x360/default.htm">
  commitment to office productivity</a>.
  </p>

  <a id="OOo32rc4"></a>
  <h2>Release Candidate 4 for OpenOffice.org 3.2 is now available for testing</h2>
  <p><em>27 January 2010:</em> The fourth Release Candidate for OpenOffice.org 3.2 is <a href="/download/all_rc.html">
  available for testing</a> since today. New things in 3.2 are described in detail on
  <a href="/dev_docs/features/3.2/rc2.html">this website</a>.
  </p>

  <a id="OOo32rc3"></a>
  <h2>Release Candidate 3 for OpenOffice.org 3.2 is now available for testing</h2>
  <p><em>20 January 2010:</em> The third Release Candidate for OpenOffice.org 3.2 is now <a href="/download/all_rc.html">
  available for testing</a>. All new things in 3.2 are described on <a href="/dev_docs/features/3.2/rc2.html">
  this website</a>.
  </p>
  
  <a id="ooocon2011cfl"></a>
  <h2>OpenOffice.org Conference 2011 - Call for Location</h2>
  <p><em>18 January 2010:</em> The OpenOffice.org Community is now accepting proposals for hosting its annual international
  conference in 2011. Since the first conference in 2003, OOoCon has been held in Germany, Slovenia, France, Spain, China
  and Italy, and will be held in Hungary in the fall of 2010 - could your local OpenOffice.org community rise to the
  challenge in 2011? More details are <a href="http://marketing.openoffice.org/ooocon2011/cfl/cfl.html">available here</a>.
  </p>

  <a id="OOo32rc2"></a>
  <h2>Release Candidate 2 for OpenOffice.org 3.2 is now available for testing</h2>
  <p><em>14 January 2010:</em> The second Release Candidate for OpenOffice.org 3.2 is now <a href="/download/all_rc.html">
  available for testing</a>. The new features in 3.2 are described <a href="/dev_docs/features/3.2/rc2.html">here</a>.
  </p>
  
  <a id="OOo32rc1"></a>
  <h2>The first Release Candidate for OpenOffice.org 3.2 is now available for testing</h2>
  <p><em>21 December 2009:</em> The first Release Candidate for OpenOffice.org 3.2 is now <a href="/download/all_rc.html">
  available for testing</a>. For further information on what a Release Candidate is, please see the
  <a href="/download/next/index.html">Developer Builds Downloads</a> page. The new features in 3.2 are described
  <a href="/dev_docs/features/3.2/rc1.html">here</a>.
  </p>

  <a id="one_hundred_mio"></a>
  <h2>100,000,000 downloads of OpenOffice.org 3</h2>
  <p><em>29 October 2009:</em> On October 28th. 2009, the one hundred millionth person clicked on the
  <a href="/download">Download OpenOffice.org button</a> since version 3.0 of the software was announced just over one year
  ago. Join in the celebrations leading up to <a href="http://conference.services.openoffice.org/index.php/ooocon/2009">
  OOoCon 2009</a> - the "Cento Milioni" conference - in Orvieto, Italy from November 4th-6th 2009.
  </p>

  <a id="plan"></a>
  <h2>Oracle's Plan for OpenOffice.org</h2>
  <p><em>27 October 2009:</em>
  An updated version of the <a href="http://www.oracle.com/us/sun/038563.pdf">FAQ</a> on
  <a href="http://www.oracle.com/us/sun/index.htm">Oracle and Sun</a> contains a section which expresses Oracle's intend to
  continue developing and supporting OpenOffice.org as open source.
  </p>

  <h2>Beta Release of OpenOffice.org 3.2</h2>
  <p><em>4 September 2009:</em> Have a look at the 
  <a href="http://wiki.services.openoffice.org/wiki/Feature_Freeze_Testing_3.2">features and enhancements</a> of the upcoming
  OpenOffice.org 3.2 release <a href="/download/next/">with our beta version</a>. The final release is expected in December.
  </p>
  
  <h2>OpenOffice.org 2.4.3 is available for download</h2>
  <p><em>4 September 2009:</em> OpenOffice.org 2.4.3 was officially released today for users of the legacy series. Read all
  about <a href="http://development.openoffice.org/releases/2.4.3.html">the release</a> and <a href="/download/">
  download it</a> now!
  </p>

  <h2>OpenOffice.org 3.1.1 is available for download</h2>
  <p><em>31 August 2009:</em> OpenOffice.org 3.1.1 was officially released to the world today. Read all about
  <a href="http://development.openoffice.org/releases/3.1.1.html">the release</a> and <a href="/download/">download it</a>
  now!
  </p>

  <h2>OOoCon Call for Papers</h2>
  <p>Send in your proposals for this year's <a href="http://conference.services.openoffice.org/index.php/ooocon/2009">
  OpenOffice.org Conference</a>!
  </p>

  <h2>OpenOffice.org 3.1 is available for download</h2>
  <p><em>07 May 2009:</em> OpenOffice.org 3.1 was officially released to the world at 09:00 UTC today. Read all about the
  <a href="/dev_docs/features/3.1/index.html">new features</a> in this release and <a href="/download/">download it</a> now!
  </p>

  <h2>OpenOffice.org scoops <em>Favorite Office Software</em> Award</h2>
  <p><em>01 May 2009:</em> Linux Journal is proud to announce that OpenOffice has won its 2009 Readers' Choice Award for
  "Favorite Office Program". See our <a href="/awards/">Awards Page.</a>
  </p>

  <h2>50 million downloads</h2>
  <p><em>26 Mar 2009:</em> Yesterday we recorded the 50 millionth download of OpenOffice.org from
  <a href="/download/">/download</a> since OpenOffice.org 3.0 was released in October last year. The download counter is
  updated every day and can be seen on the <a href="http://marketing.openoffice.org/planet/">Marketing Planet</a>.
  Congratulations to all the community members who contributed to such a fabulously successful product!
  </p>

  <h2>A new Planet</h2>
  <p><em>10 Mar 2009:</em> Read the new <a href="http://planet.services.openoffice.org/">OpenOffice.org Planet</a> for all
  the blogs worth reading on OpenOffice.org topics.
  </p>

  <h2>Meet us at CeBIT!</h2>
  <p>OpenOffice.org will be at CeBIT in Hannover, Germany, from March 3rd until March 8th. Visit us in hall 6, booth E46-12
  and listen to one of our <a href="http://www.ooodev.org/termine/aktuelle_termine/cebit_2009.html">lectures</a>!
  </p>

  <h2>OpenOffice.org 3.0.1 released</h2>
  <p>OpenOffice.org 3.0.1 has been released. <a href="/download">Download your copy now.</a>
  </p>

  <h2>We're off the scale!</h2>
  <p><em>09 Dec 2008:</em> The <a href="thermometer.png">download thermometer</a> hit the 20 million mark and will no longer
  be updated. For the latest statistics, see the <a href="http://marketing.openoffice.org/marketing_bouncer.html">
  Bouncer statistics</a>.
  </p>

  <h2>Have you checked the temperature?</h2>
  <p><em>15 Nov 2008:</em> Our <a href="thermometer.png">download thermometer</a> has been updated with the latest
  <a href="http://marketing.openoffice.org/marketing_bouncer.html">Bouncer statistics</a>.
  </p>

  <h2>OpenOffice.org 2.4.2 available</h2>
  <p><em>29 Oct 2008:</em> The OpenOffice.org Community is pleased to announce the release of OpenOffice.org 2.4.2, a minor
  update of OpenOffice.org 2.4.1 released in June 2008. OpenOffice.org 2.4.2 (en-US for Microsoft Windows, GNU/Linux, and
  Solaris) is available for immediate download from <a href="/download">/download</a>. Please contact the appropriate
  native-language project <a href="/projects/native-lang.html">/projects/native-lang.html</a> for details of availability in
  other languages, and the appropriate porting project <a href="http://porting.openoffice.org">
  http://porting.openoffice.org</a> for details of other platforms.
  </p>

  <h2>OpenOffice.org 3.0 is hot</h2>
  <p><em>26 Oct 2008:</em> Our <a href="thermometer.png">download thermometer</a> shows how hot OpenOffice.org is! Note: the
  thermometer uses data obtained via <a href="/download">our download page</a>. It does not show downloads via other sources
  - e.g. Linux users who obtain OpenOffice.org 3.0 directly from their Linux distribution.
  </p>

  <h2>OpenOffice.org 3.0 is available now</h2>
  <p><em>13 Oct 2008:</em> Following three years of continuous improvement, OpenOffice.org has now reached the landmark
  version 3.0, with a <a href="/dev_docs/features/3.0/">host of new features</a> including native support for Mac OS X users.
  Head to <a href="/download">/download</a> to download the en-US, da, de, fr, it, ja, ru, sv versions, and monitor the
  <a href="/download/other.html">platforms and languages page</a> for details of the availability of other versions.
  </p>

  <!--
  <h2>NetBeans is ten</h2>
  <p align="left"><img src="../../../look/www/overrides/static/csi/images/logo-10y-nb-since1998-180.png" width="180"
  height="180" /></p>
  -->

  <p><em>20 October 2008:</em> <a href="http://www.netbeans.org/">NetBeans</a>, the open-source platform and IDE for Java
  development celebrates its 10th birthday 20 October, a week after OpenOffice.org celebrated its 8th. But the interesting
  point about NetBeans for OpenOffice.org developers is its integration with OpenOffice.org. With NetBeans, one can easily
  write extensions, and that's only a start. See:
  </p>

  <ul>
    <li>
      OpenOffice.org. NetBeans Integration<br />
      <a href="http://wiki.services.openoffice.org/wiki/OpenOffice_NetBeans_Integration">
      http://wiki.services.openoffice.org/wiki/OpenOffice_NetBeans_Integration</a>
    </li>
    <li>
      OpenOffice.org Extensions with NetBeans LAB-9410<br />
      <a href="http://developers.sun.com/learning/javaoneonline/j1lab.jsp?lab=LAB-9410%20&amp;yr=2008&amp;track=1">
      http://developers.sun.com/learning/javaoneonline/j1lab.jsp?lab=LAB-9410%20&amp;yr=2008&amp;track=1</a>
    </li>
    <li>Using OpenOffice.org. API to generate PDF documents<br />
      <a href="http://blogs.sun.com/sebsto/entry/using_openoffice_api_to_generate">
      http://blogs.sun.com/sebsto/entry/using_openoffice_api_to_generate</a>
    </li>
  </ul>

  <p>In a similar light, the <a href="http://www.eclipse.org/">Eclipse</a> open-source framework also provides powerful
  tools for creating OpenOffice.org extensions. See:
  </p>

  <ul>
    <li>
      <a href="http://wiki.services.openoffice.org/wiki/OpenOffice_Eclipse_Integration%20">
      http://wiki.services.openoffice.org/wiki/OpenOffice_Eclipse_Integration</a>
    </li>
  </ul>

  <p>&nbsp;</p>

  <h2>Community Innovation Program winners announced</h2>
  <p><em>06 Oct 2008:</em> The Program Committee has published the names of the winners (including team leaders) to this
  important competition held the first half of this year and funded by Sun Microsystems. To learn who won and what they did
  (and are doing), see the Community Innovation Program Pages.
  </p>

  <ul>
    <li>
      Community Innovation Program <a href="http://development.openoffice.org/community_innovation_program.html">HTML</a> |
      <a href="http://development.openoffice.org/community_innovation_program.pdf">PDF</a>
    </li>
    <li>
      <a href="http://development.openoffice.org/awardees-2008.html">Winners</a> |
      <a href="http://development.openoffice.org/community_innovation_program_winners.html">Categories</a>
    </li>
  </ul>

  <h2>ODF Olympiad 2008</h2>

  <p><em>20 Sep 2008:</em> The ODF Olympiad launches today! The ODF--short for OpenDocument Format--is a fundamentally
  important format that gives to tens of millions around the world invaluable access to electronic documents. OpenOffice.org
  proudly stands as the primary implementation of this format. The Olympiad, which is global, is open to all students, and
  we invite them to participate.
  </p>

  <ul>
    <li>
      <a href="http://www.odfolympiad.org/">ODF Olympiad</a>
    </li>
  </ul>

  <h2>Prize awarded</h2>

  <h3>SourceForge.net 2008 Community Choice Awards</h3>
  <p>OpenOffice.org was awarded three prizes in the <a href="http://sourceforge.net/community/cca08">
  SourceForge.net 2008 Community Choice Awards</a>! Thanks to all our users for their votes!
  </p>

  <h3>InfoWorld: 2008 Bossie Award</h3>
  <p>OpenOffice.org was considered the <a href="http://www.infoworld.com/article/08/08/04/32TC-bossies-2008_1.html">
  "Best of open source productivity application,"</a> an award chosen by InfoWorld Test Center editors, analysts, and
  reviewers.
  </p>

  <h2>OOoCon 2008: Beijing</h2>
  <p>The OpenOffice.org Community Conference, OOoCon, will take place 5-7 November in Beijing. The event, which promises to
  be as enjoyable as it will be important, will mark the first time OOoCon has taken place outside of Europe, and for this
  we thank the primary host, Redflag 2000 and the Chinese and East Asian OpenOffice.org community.
  </p>

  <p>We invite all to participate! For more information, including travel and registration details, please visit the site:
  </p>

  <ul>
    <li>
      <a href="http://marketing.openoffice.org/ooocon2008/">http://marketing.openoffice.org/ooocon2008/</a>
    </li>
  </ul>

  <h2>Events</h2>

  <table style="border-collapse:collapse; border-spacing: 2px; float: left">
    <tbody>
      <tr>
        <td class="headcol">5-7 Nov.</td>
        <td><a href="http://marketing.openoffice.org/ooocon2008/">OOoCon 2008</a>, Beijing, China</td>
      </tr>
      <tr>
        <td class="headcol">19-22 Oct.</td>
        <td><a href="http://www.opensourceworldconference.com/">Open Source World Conference</a>, Málaga, Spain</td>
      </tr>
    </tbody>
  </table>
  <br /><br />

  <h2 style="clear: left">In the media</h2>

  <p>What other sources have to say about us...</p>

  <table style="border-collapse:collapse; border-spacing: 2px; float: left">
    <tbody>
      <tr>
        <td class="headcol">30 Sep.</td>
        <td><a href="http://news.bbc.co.uk/2/hi/technology/7642985.stm">Venezuela's 1M laptops for schools</a></td>
      </tr>
      <tr>
        <td class="headcol">26 Sep.</td>
        <td><a href="http://blogs.sun.com/webmink/entry/openoffice_org_power_tools">Phipps: OOo Power Tools</a></td>
      </tr>
      <tr>
        <td class="headcol">23 Sep.</td>
        <td><a href="http://www.theregister.co.uk/2008/09/23/becta_open_source_schools_at_last/">
        BECTA Green lights FOSS in UK schools</a></td>
      </tr>
      <tr>
        <td class="headcol">22 Sep.</td>
        <td><a href="http://www.linuxplanet.com/linuxplanet/tutorials/6537/1/">
        OOo Tricks: Making OOo more MS Office friendly</a></td>
      </tr>
    </tbody>
  </table>
  <br /><br />

  <!-- <h2 style="clear: left">OpenOffice.org Blogs</h2>

  <p>And what we say about ourselves...</p>

  <ul>
    <li>
      <a href="/editorial/blogs.html">OpenOffice.org blogs</a>
    </li>
    <li>
      <a href="http://marketing.openoffice.org/planet/">Marketing Planet</a>
    </li>
    <li>
      <a href="http://native-lang.openoffice.org/planet/">
      Native Languages Planet</a>
    </li>
  </ul>

  <p><a href="https://validator.w3.org/check?uri=referer"
  title="W3C Markup Validation Service - Check the markup (HTML, XHTML, ...) of Web documents">
  <img src="https://www.w3.org/Icons/valid-xhtml10-blue.png"
  alt="W3C Markup Validation Service - Check the markup (HTML, XHTML, ...) of Web documents" /></a></p>
  -->

</body>
</html>

